# 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.

"""
Pivy is a Coin binding for Python. Coin is a high-level 3D graphics
library with a C++ Application Programming Interface. Coin uses
scene-graph data structures to render real-time graphics suitable for
mostly all kinds of scientific and engineering visualization
applications.
"""

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 _coin
else:
    import _coin

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 charp(object):
    r"""Proxy of C++ charp class."""

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

    def __init__(self):
        r"""__init__(charp self) -> charp"""
        _coin.charp_swiginit(self, _coin.new_charp())
    __swig_destroy__ = _coin.delete_charp

    def assign(self, value: "char") -> "void":
        r"""assign(charp self, char value)"""
        return _coin.charp_assign(self, value)

    def value(self) -> "char":
        r"""value(charp self) -> char"""
        return _coin.charp_value(self)

    def cast(self) -> "char *":
        r"""cast(charp self) -> char *"""
        return _coin.charp_cast(self)

    @staticmethod
    def frompointer(t: "char *") -> "charp *":
        r"""frompointer(char * t) -> charp"""
        return _coin.charp_frompointer(t)

# Register charp in _coin:
_coin.charp_swigregister(charp)
cast = _coin.cast

def charp_frompointer(t: "char *") -> "charp *":
    r"""charp_frompointer(char * t) -> charp"""
    return _coin.charp_frompointer(t)

class intp(object):
    r"""Proxy of C++ intp class."""

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

    def __init__(self):
        r"""__init__(intp self) -> intp"""
        _coin.intp_swiginit(self, _coin.new_intp())
    __swig_destroy__ = _coin.delete_intp

    def assign(self, value: "int") -> "void":
        r"""assign(intp self, int value)"""
        return _coin.intp_assign(self, value)

    def value(self) -> "int":
        r"""value(intp self) -> int"""
        return _coin.intp_value(self)

    def cast(self) -> "int *":
        r"""cast(intp self) -> int *"""
        return _coin.intp_cast(self)

    @staticmethod
    def frompointer(t: "int *") -> "intp *":
        r"""frompointer(int * t) -> intp"""
        return _coin.intp_frompointer(t)

# Register intp in _coin:
_coin.intp_swigregister(intp)

def intp_frompointer(t: "int *") -> "intp *":
    r"""intp_frompointer(int * t) -> intp"""
    return _coin.intp_frompointer(t)

class longp(object):
    r"""Proxy of C++ longp class."""

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

    def __init__(self):
        r"""__init__(longp self) -> longp"""
        _coin.longp_swiginit(self, _coin.new_longp())
    __swig_destroy__ = _coin.delete_longp

    def assign(self, value: "long") -> "void":
        r"""assign(longp self, long value)"""
        return _coin.longp_assign(self, value)

    def value(self) -> "long":
        r"""value(longp self) -> long"""
        return _coin.longp_value(self)

    def cast(self) -> "long *":
        r"""cast(longp self) -> long *"""
        return _coin.longp_cast(self)

    @staticmethod
    def frompointer(t: "long *") -> "longp *":
        r"""frompointer(long * t) -> longp"""
        return _coin.longp_frompointer(t)

# Register longp in _coin:
_coin.longp_swigregister(longp)

def longp_frompointer(t: "long *") -> "longp *":
    r"""longp_frompointer(long * t) -> longp"""
    return _coin.longp_frompointer(t)

class floatp(object):
    r"""Proxy of C++ floatp class."""

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

    def __init__(self):
        r"""__init__(floatp self) -> floatp"""
        _coin.floatp_swiginit(self, _coin.new_floatp())
    __swig_destroy__ = _coin.delete_floatp

    def assign(self, value: "float") -> "void":
        r"""assign(floatp self, float value)"""
        return _coin.floatp_assign(self, value)

    def value(self) -> "float":
        r"""value(floatp self) -> float"""
        return _coin.floatp_value(self)

    def cast(self) -> "float *":
        r"""cast(floatp self) -> float *"""
        return _coin.floatp_cast(self)

    @staticmethod
    def frompointer(t: "float *") -> "floatp *":
        r"""frompointer(float * t) -> floatp"""
        return _coin.floatp_frompointer(t)

# Register floatp in _coin:
_coin.floatp_swigregister(floatp)

def floatp_frompointer(t: "float *") -> "floatp *":
    r"""floatp_frompointer(float * t) -> floatp"""
    return _coin.floatp_frompointer(t)

class doublep(object):
    r"""Proxy of C++ doublep class."""

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

    def __init__(self):
        r"""__init__(doublep self) -> doublep"""
        _coin.doublep_swiginit(self, _coin.new_doublep())
    __swig_destroy__ = _coin.delete_doublep

    def assign(self, value: "double") -> "void":
        r"""assign(doublep self, double value)"""
        return _coin.doublep_assign(self, value)

    def value(self) -> "double":
        r"""value(doublep self) -> double"""
        return _coin.doublep_value(self)

    def cast(self) -> "double *":
        r"""cast(doublep self) -> double *"""
        return _coin.doublep_cast(self)

    @staticmethod
    def frompointer(t: "double *") -> "doublep *":
        r"""frompointer(double * t) -> doublep"""
        return _coin.doublep_frompointer(t)

# Register doublep in _coin:
_coin.doublep_swigregister(doublep)

def doublep_frompointer(t: "double *") -> "doublep *":
    r"""doublep_frompointer(double * t) -> doublep"""
    return _coin.doublep_frompointer(t)

FALSE = _coin.FALSE

TRUE = _coin.TRUE

HAVE_INTTYPES_H = _coin.HAVE_INTTYPES_H

HAVE_STDINT_H = _coin.HAVE_STDINT_H

HAVE_SYS_TYPES_H = _coin.HAVE_SYS_TYPES_H

HAVE_STDDEF_H = _coin.HAVE_STDDEF_H

HAVE_INT8_T = _coin.HAVE_INT8_T

HAVE_UINT8_T = _coin.HAVE_UINT8_T

HAVE_INT16_T = _coin.HAVE_INT16_T

HAVE_UINT16_T = _coin.HAVE_UINT16_T

HAVE_INT32_T = _coin.HAVE_INT32_T

HAVE_UINT32_T = _coin.HAVE_UINT32_T

HAVE_INT64_T = _coin.HAVE_INT64_T

HAVE_UINT64_T = _coin.HAVE_UINT64_T

HAVE_INTPTR_T = _coin.HAVE_INTPTR_T

HAVE_UINTPTR_T = _coin.HAVE_UINTPTR_T

M_E = _coin.M_E

M_LOG2E = _coin.M_LOG2E

M_LOG10E = _coin.M_LOG10E

M_LN2 = _coin.M_LN2

M_LN10 = _coin.M_LN10

M_PI = _coin.M_PI

M_TWOPI = _coin.M_TWOPI

M_PI_2 = _coin.M_PI_2

M_PI_4 = _coin.M_PI_4

M_3PI_4 = _coin.M_3PI_4

M_SQRTPI = _coin.M_SQRTPI

M_1_PI = _coin.M_1_PI

M_2_PI = _coin.M_2_PI

M_2_SQRTPI = _coin.M_2_SQRTPI

M_SQRT2 = _coin.M_SQRT2

M_SQRT1_2 = _coin.M_SQRT1_2

M_LN2LO = _coin.M_LN2LO

M_LN2HI = _coin.M_LN2HI

M_SQRT3 = _coin.M_SQRT3

M_IVLN10 = _coin.M_IVLN10

M_LOG2_E = _coin.M_LOG2_E

M_INVLN2 = _coin.M_INVLN2

COIN_MAJOR_VERSION = _coin.COIN_MAJOR_VERSION

COIN_MINOR_VERSION = _coin.COIN_MINOR_VERSION

COIN_MICRO_VERSION = _coin.COIN_MICRO_VERSION

COIN_VERSION = _coin.COIN_VERSION

HAVE_HASH_QUOTING = _coin.HAVE_HASH_QUOTING

SUN_CC_4_0_SOTYPE_INIT_BUG = _coin.SUN_CC_4_0_SOTYPE_INIT_BUG

class SbDict(object):
    r"""Proxy of C++ SbDict class."""

    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):
        r"""
        __init__(SbDict self, int const entries=251) -> SbDict
        __init__(SbDict self, SbDict srcFrom) -> SbDict
        """
        _coin.SbDict_swiginit(self, _coin.new_SbDict(*args))
    __swig_destroy__ = _coin.delete_SbDict

    def applyToAll(self, *args) -> "void":
        r"""
        applyToAll(SbDict self, SbDictApplyFunc * rtn)
        applyToAll(SbDict self, SbDictApplyDataFunc * rtn, void * data)
        """
        return _coin.SbDict_applyToAll(self, *args)

    def clear(self) -> "void":
        r"""clear(SbDict self)"""
        return _coin.SbDict_clear(self)

    def enter(self, key: "SbDict::Key const", value: "void *const") -> "SbBool":
        r"""enter(SbDict self, SbDict::Key const key, void *const value) -> SbBool"""
        return _coin.SbDict_enter(self, key, value)

    def find(self, key: "SbDict::Key const", value: "void *&") -> "SbBool":
        r"""find(SbDict self, SbDict::Key const key, void *& value) -> SbBool"""
        return _coin.SbDict_find(self, key, value)

    def makePList(self, keys: "SbPList", values: "SbPList") -> "void":
        r"""makePList(SbDict self, SbPList keys, SbPList values)"""
        return _coin.SbDict_makePList(self, keys, values)

    def remove(self, key: "SbDict::Key const") -> "SbBool":
        r"""remove(SbDict self, SbDict::Key const key) -> SbBool"""
        return _coin.SbDict_remove(self, key)

    def setHashingFunction(self, func: "SbDictHashingFunc *") -> "void":
        r"""setHashingFunction(SbDict self, SbDictHashingFunc * func)"""
        return _coin.SbDict_setHashingFunction(self, func)

# Register SbDict in _coin:
_coin.SbDict_swigregister(SbDict)

class SoType(object):
    r"""Proxy of C++ SoType class."""

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

    @staticmethod
    def fromName(name: "SbName") -> "SoType":
        r"""fromName(SbName name) -> SoType"""
        return _coin.SoType_fromName(name)

    def getName(self) -> "SbName":
        r"""getName(SoType self) -> SbName"""
        return _coin.SoType_getName(self)

    def getParent(self) -> "SoType const":
        r"""getParent(SoType self) -> SoType"""
        return _coin.SoType_getParent(self)

    def isDerivedFrom(self, type: "SoType") -> "SbBool":
        r"""isDerivedFrom(SoType self, SoType type) -> SbBool"""
        return _coin.SoType_isDerivedFrom(self, type)

    @staticmethod
    def getAllDerivedFrom(type: "SoType", list: "SoTypeList") -> "int":
        r"""getAllDerivedFrom(SoType type, SoTypeList list) -> int"""
        return _coin.SoType_getAllDerivedFrom(type, list)

    def canCreateInstance(self) -> "SbBool":
        r"""canCreateInstance(SoType self) -> SbBool"""
        return _coin.SoType_canCreateInstance(self)

    def getData(self) -> "uint16_t":
        r"""getData(SoType self) -> uint16_t"""
        return _coin.SoType_getData(self)

    def getKey(self) -> "int16_t":
        r"""getKey(SoType self) -> int16_t"""
        return _coin.SoType_getKey(self)

    def __eq__(self, type: "SoType") -> "SbBool":
        r"""__eq__(SoType self, SoType type) -> SbBool"""
        return _coin.SoType___eq__(self, type)

    def __ne__(self, type: "SoType") -> "SbBool":
        r"""__ne__(SoType self, SoType type) -> SbBool"""
        return _coin.SoType___ne__(self, type)

    def __lt__(self, type: "SoType") -> "SbBool":
        r"""__lt__(SoType self, SoType type) -> SbBool"""
        return _coin.SoType___lt__(self, type)

    def __le__(self, type: "SoType") -> "SbBool":
        r"""__le__(SoType self, SoType type) -> SbBool"""
        return _coin.SoType___le__(self, type)

    def __ge__(self, type: "SoType") -> "SbBool":
        r"""__ge__(SoType self, SoType type) -> SbBool"""
        return _coin.SoType___ge__(self, type)

    def __gt__(self, type: "SoType") -> "SbBool":
        r"""__gt__(SoType self, SoType type) -> SbBool"""
        return _coin.SoType___gt__(self, type)

    @staticmethod
    def removeType(name: "SbName") -> "SbBool":
        r"""removeType(SbName name) -> SbBool"""
        return _coin.SoType_removeType(name)

    @staticmethod
    def init() -> "void":
        r"""init()"""
        return _coin.SoType_init()

    @staticmethod
    def fromKey(key: "uint16_t") -> "SoType":
        r"""fromKey(uint16_t key) -> SoType"""
        return _coin.SoType_fromKey(key)

    @staticmethod
    def badType() -> "SoType":
        r"""badType() -> SoType"""
        return _coin.SoType_badType()

    def isBad(self) -> "SbBool":
        r"""isBad(SoType self) -> SbBool"""
        return _coin.SoType_isBad(self)

    def makeInternal(self) -> "void":
        r"""makeInternal(SoType self)"""
        return _coin.SoType_makeInternal(self)

    def isInternal(self) -> "SbBool":
        r"""isInternal(SoType self) -> SbBool"""
        return _coin.SoType_isInternal(self)

    @staticmethod
    def getNumTypes() -> "int":
        r"""getNumTypes() -> int"""
        return _coin.SoType_getNumTypes()

    def getInstantiationMethod(self) -> "SoType::instantiationMethod":
        r"""getInstantiationMethod(SoType self) -> SoType::instantiationMethod"""
        return _coin.SoType_getInstantiationMethod(self)

    def createInstance(self) -> "PyObject *":
        r"""createInstance(SoType self) -> PyObject *"""
        return _coin.SoType_createInstance(self)

    def __init__(self):
        r"""__init__(SoType self) -> SoType"""
        _coin.SoType_swiginit(self, _coin.new_SoType())
    __swig_destroy__ = _coin.delete_SoType

# Register SoType in _coin:
_coin.SoType_swigregister(SoType)

def SoType_fromName(name: "SbName") -> "SoType":
    r"""SoType_fromName(SbName name) -> SoType"""
    return _coin.SoType_fromName(name)

def SoType_getAllDerivedFrom(type: "SoType", list: "SoTypeList") -> "int":
    r"""SoType_getAllDerivedFrom(SoType type, SoTypeList list) -> int"""
    return _coin.SoType_getAllDerivedFrom(type, list)

def SoType_removeType(name: "SbName") -> "SbBool":
    r"""SoType_removeType(SbName name) -> SbBool"""
    return _coin.SoType_removeType(name)

def SoType_init() -> "void":
    r"""SoType_init()"""
    return _coin.SoType_init()

def SoType_fromKey(key: "uint16_t") -> "SoType":
    r"""SoType_fromKey(uint16_t key) -> SoType"""
    return _coin.SoType_fromKey(key)

def SoType_badType() -> "SoType":
    r"""SoType_badType() -> SoType"""
    return _coin.SoType_badType()

def SoType_getNumTypes() -> "int":
    r"""SoType_getNumTypes() -> int"""
    return _coin.SoType_getNumTypes()

class SbPList(object):
    r"""Proxy of C++ SbPList class."""

    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):
        r"""
        __init__(SbPList self, int const sizehint=) -> SbPList
        __init__(SbPList self, SbPList l) -> SbPList
        """
        _coin.SbPList_swiginit(self, _coin.new_SbPList(*args))
    __swig_destroy__ = _coin.delete_SbPList

    def copy(self, l: "SbPList") -> "void":
        r"""copy(SbPList self, SbPList l)"""
        return _coin.SbPList_copy(self, l)

    def fit(self) -> "void":
        r"""fit(SbPList self)"""
        return _coin.SbPList_fit(self)

    def append(self, item: "void *") -> "void":
        r"""append(SbPList self, void * item)"""
        return _coin.SbPList_append(self, item)

    def find(self, item: "void const *") -> "int":
        r"""find(SbPList self, void const * item) -> int"""
        return _coin.SbPList_find(self, item)

    def insert(self, item: "void *", insertbefore: "int const") -> "void":
        r"""insert(SbPList self, void * item, int const insertbefore)"""
        return _coin.SbPList_insert(self, item, insertbefore)

    def removeItem(self, item: "void *") -> "void":
        r"""removeItem(SbPList self, void * item)"""
        return _coin.SbPList_removeItem(self, item)

    def remove(self, index: "int const") -> "void":
        r"""remove(SbPList self, int const index)"""
        return _coin.SbPList_remove(self, index)

    def removeFast(self, index: "int const") -> "void":
        r"""removeFast(SbPList self, int const index)"""
        return _coin.SbPList_removeFast(self, index)

    def getLength(self) -> "int":
        r"""getLength(SbPList self) -> int"""
        return _coin.SbPList_getLength(self)

    def truncate(self, length: "int const", fit: "int const"=0) -> "void":
        r"""truncate(SbPList self, int const length, int const fit=0)"""
        return _coin.SbPList_truncate(self, length, fit)

    def getArrayPtr(self, start: "int const"=0) -> "void **":
        r"""getArrayPtr(SbPList self, int const start=0)"""
        return _coin.SbPList_getArrayPtr(self, start)

    def __eq__(self, l: "SbPList") -> "int":
        r"""__eq__(SbPList self, SbPList l) -> int"""
        return _coin.SbPList___eq__(self, l)

    def __ne__(self, l: "SbPList") -> "int":
        r"""__ne__(SbPList self, SbPList l) -> int"""
        return _coin.SbPList___ne__(self, l)

    def get(self, index: "int const") -> "void *":
        r"""get(SbPList self, int const index) -> void *"""
        return _coin.SbPList_get(self, index)

    def set(self, index: "int const", item: "void *") -> "void":
        r"""set(SbPList self, int const index, void * item)"""
        return _coin.SbPList_set(self, index, item)

    def __getitem__(self, i: "int") -> "void *":
        r"""__getitem__(SbPList self, int i) -> void *"""
        return _coin.SbPList___getitem__(self, i)

    def __setitem__(self, i: "int", val: "void *") -> "void":
        r"""__setitem__(SbPList self, int i, void * val)"""
        return _coin.SbPList___setitem__(self, i, val)

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


# Register SbPList in _coin:
_coin.SbPList_swigregister(SbPList)

class SbIntList(SbPList):
    r"""Proxy of C++ SbIntList class."""

    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):
        r"""
        __init__(SbIntList self) -> SbIntList
        __init__(SbIntList self, int const sizehint) -> SbIntList
        """
        _coin.SbIntList_swiginit(self, _coin.new_SbIntList(*args))

    def append(self, item: "int const") -> "void":
        r"""append(SbIntList self, int const item)"""
        return _coin.SbIntList_append(self, item)

    def find(self, item: "int const") -> "int":
        r"""find(SbIntList self, int const item) -> int"""
        return _coin.SbIntList_find(self, item)

    def insert(self, item: "int const", addbefore: "int const") -> "void":
        r"""insert(SbIntList self, int const item, int const addbefore)"""
        return _coin.SbIntList_insert(self, item, addbefore)

    def __setitem__(self, i: "int const", value: "int *") -> "void":
        r"""__setitem__(SbIntList self, int const i, int * value)"""
        return _coin.SbIntList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "int &":
        r"""__getitem__(SbIntList self, int const i) -> int &"""
        return _coin.SbIntList___getitem__(self, i)

    def get(self, i: "int const") -> "int":
        r"""get(SbIntList self, int const i) -> int"""
        return _coin.SbIntList_get(self, i)
    __swig_destroy__ = _coin.delete_SbIntList

# Register SbIntList in _coin:
_coin.SbIntList_swigregister(SbIntList)

class SbString(object):
    r"""Proxy of C++ SbString class."""

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

    def __init__(self, *args):
        r"""
        __init__(SbString self) -> SbString
        __init__(SbString self, char const * s) -> SbString
        __init__(SbString self, wchar_t const * s) -> SbString
        __init__(SbString self, char const * s, int start, int end) -> SbString
        __init__(SbString self, SbString s) -> SbString
        __init__(SbString self, int const digits) -> SbString
        """
        _coin.SbString_swiginit(self, _coin.new_SbString(*args))
    __swig_destroy__ = _coin.delete_SbString

    @staticmethod
    def hash(*args) -> "uint32_t":
        r"""
        hash() -> uint32_t
        hash(char const * s) -> uint32_t
        """
        return _coin.SbString_hash(*args)

    def getLength(self) -> "int":
        r"""getLength(SbString self) -> int"""
        return _coin.SbString_getLength(self)

    def makeEmpty(self, freeold: "SbBool"=1) -> "void":
        r"""makeEmpty(SbString self, SbBool freeold=1)"""
        return _coin.SbString_makeEmpty(self, freeold)

    def getString(self) -> "char const *":
        r"""getString(SbString self) -> char const *"""
        return _coin.SbString_getString(self)

    def getSubString(self, startidx: "int", endidx: "int"=-1) -> "SbString":
        r"""getSubString(SbString self, int startidx, int endidx=-1) -> SbString"""
        return _coin.SbString_getSubString(self, startidx, endidx)

    def deleteSubString(self, startidx: "int", endidx: "int"=-1) -> "void":
        r"""deleteSubString(SbString self, int startidx, int endidx=-1)"""
        return _coin.SbString_deleteSubString(self, startidx, endidx)

    def addIntString(self, value: "int const") -> "void":
        r"""addIntString(SbString self, int const value)"""
        return _coin.SbString_addIntString(self, value)

    def __iadd__(self, *args) -> "SbString &":
        r"""
        __iadd__(SbString self, char const * s) -> SbString
        __iadd__(SbString self, SbString s) -> SbString
        __iadd__(SbString self, char const c) -> SbString
        """
        return _coin.SbString___iadd__(self, *args)

    def compareSubString(self, text: "char const *", offset: "int"=0) -> "int":
        r"""compareSubString(SbString self, char const * text, int offset=0) -> int"""
        return _coin.SbString_compareSubString(self, text, offset)

    def sprintf(self, formatstr: "char const *") -> "SbString &":
        r"""sprintf(SbString self, char const * formatstr) -> SbString"""
        return _coin.SbString_sprintf(self, formatstr)

    def apply(self, func: "char (*)(char)") -> "void":
        r"""apply(SbString self, char (*)(char) func)"""
        return _coin.SbString_apply(self, func)

    def find(self, s: "SbString") -> "int":
        r"""find(SbString self, SbString s) -> int"""
        return _coin.SbString_find(self, s)

    def findAll(self, s: "SbString", found: "SbIntList") -> "SbBool":
        r"""findAll(SbString self, SbString s, SbIntList found) -> SbBool"""
        return _coin.SbString_findAll(self, s, found)

    def lower(self) -> "SbString":
        r"""lower(SbString self) -> SbString"""
        return _coin.SbString_lower(self)

    def upper(self) -> "SbString":
        r"""upper(SbString self) -> SbString"""
        return _coin.SbString_upper(self)

    def _print(self, fp: "std::FILE *") -> "void":
        r"""_print(SbString self, std::FILE * fp)"""
        return _coin.SbString__print(self, fp)

    def __eq__(self, *args) -> "int":
        r"""
        __eq__(SbString self, SbString u) -> int
        __eq__(SbString self, char * u) -> int
        """
        return _coin.SbString___eq__(self, *args)

    def __nq__(self, *args) -> "int":
        r"""
        __nq__(SbString self, SbString u) -> int
        __nq__(SbString self, char * u) -> int
        """
        return _coin.SbString___nq__(self, *args)

    def __getitem__(self, i: "int") -> "char":
        r"""__getitem__(SbString self, int i) -> char"""
        return _coin.SbString___getitem__(self, i)

    def __iter__(self):
      return getString().__iter__()


    def __repr__(self) -> "char const *":
        r"""__repr__(SbString self) -> char const *"""
        return _coin.SbString___repr__(self)

# Register SbString in _coin:
_coin.SbString_swigregister(SbString)

def SbString_hash(*args) -> "uint32_t":
    r"""
    SbString_hash() -> uint32_t
    SbString_hash(char const * s) -> uint32_t
    """
    return _coin.SbString_hash(*args)

class SbName(object):
    r"""Proxy of C++ SbName class."""

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

    def __init__(self, *args):
        r"""
        __init__(SbName self) -> SbName
        __init__(SbName self, char const * namestring) -> SbName
        __init__(SbName self, SbString str) -> SbName
        __init__(SbName self, SbName name) -> SbName
        """
        _coin.SbName_swiginit(self, _coin.new_SbName(*args))
    __swig_destroy__ = _coin.delete_SbName

    def getString(self) -> "char const *":
        r"""getString(SbName self) -> char const *"""
        return _coin.SbName_getString(self)

    def getLength(self) -> "int":
        r"""getLength(SbName self) -> int"""
        return _coin.SbName_getLength(self)

    @staticmethod
    def isIdentStartChar(c: "char const") -> "SbBool":
        r"""isIdentStartChar(char const c) -> SbBool"""
        return _coin.SbName_isIdentStartChar(c)

    @staticmethod
    def isIdentChar(c: "char const") -> "SbBool":
        r"""isIdentChar(char const c) -> SbBool"""
        return _coin.SbName_isIdentChar(c)

    @staticmethod
    def isBaseNameStartChar(c: "char const") -> "SbBool":
        r"""isBaseNameStartChar(char const c) -> SbBool"""
        return _coin.SbName_isBaseNameStartChar(c)

    @staticmethod
    def isBaseNameChar(c: "char const") -> "SbBool":
        r"""isBaseNameChar(char const c) -> SbBool"""
        return _coin.SbName_isBaseNameChar(c)

    @staticmethod
    def empty() -> "SbName const &":
        r"""empty() -> SbName"""
        return _coin.SbName_empty()

    def __eq__(self, *args) -> "int":
        r"""
        __eq__(SbName self, SbName u) -> int
        __eq__(SbName self, char * u) -> int
        __eq__(SbName self, SbString u) -> int
        """
        return _coin.SbName___eq__(self, *args)

    def __nq__(self, *args) -> "int":
        r"""
        __nq__(SbName self, SbName u) -> int
        __nq__(SbName self, char * u) -> int
        __nq__(SbName self, SbString u) -> int
        """
        return _coin.SbName___nq__(self, *args)

    def __getitem__(self, i: "int") -> "char":
        r"""__getitem__(SbName self, int i) -> char"""
        return _coin.SbName___getitem__(self, i)

    def __iter__(self):
      return getString().__iter__()


    def __repr__(self) -> "char const *":
        r"""__repr__(SbName self) -> char const *"""
        return _coin.SbName___repr__(self)

# Register SbName in _coin:
_coin.SbName_swigregister(SbName)

def SbName_isIdentStartChar(c: "char const") -> "SbBool":
    r"""SbName_isIdentStartChar(char const c) -> SbBool"""
    return _coin.SbName_isIdentStartChar(c)

def SbName_isIdentChar(c: "char const") -> "SbBool":
    r"""SbName_isIdentChar(char const c) -> SbBool"""
    return _coin.SbName_isIdentChar(c)

def SbName_isBaseNameStartChar(c: "char const") -> "SbBool":
    r"""SbName_isBaseNameStartChar(char const c) -> SbBool"""
    return _coin.SbName_isBaseNameStartChar(c)

def SbName_isBaseNameChar(c: "char const") -> "SbBool":
    r"""SbName_isBaseNameChar(char const c) -> SbBool"""
    return _coin.SbName_isBaseNameChar(c)

def SbName_empty() -> "SbName const &":
    r"""SbName_empty() -> SbName"""
    return _coin.SbName_empty()

class SoError(object):
    r"""Proxy of C++ SoError class."""

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

    def __init__(self):
        r"""__init__(SoError self) -> SoError"""
        _coin.SoError_swiginit(self, _coin.new_SoError())
    __swig_destroy__ = _coin.delete_SoError

    @staticmethod
    def setHandlerCallback(func: "SoErrorCB *const", data: "void *const") -> "void":
        r"""setHandlerCallback(SoErrorCB *const func, void *const data)"""
        return _coin.SoError_setHandlerCallback(func, data)

    @staticmethod
    def getHandlerCallback() -> "SoErrorCB *":
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoError_getHandlerCallback()

    @staticmethod
    def getHandlerData() -> "void *":
        r"""getHandlerData() -> void *"""
        return _coin.SoError_getHandlerData()

    def getDebugString(self) -> "SbString const &":
        r"""getDebugString(SoError self) -> SbString"""
        return _coin.SoError_getDebugString(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoError_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoError self) -> SoType"""
        return _coin.SoError_getTypeId(self)

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(SoError self, SoType type) -> SbBool"""
        return _coin.SoError_isOfType(self, type)

    @staticmethod
    def post(*args) -> "void":
        r"""post(char const *const format)"""
        return _coin.SoError_post(*args)

    @staticmethod
    def getString(*args) -> "SbString":
        r"""
        getString(SoNode node) -> SbString
        getString(SoPath path) -> SbString
        getString(SoEngine engine) -> SbString
        """
        return _coin.SoError_getString(*args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoError_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoError_initClasses()

# Register SoError in _coin:
_coin.SoError_swigregister(SoError)

def SoError_setHandlerCallback(func: "SoErrorCB *const", data: "void *const") -> "void":
    r"""SoError_setHandlerCallback(SoErrorCB *const func, void *const data)"""
    return _coin.SoError_setHandlerCallback(func, data)

def SoError_getHandlerCallback() -> "SoErrorCB *":
    r"""SoError_getHandlerCallback() -> SoErrorCB *"""
    return _coin.SoError_getHandlerCallback()

def SoError_getHandlerData() -> "void *":
    r"""SoError_getHandlerData() -> void *"""
    return _coin.SoError_getHandlerData()

def SoError_getClassTypeId() -> "SoType":
    r"""SoError_getClassTypeId() -> SoType"""
    return _coin.SoError_getClassTypeId()

def SoError_post(*args) -> "void":
    r"""SoError_post(char const *const format)"""
    return _coin.SoError_post(*args)

def SoError_getString(*args) -> "SbString":
    r"""
    SoError_getString(SoNode node) -> SbString
    SoError_getString(SoPath path) -> SbString
    SoError_getString(SoEngine engine) -> SbString
    """
    return _coin.SoError_getString(*args)

def SoError_initClass() -> "void":
    r"""SoError_initClass()"""
    return _coin.SoError_initClass()

def SoError_initClasses() -> "void":
    r"""SoError_initClasses()"""
    return _coin.SoError_initClasses()

class SoDebugError(SoError):
    r"""Proxy of C++ SoDebugError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ERROR = _coin.SoDebugError_ERROR
    
    WARNING = _coin.SoDebugError_WARNING
    
    INFO = _coin.SoDebugError_INFO
    

    @staticmethod
    def setHandlerCallback(function: "SoErrorCB *const", data: "void *const") -> "void":
        r"""setHandlerCallback(SoErrorCB *const function, void *const data)"""
        return _coin.SoDebugError_setHandlerCallback(function, data)

    @staticmethod
    def getHandlerCallback() -> "SoErrorCB *":
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoDebugError_getHandlerCallback()

    @staticmethod
    def getHandlerData() -> "void *":
        r"""getHandlerData() -> void *"""
        return _coin.SoDebugError_getHandlerData()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDebugError_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDebugError self) -> SoType"""
        return _coin.SoDebugError_getTypeId(self)

    def getSeverity(self) -> "SoDebugError::Severity":
        r"""getSeverity(SoDebugError self) -> SoDebugError::Severity"""
        return _coin.SoDebugError_getSeverity(self)

    @staticmethod
    def post(*args) -> "void":
        r"""post(char const *const source, char const *const format)"""
        return _coin.SoDebugError_post(*args)

    @staticmethod
    def postWarning(*args) -> "void":
        r"""postWarning(char const *const source, char const *const format)"""
        return _coin.SoDebugError_postWarning(*args)

    @staticmethod
    def postInfo(*args) -> "void":
        r"""postInfo(char const *const source, char const *const format)"""
        return _coin.SoDebugError_postInfo(*args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDebugError_initClass()

    def __init__(self):
        r"""__init__(SoDebugError self) -> SoDebugError"""
        _coin.SoDebugError_swiginit(self, _coin.new_SoDebugError())
    __swig_destroy__ = _coin.delete_SoDebugError

# Register SoDebugError in _coin:
_coin.SoDebugError_swigregister(SoDebugError)

def SoDebugError_setHandlerCallback(function: "SoErrorCB *const", data: "void *const") -> "void":
    r"""SoDebugError_setHandlerCallback(SoErrorCB *const function, void *const data)"""
    return _coin.SoDebugError_setHandlerCallback(function, data)

def SoDebugError_getHandlerCallback() -> "SoErrorCB *":
    r"""SoDebugError_getHandlerCallback() -> SoErrorCB *"""
    return _coin.SoDebugError_getHandlerCallback()

def SoDebugError_getHandlerData() -> "void *":
    r"""SoDebugError_getHandlerData() -> void *"""
    return _coin.SoDebugError_getHandlerData()

def SoDebugError_getClassTypeId() -> "SoType":
    r"""SoDebugError_getClassTypeId() -> SoType"""
    return _coin.SoDebugError_getClassTypeId()

def SoDebugError_post(*args) -> "void":
    r"""SoDebugError_post(char const *const source, char const *const format)"""
    return _coin.SoDebugError_post(*args)

def SoDebugError_postWarning(*args) -> "void":
    r"""SoDebugError_postWarning(char const *const source, char const *const format)"""
    return _coin.SoDebugError_postWarning(*args)

def SoDebugError_postInfo(*args) -> "void":
    r"""SoDebugError_postInfo(char const *const source, char const *const format)"""
    return _coin.SoDebugError_postInfo(*args)

def SoDebugError_initClass() -> "void":
    r"""SoDebugError_initClass()"""
    return _coin.SoDebugError_initClass()

class SbVec2s(object):
    r"""Proxy of C++ SbVec2s class."""

    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):
        r"""
        __init__(SbVec2s self) -> SbVec2s
        __init__(SbVec2s self, short const [2] v) -> SbVec2s
        __init__(SbVec2s self, short x, short y) -> SbVec2s
        __init__(SbVec2s self, SbVec2us const & v) -> SbVec2s
        __init__(SbVec2s self, SbVec2b v) -> SbVec2s
        __init__(SbVec2s self, SbVec2i32 v) -> SbVec2s
        __init__(SbVec2s self, SbVec2f v) -> SbVec2s
        __init__(SbVec2s self, SbVec2d v) -> SbVec2s
        """
        _coin.SbVec2s_swiginit(self, _coin.new_SbVec2s(*args))

    def setValue(self, *args) -> "SbVec2s &":
        r"""
        setValue(SbVec2s self, short const [2] v) -> SbVec2s
        setValue(SbVec2s self, short x, short y) -> SbVec2s
        setValue(SbVec2s self, SbVec2us const & v) -> SbVec2s
        setValue(SbVec2s self, SbVec2b v) -> SbVec2s
        setValue(SbVec2s self, SbVec2i32 v) -> SbVec2s
        setValue(SbVec2s self, SbVec2f v) -> SbVec2s
        setValue(SbVec2s self, SbVec2d v) -> SbVec2s
        """
        return _coin.SbVec2s_setValue(self, *args)

    def getValue(self) -> "void":
        r"""getValue(SbVec2s self)"""
        return _coin.SbVec2s_getValue(self)

    def dot(self, v: "SbVec2s") -> "int32_t":
        r"""dot(SbVec2s self, SbVec2s v) -> int32_t"""
        return _coin.SbVec2s_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec2s self)"""
        return _coin.SbVec2s_negate(self)

    def __imul__(self, *args) -> "SbVec2s &":
        r"""
        __imul__(SbVec2s self, int d) -> SbVec2s
        __imul__(SbVec2s self, double d) -> SbVec2s
        """
        return _coin.SbVec2s___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec2s___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec2s") -> "SbVec2s &":
        r"""__iadd__(SbVec2s self, SbVec2s v) -> SbVec2s"""
        return _coin.SbVec2s___iadd__(self, v)

    def __isub__(self, v: "SbVec2s") -> "SbVec2s &":
        r"""__isub__(SbVec2s self, SbVec2s v) -> SbVec2s"""
        return _coin.SbVec2s___isub__(self, v)

    def __neg__(self) -> "SbVec2s":
        r"""__neg__(SbVec2s self) -> SbVec2s"""
        return _coin.SbVec2s___neg__(self)

    def toString(self) -> "SbString":
        r"""toString(SbVec2s self) -> SbString"""
        return _coin.SbVec2s_toString(self)

    def fromString(self, str: "SbString") -> "SbBool":
        r"""fromString(SbVec2s self, SbString str) -> SbBool"""
        return _coin.SbVec2s_fromString(self, str)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec2s self, FILE * fp)"""
        return _coin.SbVec2s_output(self, fp)

    def __add__(self, u: "SbVec2s") -> "SbVec2s":
        r"""__add__(SbVec2s self, SbVec2s u) -> SbVec2s"""
        return _coin.SbVec2s___add__(self, u)

    def __sub__(self, u: "SbVec2s") -> "SbVec2s":
        r"""__sub__(SbVec2s self, SbVec2s u) -> SbVec2s"""
        return _coin.SbVec2s___sub__(self, u)

    def __mul__(self, d: "double const") -> "SbVec2s":
        r"""__mul__(SbVec2s self, double const d) -> SbVec2s"""
        return _coin.SbVec2s___mul__(self, d)

    def __rmul__(self, d: "double const") -> "SbVec2s":
        r"""__rmul__(SbVec2s self, double const d) -> SbVec2s"""
        return _coin.SbVec2s___rmul__(self, d)

    def __div__(self, d: "double const") -> "SbVec2s":
        r"""__div__(SbVec2s self, double const d) -> SbVec2s"""
        return _coin.SbVec2s___div__(self, d)

    def __truediv__(self, d: "double const") -> "SbVec2s":
        r"""__truediv__(SbVec2s self, double const d) -> SbVec2s"""
        return _coin.SbVec2s___truediv__(self, d)

    def __eq__(self, u: "SbVec2s") -> "int":
        r"""__eq__(SbVec2s self, SbVec2s u) -> int"""
        return _coin.SbVec2s___eq__(self, u)

    def __nq__(self, u: "SbVec2s") -> "int":
        r"""__nq__(SbVec2s self, SbVec2s u) -> int"""
        return _coin.SbVec2s___nq__(self, u)

    def __getitem__(self, i: "int") -> "short":
        r"""__getitem__(SbVec2s self, int i) -> short"""
        return _coin.SbVec2s___getitem__(self, i)

    def __setitem__(self, i: "int", value: "short") -> "void":
        r"""__setitem__(SbVec2s self, int i, short value)"""
        return _coin.SbVec2s___setitem__(self, i, value)

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

    def __len__(self):
          return 2

    __swig_destroy__ = _coin.delete_SbVec2s

# Register SbVec2s in _coin:
_coin.SbVec2s_swigregister(SbVec2s)

class SbVec2f(object):
    r"""Proxy of C++ SbVec2f class."""

    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):
        r"""
        __init__(SbVec2f self) -> SbVec2f
        __init__(SbVec2f self, float const [2] v) -> SbVec2f
        __init__(SbVec2f self, float x, float y) -> SbVec2f
        __init__(SbVec2f self, SbVec2d v) -> SbVec2f
        __init__(SbVec2f self, SbVec2b v) -> SbVec2f
        __init__(SbVec2f self, SbVec2s v) -> SbVec2f
        __init__(SbVec2f self, SbVec2i32 v) -> SbVec2f
        """
        _coin.SbVec2f_swiginit(self, _coin.new_SbVec2f(*args))

    def setValue(self, *args) -> "SbVec2f &":
        r"""
        setValue(SbVec2f self, float const [2] v) -> SbVec2f
        setValue(SbVec2f self, float x, float y) -> SbVec2f
        setValue(SbVec2f self, SbVec2d v) -> SbVec2f
        setValue(SbVec2f self, SbVec2b v) -> SbVec2f
        setValue(SbVec2f self, SbVec2s v) -> SbVec2f
        setValue(SbVec2f self, SbVec2i32 v) -> SbVec2f
        """
        return _coin.SbVec2f_setValue(self, *args)

    def getValue(self) -> "void":
        r"""getValue(SbVec2f self)"""
        return _coin.SbVec2f_getValue(self)

    def dot(self, v: "SbVec2f") -> "float":
        r"""dot(SbVec2f self, SbVec2f v) -> float"""
        return _coin.SbVec2f_dot(self, v)

    def equals(self, v: "SbVec2f", tolerance: "float") -> "SbBool":
        r"""equals(SbVec2f self, SbVec2f v, float tolerance) -> SbBool"""
        return _coin.SbVec2f_equals(self, v, tolerance)

    def length(self) -> "float":
        r"""length(SbVec2f self) -> float"""
        return _coin.SbVec2f_length(self)

    def sqrLength(self) -> "float":
        r"""sqrLength(SbVec2f self) -> float"""
        return _coin.SbVec2f_sqrLength(self)

    def negate(self) -> "void":
        r"""negate(SbVec2f self)"""
        return _coin.SbVec2f_negate(self)

    def normalize(self) -> "float":
        r"""normalize(SbVec2f self) -> float"""
        return _coin.SbVec2f_normalize(self)

    def __imul__(self, d: "float") -> "SbVec2f &":
        r"""__imul__(SbVec2f self, float d) -> SbVec2f"""
        return _coin.SbVec2f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec2f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec2f") -> "SbVec2f &":
        r"""__iadd__(SbVec2f self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___iadd__(self, v)

    def __isub__(self, v: "SbVec2f") -> "SbVec2f &":
        r"""__isub__(SbVec2f self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___isub__(self, v)

    def __neg__(self) -> "SbVec2f":
        r"""__neg__(SbVec2f self) -> SbVec2f"""
        return _coin.SbVec2f___neg__(self)

    def toString(self) -> "SbString":
        r"""toString(SbVec2f self) -> SbString"""
        return _coin.SbVec2f_toString(self)

    def fromString(self, str: "SbString") -> "SbBool":
        r"""fromString(SbVec2f self, SbString str) -> SbBool"""
        return _coin.SbVec2f_fromString(self, str)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec2f self, FILE * fp)"""
        return _coin.SbVec2f_output(self, fp)

    def __add__(self, u: "SbVec2f") -> "SbVec2f":
        r"""__add__(SbVec2f self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___add__(self, u)

    def __sub__(self, u: "SbVec2f") -> "SbVec2f":
        r"""__sub__(SbVec2f self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___sub__(self, u)

    def __mul__(self, d: "float const") -> "SbVec2f":
        r"""__mul__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___mul__(self, d)

    def __rmul__(self, d: "float const") -> "SbVec2f":
        r"""__rmul__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___rmul__(self, d)

    def __div__(self, d: "float const") -> "SbVec2f":
        r"""__div__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___div__(self, d)

    def __truediv__(self, d: "float const") -> "SbVec2f":
        r"""__truediv__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___truediv__(self, d)

    def __eq__(self, u: "SbVec2f") -> "int":
        r"""__eq__(SbVec2f self, SbVec2f u) -> int"""
        return _coin.SbVec2f___eq__(self, u)

    def __nq__(self, u: "SbVec2f") -> "int":
        r"""__nq__(SbVec2f self, SbVec2f u) -> int"""
        return _coin.SbVec2f___nq__(self, u)

    def __getitem__(self, i: "int") -> "float":
        r"""__getitem__(SbVec2f self, int i) -> float"""
        return _coin.SbVec2f___getitem__(self, i)

    def __setitem__(self, i: "int", value: "float") -> "void":
        r"""__setitem__(SbVec2f self, int i, float value)"""
        return _coin.SbVec2f___setitem__(self, i, value)

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

    def __len__(self):
          return 2

    __swig_destroy__ = _coin.delete_SbVec2f

# Register SbVec2f in _coin:
_coin.SbVec2f_swigregister(SbVec2f)

class SbTime(object):
    r"""Proxy of C++ SbTime class."""

    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):
        r"""
        __init__(SbTime self) -> SbTime
        __init__(SbTime self, double const sec) -> SbTime
        __init__(SbTime self, int32_t const sec, long const usec) -> SbTime
        __init__(SbTime self, timeval const *const tv) -> SbTime
        """
        _coin.SbTime_swiginit(self, _coin.new_SbTime(*args))

    @staticmethod
    def getTimeOfDay() -> "SbTime":
        r"""getTimeOfDay() -> SbTime"""
        return _coin.SbTime_getTimeOfDay()

    def setToTimeOfDay(self) -> "void":
        r"""setToTimeOfDay(SbTime self)"""
        return _coin.SbTime_setToTimeOfDay(self)

    @staticmethod
    def zero() -> "SbTime":
        r"""zero() -> SbTime"""
        return _coin.SbTime_zero()

    @staticmethod
    def max() -> "SbTime":
        r"""max() -> SbTime"""
        return _coin.SbTime_max()

    @staticmethod
    def maxTime() -> "SbTime":
        r"""maxTime() -> SbTime"""
        return _coin.SbTime_maxTime()

    @staticmethod
    def sleep(msec: "int") -> "void":
        r"""sleep(int msec)"""
        return _coin.SbTime_sleep(msec)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SbTime self, double const sec)
        setValue(SbTime self, int32_t const sec, long const usec)
        setValue(SbTime self, timeval const *const tv)
        """
        return _coin.SbTime_setValue(self, *args)

    def setMsecValue(self, msec: "unsigned long const") -> "void":
        r"""setMsecValue(SbTime self, unsigned long const msec)"""
        return _coin.SbTime_setMsecValue(self, msec)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbTime self) -> double
        getValue(SbTime self, time_t & sec, long & usec)
        getValue(SbTime self, timeval * tv)
        """
        return _coin.SbTime_getValue(self, *args)

    def getMsecValue(self) -> "unsigned long":
        r"""getMsecValue(SbTime self) -> unsigned long"""
        return _coin.SbTime_getMsecValue(self)

    def format(self, *args) -> "SbString":
        r"""format(SbTime self, char const *const fmt="%S.%i") -> SbString"""
        return _coin.SbTime_format(self, *args)

    def formatDate(self, fmt: "char const *const"=None) -> "SbString":
        r"""formatDate(SbTime self, char const *const fmt=None) -> SbString"""
        return _coin.SbTime_formatDate(self, fmt)

    def parsedate(self, date: "char const *const") -> "SbBool":
        r"""parsedate(SbTime self, char const *const date) -> SbBool"""
        return _coin.SbTime_parsedate(self, date)

    def __iadd__(self, tm: "SbTime") -> "SbTime &":
        r"""__iadd__(SbTime self, SbTime tm) -> SbTime"""
        return _coin.SbTime___iadd__(self, tm)

    def __isub__(self, tm: "SbTime") -> "SbTime &":
        r"""__isub__(SbTime self, SbTime tm) -> SbTime"""
        return _coin.SbTime___isub__(self, tm)

    def __neg__(self) -> "SbTime":
        r"""__neg__(SbTime self) -> SbTime"""
        return _coin.SbTime___neg__(self)

    def __imul__(self, s: "double const") -> "SbTime &":
        r"""__imul__(SbTime self, double const s) -> SbTime"""
        return _coin.SbTime___imul__(self, s)

    def __itruediv__(self, *args):
        return _coin.SbTime___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __truediv__(self, *args):
        return _coin.SbTime___truediv__(self, *args)
    __div__ = __truediv__



    def __mod__(self, tm: "SbTime") -> "SbTime":
        r"""__mod__(SbTime self, SbTime tm) -> SbTime"""
        return _coin.SbTime___mod__(self, tm)

    def __eq__(self, tm: "SbTime") -> "int":
        r"""__eq__(SbTime self, SbTime tm) -> int"""
        return _coin.SbTime___eq__(self, tm)

    def __ne__(self, tm: "SbTime") -> "int":
        r"""__ne__(SbTime self, SbTime tm) -> int"""
        return _coin.SbTime___ne__(self, tm)

    def __lt__(self, tm: "SbTime") -> "SbBool":
        r"""__lt__(SbTime self, SbTime tm) -> SbBool"""
        return _coin.SbTime___lt__(self, tm)

    def __gt__(self, tm: "SbTime") -> "SbBool":
        r"""__gt__(SbTime self, SbTime tm) -> SbBool"""
        return _coin.SbTime___gt__(self, tm)

    def __le__(self, tm: "SbTime") -> "SbBool":
        r"""__le__(SbTime self, SbTime tm) -> SbBool"""
        return _coin.SbTime___le__(self, tm)

    def __ge__(self, tm: "SbTime") -> "SbBool":
        r"""__ge__(SbTime self, SbTime tm) -> SbBool"""
        return _coin.SbTime___ge__(self, tm)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbTime self, FILE * fp)"""
        return _coin.SbTime_output(self, fp)

    def __add__(self, u: "SbTime") -> "SbTime":
        r"""__add__(SbTime self, SbTime u) -> SbTime"""
        return _coin.SbTime___add__(self, u)

    def __sub__(self, u: "SbTime") -> "SbTime":
        r"""__sub__(SbTime self, SbTime u) -> SbTime"""
        return _coin.SbTime___sub__(self, u)

    def __mul__(self, d: "double const") -> "SbTime":
        r"""__mul__(SbTime self, double const d) -> SbTime"""
        return _coin.SbTime___mul__(self, d)

    def __rmul__(self, d: "double const") -> "SbTime":
        r"""__rmul__(SbTime self, double const d) -> SbTime"""
        return _coin.SbTime___rmul__(self, d)

    def __div__(self, d: "double const") -> "SbTime":
        r"""__div__(SbTime self, double const d) -> SbTime"""
        return _coin.SbTime___div__(self, d)
    __swig_destroy__ = _coin.delete_SbTime

# Register SbTime in _coin:
_coin.SbTime_swigregister(SbTime)

def SbTime_getTimeOfDay() -> "SbTime":
    r"""SbTime_getTimeOfDay() -> SbTime"""
    return _coin.SbTime_getTimeOfDay()

def SbTime_zero() -> "SbTime":
    r"""SbTime_zero() -> SbTime"""
    return _coin.SbTime_zero()

def SbTime_max() -> "SbTime":
    r"""SbTime_max() -> SbTime"""
    return _coin.SbTime_max()

def SbTime_maxTime() -> "SbTime":
    r"""SbTime_maxTime() -> SbTime"""
    return _coin.SbTime_maxTime()

def SbTime_sleep(msec: "int") -> "void":
    r"""SbTime_sleep(int msec)"""
    return _coin.SbTime_sleep(msec)

class SoEvent(object):
    r"""Proxy of C++ SoEvent class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEvent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoEvent self) -> SoType"""
        return _coin.SoEvent_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoEvent_initClass()

    def __init__(self):
        r"""__init__(SoEvent self) -> SoEvent"""
        _coin.SoEvent_swiginit(self, _coin.new_SoEvent())
    __swig_destroy__ = _coin.delete_SoEvent

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(SoEvent self, SoType type) -> SbBool"""
        return _coin.SoEvent_isOfType(self, type)

    def setTime(self, t: "SbTime") -> "void":
        r"""setTime(SoEvent self, SbTime t)"""
        return _coin.SoEvent_setTime(self, t)

    def getTime(self) -> "SbTime":
        r"""getTime(SoEvent self) -> SbTime"""
        return _coin.SoEvent_getTime(self)

    def setPosition(self, p: "SbVec2s") -> "void":
        r"""setPosition(SoEvent self, SbVec2s p)"""
        return _coin.SoEvent_setPosition(self, p)

    def getPosition(self, *args) -> "SbVec2s const &":
        r"""
        getPosition(SoEvent self) -> SbVec2s
        getPosition(SoEvent self, SbViewportRegion vpRgn) -> SbVec2s
        """
        return _coin.SoEvent_getPosition(self, *args)

    def getNormalizedPosition(self, vpRgn: "SbViewportRegion") -> "SbVec2f const &":
        r"""getNormalizedPosition(SoEvent self, SbViewportRegion vpRgn) -> SbVec2f"""
        return _coin.SoEvent_getNormalizedPosition(self, vpRgn)

    def setShiftDown(self, isDown: "SbBool") -> "void":
        r"""setShiftDown(SoEvent self, SbBool isDown)"""
        return _coin.SoEvent_setShiftDown(self, isDown)

    def wasShiftDown(self) -> "SbBool":
        r"""wasShiftDown(SoEvent self) -> SbBool"""
        return _coin.SoEvent_wasShiftDown(self)

    def setCtrlDown(self, isDown: "SbBool") -> "void":
        r"""setCtrlDown(SoEvent self, SbBool isDown)"""
        return _coin.SoEvent_setCtrlDown(self, isDown)

    def wasCtrlDown(self) -> "SbBool":
        r"""wasCtrlDown(SoEvent self) -> SbBool"""
        return _coin.SoEvent_wasCtrlDown(self)

    def setAltDown(self, isDown: "SbBool") -> "void":
        r"""setAltDown(SoEvent self, SbBool isDown)"""
        return _coin.SoEvent_setAltDown(self, isDown)

    def wasAltDown(self) -> "SbBool":
        r"""wasAltDown(SoEvent self) -> SbBool"""
        return _coin.SoEvent_wasAltDown(self)

# Register SoEvent in _coin:
_coin.SoEvent_swigregister(SoEvent)

def SoEvent_getClassTypeId() -> "SoType":
    r"""SoEvent_getClassTypeId() -> SoType"""
    return _coin.SoEvent_getClassTypeId()

def SoEvent_initClass() -> "void":
    r"""SoEvent_initClass()"""
    return _coin.SoEvent_initClass()

class SoNotRec(object):
    r"""Proxy of C++ SoNotRec class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CONTAINER = _coin.SoNotRec_CONTAINER
    
    PARENT = _coin.SoNotRec_PARENT
    
    SENSOR = _coin.SoNotRec_SENSOR
    
    FIELD = _coin.SoNotRec_FIELD
    
    ENGINE = _coin.SoNotRec_ENGINE
    
    UNSPECIFIED = _coin.SoNotRec_UNSPECIFIED
    
    FIELD_UPDATE = _coin.SoNotRec_FIELD_UPDATE
    
    GROUP_ADDCHILD = _coin.SoNotRec_GROUP_ADDCHILD
    
    GROUP_INSERTCHILD = _coin.SoNotRec_GROUP_INSERTCHILD
    
    GROUP_REPLACECHILD = _coin.SoNotRec_GROUP_REPLACECHILD
    
    GROUP_REMOVECHILD = _coin.SoNotRec_GROUP_REMOVECHILD
    
    GROUP_REMOVEALLCHILDREN = _coin.SoNotRec_GROUP_REMOVEALLCHILDREN
    

    def __init__(self, notifbase: "SoBase"):
        r"""__init__(SoNotRec self, SoBase notifbase) -> SoNotRec"""
        _coin.SoNotRec_swiginit(self, _coin.new_SoNotRec(notifbase))

    def setType(self, type: "SoNotRec::Type const") -> "void":
        r"""setType(SoNotRec self, SoNotRec::Type const type)"""
        return _coin.SoNotRec_setType(self, type)

    def getBase(self) -> "SoBase *":
        r"""getBase(SoNotRec self) -> SoBase"""
        return _coin.SoNotRec_getBase(self)

    def getType(self) -> "SoNotRec::Type":
        r"""getType(SoNotRec self) -> SoNotRec::Type"""
        return _coin.SoNotRec_getType(self)

    def getPrevious(self) -> "SoNotRec const *":
        r"""getPrevious(SoNotRec self) -> SoNotRec"""
        return _coin.SoNotRec_getPrevious(self)

    def setPrevious(self, prev: "SoNotRec") -> "void":
        r"""setPrevious(SoNotRec self, SoNotRec prev)"""
        return _coin.SoNotRec_setPrevious(self, prev)

    def output(self, file: "FILE *const") -> "void":
        r"""output(SoNotRec self, FILE *const file)"""
        return _coin.SoNotRec_output(self, file)

    def getOperationType(self) -> "SoNotRec::OperationType":
        r"""getOperationType(SoNotRec self) -> SoNotRec::OperationType"""
        return _coin.SoNotRec_getOperationType(self)

    def getIndex(self) -> "int":
        r"""getIndex(SoNotRec self) -> int"""
        return _coin.SoNotRec_getIndex(self)

    def getFieldNumIndices(self) -> "int":
        r"""getFieldNumIndices(SoNotRec self) -> int"""
        return _coin.SoNotRec_getFieldNumIndices(self)

    def getGroupChild(self) -> "SoBase const *":
        r"""getGroupChild(SoNotRec self) -> SoBase"""
        return _coin.SoNotRec_getGroupChild(self)

    def getGroupPrevChild(self) -> "SoBase const *":
        r"""getGroupPrevChild(SoNotRec self) -> SoBase"""
        return _coin.SoNotRec_getGroupPrevChild(self)

    def setOperationType(self, opType: "SoNotRec::OperationType const") -> "void":
        r"""setOperationType(SoNotRec self, SoNotRec::OperationType const opType)"""
        return _coin.SoNotRec_setOperationType(self, opType)

    def setIndex(self, idx: "int const") -> "void":
        r"""setIndex(SoNotRec self, int const idx)"""
        return _coin.SoNotRec_setIndex(self, idx)

    def setFieldNumIndices(self, fldnumind: "int const") -> "void":
        r"""setFieldNumIndices(SoNotRec self, int const fldnumind)"""
        return _coin.SoNotRec_setFieldNumIndices(self, fldnumind)

    def setGroupChild(self, gc: "SoBase") -> "void":
        r"""setGroupChild(SoNotRec self, SoBase gc)"""
        return _coin.SoNotRec_setGroupChild(self, gc)

    def setGroupPrevChild(self, pc: "SoBase") -> "void":
        r"""setGroupPrevChild(SoNotRec self, SoBase pc)"""
        return _coin.SoNotRec_setGroupPrevChild(self, pc)
    __swig_destroy__ = _coin.delete_SoNotRec

# Register SoNotRec in _coin:
_coin.SoNotRec_swigregister(SoNotRec)

class SoNotList(object):
    r"""Proxy of C++ SoNotList class."""

    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):
        r"""
        __init__(SoNotList self) -> SoNotList
        __init__(SoNotList self, SoNotList nl) -> SoNotList
        """
        _coin.SoNotList_swiginit(self, _coin.new_SoNotList(*args))

    def append(self, *args) -> "void":
        r"""
        append(SoNotList self, SoNotRec rec)
        append(SoNotList self, SoNotRec rec, SoField field)
        append(SoNotList self, SoNotRec rec, SoEngineOutput engineout)
        """
        return _coin.SoNotList_append(self, *args)

    def setLastType(self, type: "SoNotRec::Type const") -> "void":
        r"""setLastType(SoNotList self, SoNotRec::Type const type)"""
        return _coin.SoNotList_setLastType(self, type)

    def getFirstRec(self) -> "SoNotRec *":
        r"""getFirstRec(SoNotList self) -> SoNotRec"""
        return _coin.SoNotList_getFirstRec(self)

    def getLastRec(self) -> "SoNotRec *":
        r"""getLastRec(SoNotList self) -> SoNotRec"""
        return _coin.SoNotList_getLastRec(self)

    def getFirstRecAtNode(self) -> "SoNotRec *":
        r"""getFirstRecAtNode(SoNotList self) -> SoNotRec"""
        return _coin.SoNotList_getFirstRecAtNode(self)

    def getLastField(self) -> "SoField *":
        r"""getLastField(SoNotList self) -> SoField"""
        return _coin.SoNotList_getLastField(self)

    def getLastEngineOutput(self) -> "SoEngineOutput *":
        r"""getLastEngineOutput(SoNotList self) -> SoEngineOutput"""
        return _coin.SoNotList_getLastEngineOutput(self)

    def getTimeStamp(self) -> "SbUniqueId":
        r"""getTimeStamp(SoNotList self) -> SbUniqueId"""
        return _coin.SoNotList_getTimeStamp(self)

    def output(self, *args) -> "void":
        r"""output(SoNotList self, FILE *const file=stdout)"""
        return _coin.SoNotList_output(self, *args)
    __swig_destroy__ = _coin.delete_SoNotList

# Register SoNotList in _coin:
_coin.SoNotList_swigregister(SoNotList)

class SoField(object):
    r"""Proxy of C++ SoField class."""

    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__ = _coin.delete_SoField

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoField_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoField_initClasses()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoField_cleanupClass()

    def setIgnored(self, ignore: "SbBool") -> "void":
        r"""setIgnored(SoField self, SbBool ignore)"""
        return _coin.SoField_setIgnored(self, ignore)

    def isIgnored(self) -> "SbBool":
        r"""isIgnored(SoField self) -> SbBool"""
        return _coin.SoField_isIgnored(self)

    def setDefault(self, defaultVal: "SbBool") -> "void":
        r"""setDefault(SoField self, SbBool defaultVal)"""
        return _coin.SoField_setDefault(self, defaultVal)

    def isDefault(self) -> "SbBool":
        r"""isDefault(SoField self) -> SbBool"""
        return _coin.SoField_isDefault(self)

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoField self) -> SoType"""
        return _coin.SoField_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoField_getClassTypeId()

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(SoField self, SoType type) -> SbBool"""
        return _coin.SoField_isOfType(self, type)

    def enableConnection(self, flag: "SbBool") -> "void":
        r"""enableConnection(SoField self, SbBool flag)"""
        return _coin.SoField_enableConnection(self, flag)

    def isConnectionEnabled(self) -> "SbBool":
        r"""isConnectionEnabled(SoField self) -> SbBool"""
        return _coin.SoField_isConnectionEnabled(self)

    def isConnectedFromEngine(self) -> "SbBool":
        r"""isConnectedFromEngine(SoField self) -> SbBool"""
        return _coin.SoField_isConnectedFromEngine(self)

    def getConnectedEngine(self, master: "SoEngineOutput *&") -> "SbBool":
        r"""getConnectedEngine(SoField self, SoEngineOutput *& master) -> SbBool"""
        return _coin.SoField_getConnectedEngine(self, master)

    def connectFrom(self, *args) -> "SbBool":
        r"""
        connectFrom(SoField self, SoEngineOutput master, SbBool notnotify=0, SbBool append=0) -> SbBool
        connectFrom(SoField self, SoField master, SbBool notnotify=0, SbBool append=0) -> SbBool
        """
        return _coin.SoField_connectFrom(self, *args)

    def appendConnection(self, *args) -> "SbBool":
        r"""
        appendConnection(SoField self, SoEngineOutput master, SbBool notnotify=0) -> SbBool
        appendConnection(SoField self, SoField master, SbBool notnotify=0) -> SbBool
        """
        return _coin.SoField_appendConnection(self, *args)

    def isConnectedFromField(self) -> "SbBool":
        r"""isConnectedFromField(SoField self) -> SbBool"""
        return _coin.SoField_isConnectedFromField(self)

    def getConnectedField(self, master: "SoField *&") -> "SbBool":
        r"""getConnectedField(SoField self, SoField *& master) -> SbBool"""
        return _coin.SoField_getConnectedField(self, master)

    def getNumConnections(self) -> "int":
        r"""getNumConnections(SoField self) -> int"""
        return _coin.SoField_getNumConnections(self)

    def getForwardConnections(self, slavelist: "SoFieldList") -> "int":
        r"""getForwardConnections(SoField self, SoFieldList slavelist) -> int"""
        return _coin.SoField_getForwardConnections(self, slavelist)

    def getConnections(self, masterlist: "SoFieldList") -> "int":
        r"""getConnections(SoField self, SoFieldList masterlist) -> int"""
        return _coin.SoField_getConnections(self, masterlist)

    def disconnect(self, *args) -> "void":
        r"""
        disconnect(SoField self, SoEngineOutput engineoutput)
        disconnect(SoField self, SoField field)
        disconnect(SoField self)
        """
        return _coin.SoField_disconnect(self, *args)

    def isConnected(self) -> "SbBool":
        r"""isConnected(SoField self) -> SbBool"""
        return _coin.SoField_isConnected(self)

    def setContainer(self, cont: "SoFieldContainer") -> "void":
        r"""setContainer(SoField self, SoFieldContainer cont)"""
        return _coin.SoField_setContainer(self, cont)

    def getContainer(self) -> "SoFieldContainer *":
        r"""getContainer(SoField self) -> SoFieldContainer"""
        return _coin.SoField_getContainer(self)

    def set(self, valuestring: "char const *") -> "SbBool":
        r"""set(SoField self, char const * valuestring) -> SbBool"""
        return _coin.SoField_set(self, valuestring)

    def shouldWrite(self) -> "SbBool":
        r"""shouldWrite(SoField self) -> SbBool"""
        return _coin.SoField_shouldWrite(self)

    def touch(self) -> "void":
        r"""touch(SoField self)"""
        return _coin.SoField_touch(self)

    def startNotify(self) -> "void":
        r"""startNotify(SoField self)"""
        return _coin.SoField_startNotify(self)

    def notify(self, nlist: "SoNotList") -> "void":
        r"""notify(SoField self, SoNotList nlist)"""
        return _coin.SoField_notify(self, nlist)

    def enableNotify(self, on: "SbBool") -> "SbBool":
        r"""enableNotify(SoField self, SbBool on) -> SbBool"""
        return _coin.SoField_enableNotify(self, on)

    def isNotifyEnabled(self) -> "SbBool":
        r"""isNotifyEnabled(SoField self) -> SbBool"""
        return _coin.SoField_isNotifyEnabled(self)

    def addAuditor(self, f: "void *", type: "SoNotRec::Type") -> "void":
        r"""addAuditor(SoField self, void * f, SoNotRec::Type type)"""
        return _coin.SoField_addAuditor(self, f, type)

    def removeAuditor(self, f: "void *", type: "SoNotRec::Type") -> "void":
        r"""removeAuditor(SoField self, void * f, SoNotRec::Type type)"""
        return _coin.SoField_removeAuditor(self, f, type)

    def __eq__(self, f: "SoField") -> "int":
        r"""__eq__(SoField self, SoField f) -> int"""
        return _coin.SoField___eq__(self, f)

    def __ne__(self, f: "SoField") -> "int":
        r"""__ne__(SoField self, SoField f) -> int"""
        return _coin.SoField___ne__(self, f)

    def connectionStatusChanged(self, numconnections: "int") -> "void":
        r"""connectionStatusChanged(SoField self, int numconnections)"""
        return _coin.SoField_connectionStatusChanged(self, numconnections)

    def isReadOnly(self) -> "SbBool":
        r"""isReadOnly(SoField self) -> SbBool"""
        return _coin.SoField_isReadOnly(self)

    def isSame(self, f: "SoField") -> "SbBool":
        r"""isSame(SoField self, SoField f) -> SbBool"""
        return _coin.SoField_isSame(self, f)

    def copyFrom(self, f: "SoField") -> "void":
        r"""copyFrom(SoField self, SoField f)"""
        return _coin.SoField_copyFrom(self, f)

    def fixCopy(self, copyconnections: "SbBool") -> "void":
        r"""fixCopy(SoField self, SbBool copyconnections)"""
        return _coin.SoField_fixCopy(self, copyconnections)

    def referencesCopy(self) -> "SbBool":
        r"""referencesCopy(SoField self) -> SbBool"""
        return _coin.SoField_referencesCopy(self)

    def copyConnection(self, fromfield: "SoField") -> "void":
        r"""copyConnection(SoField self, SoField fromfield)"""
        return _coin.SoField_copyConnection(self, fromfield)

    def read(self, input: "SoInput", name: "SbName") -> "SbBool":
        r"""read(SoField self, SoInput input, SbName name) -> SbBool"""
        return _coin.SoField_read(self, input, name)

    def write(self, out: "SoOutput", name: "SbName") -> "void":
        r"""write(SoField self, SoOutput out, SbName name)"""
        return _coin.SoField_write(self, out, name)

    def countWriteRefs(self, out: "SoOutput") -> "void":
        r"""countWriteRefs(SoField self, SoOutput out)"""
        return _coin.SoField_countWriteRefs(self, out)
    NORMAL_FIELD = _coin.SoField_NORMAL_FIELD
    
    EVENTIN_FIELD = _coin.SoField_EVENTIN_FIELD
    
    EVENTOUT_FIELD = _coin.SoField_EVENTOUT_FIELD
    
    EXPOSED_FIELD = _coin.SoField_EXPOSED_FIELD
    

    def setFieldType(self, type: "int") -> "void":
        r"""setFieldType(SoField self, int type)"""
        return _coin.SoField_setFieldType(self, type)

    def getFieldType(self) -> "int":
        r"""getFieldType(SoField self) -> int"""
        return _coin.SoField_getFieldType(self)

    def getDirty(self) -> "SbBool":
        r"""getDirty(SoField self) -> SbBool"""
        return _coin.SoField_getDirty(self)

    def setDirty(self, dirty: "SbBool") -> "void":
        r"""setDirty(SoField self, SbBool dirty)"""
        return _coin.SoField_setDirty(self, dirty)

    def evaluate(self) -> "void":
        r"""evaluate(SoField self)"""
        return _coin.SoField_evaluate(self)

    def get(self) -> "SbString":
        r"""get(SoField self) -> SbString"""
        return _coin.SoField_get(self)

# Register SoField in _coin:
_coin.SoField_swigregister(SoField)

def SoField_initClass() -> "void":
    r"""SoField_initClass()"""
    return _coin.SoField_initClass()

def SoField_initClasses() -> "void":
    r"""SoField_initClasses()"""
    return _coin.SoField_initClasses()

def SoField_cleanupClass() -> "void":
    r"""SoField_cleanupClass()"""
    return _coin.SoField_cleanupClass()

def SoField_getClassTypeId() -> "SoType":
    r"""SoField_getClassTypeId() -> SoType"""
    return _coin.SoField_getClassTypeId()

class SoSField(SoField):
    r"""Proxy of C++ SoSField class."""

    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__ = _coin.delete_SoSField

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSField_initClass()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSField_getClassTypeId()

    @staticmethod
    def atexit_cleanup() -> "void":
        r"""atexit_cleanup()"""
        return _coin.SoSField_atexit_cleanup()

# Register SoSField in _coin:
_coin.SoSField_swigregister(SoSField)

def SoSField_initClass() -> "void":
    r"""SoSField_initClass()"""
    return _coin.SoSField_initClass()

def SoSField_getClassTypeId() -> "SoType":
    r"""SoSField_getClassTypeId() -> SoType"""
    return _coin.SoSField_getClassTypeId()

def SoSField_atexit_cleanup() -> "void":
    r"""SoSField_atexit_cleanup()"""
    return _coin.SoSField_atexit_cleanup()

class SoMField(SoField):
    r"""Proxy of C++ SoMField class."""

    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__ = _coin.delete_SoMField

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMField_getClassTypeId()

    @staticmethod
    def atexit_cleanup() -> "void":
        r"""atexit_cleanup()"""
        return _coin.SoMField_atexit_cleanup()

    def getNum(self) -> "int":
        r"""getNum(SoMField self) -> int"""
        return _coin.SoMField_getNum(self)

    def setNum(self, num: "int const") -> "void":
        r"""setNum(SoMField self, int const num)"""
        return _coin.SoMField_setNum(self, num)

    def deleteValues(self, start: "int", num: "int"=-1) -> "void":
        r"""deleteValues(SoMField self, int start, int num=-1)"""
        return _coin.SoMField_deleteValues(self, start, num)

    def insertSpace(self, start: "int", num: "int") -> "void":
        r"""insertSpace(SoMField self, int start, int num)"""
        return _coin.SoMField_insertSpace(self, start, num)

    def set1(self, index: "int const", valuestring: "char const *const") -> "SbBool":
        r"""set1(SoMField self, int const index, char const *const valuestring) -> SbBool"""
        return _coin.SoMField_set1(self, index, valuestring)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMField_initClass()

    def enableDeleteValues(self) -> "void":
        r"""enableDeleteValues(SoMField self)"""
        return _coin.SoMField_enableDeleteValues(self)

    def isDeleteValuesEnabled(self) -> "SbBool":
        r"""isDeleteValuesEnabled(SoMField self) -> SbBool"""
        return _coin.SoMField_isDeleteValuesEnabled(self)

    def __iter__(self):
       i = 0
       while i < self.getNum():
          yield self[i]
          i += 1


    def __len__(self) -> "int":
        r"""__len__(SoMField self) -> int"""
        return _coin.SoMField___len__(self)

    def get1(self, index: "int const") -> "SbString":
        r"""get1(SoMField self, int const index) -> SbString"""
        return _coin.SoMField_get1(self, index)

    @property
    def values(self):
      def _values(obj):
        for value in obj:
          if hasattr(value, "__iter__"):
            yield list(_values(value))
          else:
            yield value
      out = _values(self)
      return list(out)

    @values.setter
    def values(self, arr):
      self.deleteValues(0)
      self.setValues(0, len(arr), arr)



# Register SoMField in _coin:
_coin.SoMField_swigregister(SoMField)

def SoMField_getClassTypeId() -> "SoType":
    r"""SoMField_getClassTypeId() -> SoType"""
    return _coin.SoMField_getClassTypeId()

def SoMField_atexit_cleanup() -> "void":
    r"""SoMField_atexit_cleanup()"""
    return _coin.SoMField_atexit_cleanup()

def SoMField_initClass() -> "void":
    r"""SoMField_initClass()"""
    return _coin.SoMField_initClass()

class SoAuditorList(object):
    r"""Proxy of C++ SoAuditorList class."""

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

    def __init__(self):
        r"""__init__(SoAuditorList self) -> SoAuditorList"""
        _coin.SoAuditorList_swiginit(self, _coin.new_SoAuditorList())
    __swig_destroy__ = _coin.delete_SoAuditorList

    def append(self, auditor: "void *const", type: "SoNotRec::Type const") -> "void":
        r"""append(SoAuditorList self, void *const auditor, SoNotRec::Type const type)"""
        return _coin.SoAuditorList_append(self, auditor, type)

    def set(self, index: "int const", auditor: "void *const", type: "SoNotRec::Type const") -> "void":
        r"""set(SoAuditorList self, int const index, void *const auditor, SoNotRec::Type const type)"""
        return _coin.SoAuditorList_set(self, index, auditor, type)

    def getObject(self, index: "int const") -> "void *":
        r"""getObject(SoAuditorList self, int const index) -> void *"""
        return _coin.SoAuditorList_getObject(self, index)

    def getType(self, index: "int const") -> "SoNotRec::Type":
        r"""getType(SoAuditorList self, int const index) -> SoNotRec::Type"""
        return _coin.SoAuditorList_getType(self, index)

    def getLength(self) -> "int":
        r"""getLength(SoAuditorList self) -> int"""
        return _coin.SoAuditorList_getLength(self)

    def find(self, auditor: "void *const", type: "SoNotRec::Type const") -> "int":
        r"""find(SoAuditorList self, void *const auditor, SoNotRec::Type const type) -> int"""
        return _coin.SoAuditorList_find(self, auditor, type)

    def remove(self, *args) -> "void":
        r"""
        remove(SoAuditorList self, int const index)
        remove(SoAuditorList self, void *const auditor, SoNotRec::Type const type)
        """
        return _coin.SoAuditorList_remove(self, *args)

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoAuditorList self, SoNotList l)"""
        return _coin.SoAuditorList_notify(self, l)

# Register SoAuditorList in _coin:
_coin.SoAuditorList_swigregister(SoAuditorList)

class SoBase(object):
    r"""Proxy of C++ SoBase class."""

    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 initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBase_initClass()

    def ref(self) -> "void":
        r"""ref(SoBase self)"""
        return _coin.SoBase_ref(self)

    def unref(self) -> "void":
        r"""unref(SoBase self)"""
        return _coin.SoBase_unref(self)

    def unrefNoDelete(self) -> "void":
        r"""unrefNoDelete(SoBase self)"""
        return _coin.SoBase_unrefNoDelete(self)

    def getRefCount(self) -> "int32_t":
        r"""getRefCount(SoBase self) -> int32_t"""
        return _coin.SoBase_getRefCount(self)

    def touch(self) -> "void":
        r"""touch(SoBase self)"""
        return _coin.SoBase_touch(self)

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBase self) -> SoType"""
        return _coin.SoBase_getTypeId(self)

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(SoBase self, SoType type) -> SbBool"""
        return _coin.SoBase_isOfType(self, type)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBase_getClassTypeId()

    def getName(self) -> "SbName":
        r"""getName(SoBase self) -> SbName"""
        return _coin.SoBase_getName(self)

    def setName(self, newname: "SbName") -> "void":
        r"""setName(SoBase self, SbName newname)"""
        return _coin.SoBase_setName(self, newname)

    @staticmethod
    def addName(base: "SoBase", name: "char const *const") -> "void":
        r"""addName(SoBase base, char const *const name)"""
        return _coin.SoBase_addName(base, name)

    @staticmethod
    def removeName(base: "SoBase", name: "char const *const") -> "void":
        r"""removeName(SoBase base, char const *const name)"""
        return _coin.SoBase_removeName(base, name)

    def startNotify(self) -> "void":
        r"""startNotify(SoBase self)"""
        return _coin.SoBase_startNotify(self)

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoBase self, SoNotList l)"""
        return _coin.SoBase_notify(self, l)

    def addAuditor(self, auditor: "void *const", type: "SoNotRec::Type const") -> "void":
        r"""addAuditor(SoBase self, void *const auditor, SoNotRec::Type const type)"""
        return _coin.SoBase_addAuditor(self, auditor, type)

    def removeAuditor(self, auditor: "void *const", type: "SoNotRec::Type const") -> "void":
        r"""removeAuditor(SoBase self, void *const auditor, SoNotRec::Type const type)"""
        return _coin.SoBase_removeAuditor(self, auditor, type)

    def getAuditors(self) -> "SoAuditorList const &":
        r"""getAuditors(SoBase self) -> SoAuditorList"""
        return _coin.SoBase_getAuditors(self)

    def addWriteReference(self, out: "SoOutput", isfromfield: "SbBool"=0) -> "void":
        r"""addWriteReference(SoBase self, SoOutput out, SbBool isfromfield=0)"""
        return _coin.SoBase_addWriteReference(self, out, isfromfield)

    def shouldWrite(self) -> "SbBool":
        r"""shouldWrite(SoBase self) -> SbBool"""
        return _coin.SoBase_shouldWrite(self)

    @staticmethod
    def incrementCurrentWriteCounter() -> "void":
        r"""incrementCurrentWriteCounter()"""
        return _coin.SoBase_incrementCurrentWriteCounter()

    @staticmethod
    def decrementCurrentWriteCounter() -> "void":
        r"""decrementCurrentWriteCounter()"""
        return _coin.SoBase_decrementCurrentWriteCounter()

    @staticmethod
    def getNamedBase(name: "SbName", type: "SoType") -> "SoBase *":
        r"""getNamedBase(SbName name, SoType type) -> SoBase"""
        return _coin.SoBase_getNamedBase(name, type)

    @staticmethod
    def getNamedBases(name: "SbName", baselist: "SoBaseList", type: "SoType") -> "int":
        r"""getNamedBases(SbName name, SoBaseList baselist, SoType type) -> int"""
        return _coin.SoBase_getNamedBases(name, baselist, type)

    @staticmethod
    def read(input: "SoInput", base: "SoBase *&", expectedtype: "SoType") -> "SbBool":
        r"""read(SoInput input, SoBase *& base, SoType expectedtype) -> SbBool"""
        return _coin.SoBase_read(input, base, expectedtype)

    @staticmethod
    def setInstancePrefix(c: "SbString") -> "void":
        r"""setInstancePrefix(SbString c)"""
        return _coin.SoBase_setInstancePrefix(c)

    @staticmethod
    def setTraceRefs(trace: "SbBool") -> "void":
        r"""setTraceRefs(SbBool trace)"""
        return _coin.SoBase_setTraceRefs(trace)

    @staticmethod
    def getTraceRefs() -> "SbBool":
        r"""getTraceRefs() -> SbBool"""
        return _coin.SoBase_getTraceRefs()

    @staticmethod
    def connectRoute(input: "SoInput", fromnodename: "SbName", fromfieldname: "SbName", tonodename: "SbName", tofieldname: "SbName") -> "SbBool":
        r"""connectRoute(SoInput input, SbName fromnodename, SbName fromfieldname, SbName tonodename, SbName tofieldname) -> SbBool"""
        return _coin.SoBase_connectRoute(input, fromnodename, fromfieldname, tonodename, tofieldname)

    def assertAlive(self) -> "void":
        r"""assertAlive(SoBase self)"""
        return _coin.SoBase_assertAlive(self)

    @staticmethod
    def readRoute(input: "SoInput") -> "SbBool":
        r"""readRoute(SoInput input) -> SbBool"""
        return _coin.SoBase_readRoute(input)
    __swig_destroy__ = _coin.delete_SoBase

    def __hash__(self) -> "size_t":
        r"""__hash__(SoBase self) -> size_t"""
        return _coin.SoBase___hash__(self)

    def __eq__(self,other):
      return (self.this == other.this) if other is not None else False
    def __ne__(self,other):
      return (self.this != other.this) if other is not None else True
    def __nonzero__(self):
      return True


# Register SoBase in _coin:
_coin.SoBase_swigregister(SoBase)

def SoBase_initClass() -> "void":
    r"""SoBase_initClass()"""
    return _coin.SoBase_initClass()

def SoBase_getClassTypeId() -> "SoType":
    r"""SoBase_getClassTypeId() -> SoType"""
    return _coin.SoBase_getClassTypeId()

def SoBase_addName(base: "SoBase", name: "char const *const") -> "void":
    r"""SoBase_addName(SoBase base, char const *const name)"""
    return _coin.SoBase_addName(base, name)

def SoBase_removeName(base: "SoBase", name: "char const *const") -> "void":
    r"""SoBase_removeName(SoBase base, char const *const name)"""
    return _coin.SoBase_removeName(base, name)

def SoBase_incrementCurrentWriteCounter() -> "void":
    r"""SoBase_incrementCurrentWriteCounter()"""
    return _coin.SoBase_incrementCurrentWriteCounter()

def SoBase_decrementCurrentWriteCounter() -> "void":
    r"""SoBase_decrementCurrentWriteCounter()"""
    return _coin.SoBase_decrementCurrentWriteCounter()

def SoBase_getNamedBase(name: "SbName", type: "SoType") -> "SoBase *":
    r"""SoBase_getNamedBase(SbName name, SoType type) -> SoBase"""
    return _coin.SoBase_getNamedBase(name, type)

def SoBase_getNamedBases(name: "SbName", baselist: "SoBaseList", type: "SoType") -> "int":
    r"""SoBase_getNamedBases(SbName name, SoBaseList baselist, SoType type) -> int"""
    return _coin.SoBase_getNamedBases(name, baselist, type)

def SoBase_read(input: "SoInput", base: "SoBase *&", expectedtype: "SoType") -> "SbBool":
    r"""SoBase_read(SoInput input, SoBase *& base, SoType expectedtype) -> SbBool"""
    return _coin.SoBase_read(input, base, expectedtype)

def SoBase_setInstancePrefix(c: "SbString") -> "void":
    r"""SoBase_setInstancePrefix(SbString c)"""
    return _coin.SoBase_setInstancePrefix(c)

def SoBase_setTraceRefs(trace: "SbBool") -> "void":
    r"""SoBase_setTraceRefs(SbBool trace)"""
    return _coin.SoBase_setTraceRefs(trace)

def SoBase_getTraceRefs() -> "SbBool":
    r"""SoBase_getTraceRefs() -> SbBool"""
    return _coin.SoBase_getTraceRefs()

def SoBase_connectRoute(input: "SoInput", fromnodename: "SbName", fromfieldname: "SbName", tonodename: "SbName", tofieldname: "SbName") -> "SbBool":
    r"""SoBase_connectRoute(SoInput input, SbName fromnodename, SbName fromfieldname, SbName tonodename, SbName tofieldname) -> SbBool"""
    return _coin.SoBase_connectRoute(input, fromnodename, fromfieldname, tonodename, tofieldname)

def SoBase_readRoute(input: "SoInput") -> "SbBool":
    r"""SoBase_readRoute(SoInput input) -> SbBool"""
    return _coin.SoBase_readRoute(input)


def intrusive_ptr_add_ref(obj: "SoBase") -> "void":
    r"""intrusive_ptr_add_ref(SoBase obj)"""
    return _coin.intrusive_ptr_add_ref(obj)

def intrusive_ptr_release(obj: "SoBase") -> "void":
    r"""intrusive_ptr_release(SoBase obj)"""
    return _coin.intrusive_ptr_release(obj)
class SoBaseList(SbPList):
    r"""Proxy of C++ SoBaseList class."""

    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):
        r"""
        __init__(SoBaseList self) -> SoBaseList
        __init__(SoBaseList self, int const size) -> SoBaseList
        __init__(SoBaseList self, SoBaseList l) -> SoBaseList
        """
        _coin.SoBaseList_swiginit(self, _coin.new_SoBaseList(*args))
    __swig_destroy__ = _coin.delete_SoBaseList

    def append(self, ptr: "SoBase") -> "void":
        r"""append(SoBaseList self, SoBase ptr)"""
        return _coin.SoBaseList_append(self, ptr)

    def insert(self, ptr: "SoBase", addbefore: "int const") -> "void":
        r"""insert(SoBaseList self, SoBase ptr, int const addbefore)"""
        return _coin.SoBaseList_insert(self, ptr, addbefore)

    def remove(self, index: "int const") -> "void":
        r"""remove(SoBaseList self, int const index)"""
        return _coin.SoBaseList_remove(self, index)

    def removeItem(self, item: "SoBase") -> "void":
        r"""removeItem(SoBaseList self, SoBase item)"""
        return _coin.SoBaseList_removeItem(self, item)

    def truncate(self, length: "int const") -> "void":
        r"""truncate(SoBaseList self, int const length)"""
        return _coin.SoBaseList_truncate(self, length)

    def copy(self, l: "SoBaseList") -> "void":
        r"""copy(SoBaseList self, SoBaseList l)"""
        return _coin.SoBaseList_copy(self, l)

    def set(self, i: "int const", ptr: "SoBase") -> "void":
        r"""set(SoBaseList self, int const i, SoBase ptr)"""
        return _coin.SoBaseList_set(self, i, ptr)

    def addReferences(self, flag: "SbBool const") -> "void":
        r"""addReferences(SoBaseList self, SbBool const flag)"""
        return _coin.SoBaseList_addReferences(self, flag)

    def isReferencing(self) -> "SbBool":
        r"""isReferencing(SoBaseList self) -> SbBool"""
        return _coin.SoBaseList_isReferencing(self)

    def __setitem__(self, i: "int const", value: "SoBase") -> "void":
        r"""__setitem__(SoBaseList self, int const i, SoBase value)"""
        return _coin.SoBaseList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoBase *":
        r"""__getitem__(SoBaseList self, int const i) -> SoBase"""
        return _coin.SoBaseList___getitem__(self, i)

    def get(self, i: "int const") -> "SoBase *":
        r"""get(SoBaseList self, int const i) -> SoBase"""
        return _coin.SoBaseList_get(self, i)

# Register SoBaseList in _coin:
_coin.SoBaseList_swigregister(SoBaseList)

class SoNodeList(SoBaseList):
    r"""Proxy of C++ SoNodeList class."""

    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):
        r"""
        __init__(SoNodeList self) -> SoNodeList
        __init__(SoNodeList self, int const size) -> SoNodeList
        __init__(SoNodeList self, SoNodeList nl) -> SoNodeList
        """
        _coin.SoNodeList_swiginit(self, _coin.new_SoNodeList(*args))
    __swig_destroy__ = _coin.delete_SoNodeList

    def append(self, ptr: "SoNode") -> "void":
        r"""append(SoNodeList self, SoNode ptr)"""
        return _coin.SoNodeList_append(self, ptr)

    def __setitem__(self, i: "int const", value: "SoNode") -> "void":
        r"""__setitem__(SoNodeList self, int const i, SoNode value)"""
        return _coin.SoNodeList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoNode *":
        r"""__getitem__(SoNodeList self, int const i) -> SoNode"""
        return _coin.SoNodeList___getitem__(self, i)

    def get(self, i: "int const") -> "SoNode *":
        r"""get(SoNodeList self, int const i) -> SoNode"""
        return _coin.SoNodeList_get(self, i)

# Register SoNodeList in _coin:
_coin.SoNodeList_swigregister(SoNodeList)

class SoDetailList(SbPList):
    r"""Proxy of C++ SoDetailList class."""

    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):
        r"""
        __init__(SoDetailList self) -> SoDetailList
        __init__(SoDetailList self, int const sizehint) -> SoDetailList
        __init__(SoDetailList self, SoDetailList l) -> SoDetailList
        """
        _coin.SoDetailList_swiginit(self, _coin.new_SoDetailList(*args))
    __swig_destroy__ = _coin.delete_SoDetailList

    def append(self, detail: "SoDetail") -> "void":
        r"""append(SoDetailList self, SoDetail detail)"""
        return _coin.SoDetailList_append(self, detail)

    def insert(self, detail: "SoDetail", insertbefore: "int const") -> "void":
        r"""insert(SoDetailList self, SoDetail detail, int const insertbefore)"""
        return _coin.SoDetailList_insert(self, detail, insertbefore)

    def truncate(self, length: "int const", fit: "int const"=0) -> "void":
        r"""truncate(SoDetailList self, int const length, int const fit=0)"""
        return _coin.SoDetailList_truncate(self, length, fit)

    def copy(self, l: "SoDetailList") -> "void":
        r"""copy(SoDetailList self, SoDetailList l)"""
        return _coin.SoDetailList_copy(self, l)

    def set(self, index: "int const", item: "SoDetail") -> "void":
        r"""set(SoDetailList self, int const index, SoDetail item)"""
        return _coin.SoDetailList_set(self, index, item)

    def __setitem__(self, i: "int const", value: "SoDetail") -> "void":
        r"""__setitem__(SoDetailList self, int const i, SoDetail value)"""
        return _coin.SoDetailList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoDetail *":
        r"""__getitem__(SoDetailList self, int const i) -> SoDetail"""
        return _coin.SoDetailList___getitem__(self, i)

    def get(self, i: "int const") -> "SoDetail *":
        r"""get(SoDetailList self, int const i) -> SoDetail"""
        return _coin.SoDetailList_get(self, i)

# Register SoDetailList in _coin:
_coin.SoDetailList_swigregister(SoDetailList)

class SoTypeList(SbPList):
    r"""Proxy of C++ SoTypeList class."""

    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):
        r"""
        __init__(SoTypeList self) -> SoTypeList
        __init__(SoTypeList self, int const sizehint) -> SoTypeList
        __init__(SoTypeList self, SoTypeList l) -> SoTypeList
        """
        _coin.SoTypeList_swiginit(self, _coin.new_SoTypeList(*args))

    def append(self, type: "SoType") -> "void":
        r"""append(SoTypeList self, SoType type)"""
        return _coin.SoTypeList_append(self, type)

    def find(self, type: "SoType") -> "int":
        r"""find(SoTypeList self, SoType type) -> int"""
        return _coin.SoTypeList_find(self, type)

    def insert(self, type: "SoType", insertbefore: "int const") -> "void":
        r"""insert(SoTypeList self, SoType type, int const insertbefore)"""
        return _coin.SoTypeList_insert(self, type, insertbefore)

    def set(self, index: "int const", item: "SoType") -> "void":
        r"""set(SoTypeList self, int const index, SoType item)"""
        return _coin.SoTypeList_set(self, index, item)

    def __setitem__(self, i: "int const", value: "SoType") -> "void":
        r"""__setitem__(SoTypeList self, int const i, SoType value)"""
        return _coin.SoTypeList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoType":
        r"""__getitem__(SoTypeList self, int const i) -> SoType"""
        return _coin.SoTypeList___getitem__(self, i)

    def get(self, i: "int const") -> "SoType":
        r"""get(SoTypeList self, int const i) -> SoType"""
        return _coin.SoTypeList_get(self, i)
    __swig_destroy__ = _coin.delete_SoTypeList

# Register SoTypeList in _coin:
_coin.SoTypeList_swigregister(SoTypeList)

class SoEnabledElementsList(object):
    r"""Proxy of C++ SoEnabledElementsList class."""

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

    def __init__(self, parentlist: "SoEnabledElementsList"):
        r"""__init__(SoEnabledElementsList self, SoEnabledElementsList parentlist) -> SoEnabledElementsList"""
        _coin.SoEnabledElementsList_swiginit(self, _coin.new_SoEnabledElementsList(parentlist))
    __swig_destroy__ = _coin.delete_SoEnabledElementsList

    def getElements(self) -> "SoTypeList const &":
        r"""getElements(SoEnabledElementsList self) -> SoTypeList"""
        return _coin.SoEnabledElementsList_getElements(self)

    def enable(self, elementtype: "SoType", stackindex: "int const") -> "void":
        r"""enable(SoEnabledElementsList self, SoType elementtype, int const stackindex)"""
        return _coin.SoEnabledElementsList_enable(self, elementtype, stackindex)

    def merge(self, eel: "SoEnabledElementsList") -> "void":
        r"""merge(SoEnabledElementsList self, SoEnabledElementsList eel)"""
        return _coin.SoEnabledElementsList_merge(self, eel)

    @staticmethod
    def getCounter() -> "int":
        r"""getCounter() -> int"""
        return _coin.SoEnabledElementsList_getCounter()

# Register SoEnabledElementsList in _coin:
_coin.SoEnabledElementsList_swigregister(SoEnabledElementsList)

def SoEnabledElementsList_getCounter() -> "int":
    r"""SoEnabledElementsList_getCounter() -> int"""
    return _coin.SoEnabledElementsList_getCounter()

class SoEngineOutputList(SbPList):
    r"""Proxy of C++ SoEngineOutputList class."""

    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):
        r"""
        __init__(SoEngineOutputList self) -> SoEngineOutputList
        __init__(SoEngineOutputList self, int const sizehint) -> SoEngineOutputList
        __init__(SoEngineOutputList self, SoEngineOutputList l) -> SoEngineOutputList
        """
        _coin.SoEngineOutputList_swiginit(self, _coin.new_SoEngineOutputList(*args))

    def append(self, output: "SoEngineOutput") -> "void":
        r"""append(SoEngineOutputList self, SoEngineOutput output)"""
        return _coin.SoEngineOutputList_append(self, output)

    def insert(self, output: "SoEngineOutput", insertbefore: "int const") -> "void":
        r"""insert(SoEngineOutputList self, SoEngineOutput output, int const insertbefore)"""
        return _coin.SoEngineOutputList_insert(self, output, insertbefore)

    def set(self, idx: "int const", item: "SoEngineOutput") -> "void":
        r"""set(SoEngineOutputList self, int const idx, SoEngineOutput item)"""
        return _coin.SoEngineOutputList_set(self, idx, item)

    def __setitem__(self, i: "int const", value: "SoEngineOutput") -> "void":
        r"""__setitem__(SoEngineOutputList self, int const i, SoEngineOutput value)"""
        return _coin.SoEngineOutputList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoEngineOutput *":
        r"""__getitem__(SoEngineOutputList self, int const i) -> SoEngineOutput"""
        return _coin.SoEngineOutputList___getitem__(self, i)

    def get(self, i: "int const") -> "SoEngineOutput *":
        r"""get(SoEngineOutputList self, int const i) -> SoEngineOutput"""
        return _coin.SoEngineOutputList_get(self, i)
    __swig_destroy__ = _coin.delete_SoEngineOutputList

# Register SoEngineOutputList in _coin:
_coin.SoEngineOutputList_swigregister(SoEngineOutputList)

class SoEngineList(SoBaseList):
    r"""Proxy of C++ SoEngineList class."""

    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):
        r"""
        __init__(SoEngineList self) -> SoEngineList
        __init__(SoEngineList self, int const size) -> SoEngineList
        __init__(SoEngineList self, SoEngineList el) -> SoEngineList
        """
        _coin.SoEngineList_swiginit(self, _coin.new_SoEngineList(*args))
    __swig_destroy__ = _coin.delete_SoEngineList

    def append(self, ptr: "SoEngine") -> "void":
        r"""append(SoEngineList self, SoEngine ptr)"""
        return _coin.SoEngineList_append(self, ptr)

    def __setitem__(self, i: "int const", value: "SoEngine") -> "void":
        r"""__setitem__(SoEngineList self, int const i, SoEngine value)"""
        return _coin.SoEngineList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoEngine *":
        r"""__getitem__(SoEngineList self, int const i) -> SoEngine"""
        return _coin.SoEngineList___getitem__(self, i)

    def get(self, i: "int const") -> "SoEngine *":
        r"""get(SoEngineList self, int const i) -> SoEngine"""
        return _coin.SoEngineList_get(self, i)

# Register SoEngineList in _coin:
_coin.SoEngineList_swigregister(SoEngineList)

class SoFieldList(SbPList):
    r"""Proxy of C++ SoFieldList class."""

    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):
        r"""
        __init__(SoFieldList self) -> SoFieldList
        __init__(SoFieldList self, int const sizehint) -> SoFieldList
        __init__(SoFieldList self, SoFieldList l) -> SoFieldList
        """
        _coin.SoFieldList_swiginit(self, _coin.new_SoFieldList(*args))

    def append(self, field: "SoField") -> "void":
        r"""append(SoFieldList self, SoField field)"""
        return _coin.SoFieldList_append(self, field)

    def insert(self, field: "SoField", insertbefore: "int const") -> "void":
        r"""insert(SoFieldList self, SoField field, int const insertbefore)"""
        return _coin.SoFieldList_insert(self, field, insertbefore)

    def set(self, idx: "int const", field: "SoField") -> "void":
        r"""set(SoFieldList self, int const idx, SoField field)"""
        return _coin.SoFieldList_set(self, idx, field)

    def __setitem__(self, i: "int const", value: "SoField") -> "void":
        r"""__setitem__(SoFieldList self, int const i, SoField value)"""
        return _coin.SoFieldList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoField *":
        r"""__getitem__(SoFieldList self, int const i) -> SoField"""
        return _coin.SoFieldList___getitem__(self, i)

    def get(self, *args) -> "SoField *":
        r"""
        get(SoFieldList self, int const idx) -> SoField
        get(SoFieldList self, int const i) -> SoField
        """
        return _coin.SoFieldList_get(self, *args)
    __swig_destroy__ = _coin.delete_SoFieldList

# Register SoFieldList in _coin:
_coin.SoFieldList_swigregister(SoFieldList)

class SoPathList(SoBaseList):
    r"""Proxy of C++ SoPathList class."""

    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):
        r"""
        __init__(SoPathList self) -> SoPathList
        __init__(SoPathList self, int const size) -> SoPathList
        __init__(SoPathList self, SoPathList pl) -> SoPathList
        """
        _coin.SoPathList_swiginit(self, _coin.new_SoPathList(*args))
    __swig_destroy__ = _coin.delete_SoPathList

    def append(self, path: "SoPath") -> "void":
        r"""append(SoPathList self, SoPath path)"""
        return _coin.SoPathList_append(self, path)

    def findPath(self, path: "SoPath") -> "int":
        r"""findPath(SoPathList self, SoPath path) -> int"""
        return _coin.SoPathList_findPath(self, path)

    def sort(self) -> "void":
        r"""sort(SoPathList self)"""
        return _coin.SoPathList_sort(self)

    def uniquify(self) -> "void":
        r"""uniquify(SoPathList self)"""
        return _coin.SoPathList_uniquify(self)

    def __setitem__(self, i: "int const", value: "SoPath") -> "void":
        r"""__setitem__(SoPathList self, int const i, SoPath value)"""
        return _coin.SoPathList___setitem__(self, i, value)

    def __getitem__(self, i: "int") -> "SoPath *":
        r"""__getitem__(SoPathList self, int i) -> SoPath"""
        return _coin.SoPathList___getitem__(self, i)

    def get(self, i: "int const") -> "SoPath *":
        r"""get(SoPathList self, int const i) -> SoPath"""
        return _coin.SoPathList_get(self, i)

# Register SoPathList in _coin:
_coin.SoPathList_swigregister(SoPathList)

class SoPickedPointList(SbPList):
    r"""Proxy of C++ SoPickedPointList class."""

    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):
        r"""
        __init__(SoPickedPointList self) -> SoPickedPointList
        __init__(SoPickedPointList self, int const sizehint) -> SoPickedPointList
        __init__(SoPickedPointList self, SoPickedPointList l) -> SoPickedPointList
        """
        _coin.SoPickedPointList_swiginit(self, _coin.new_SoPickedPointList(*args))
    __swig_destroy__ = _coin.delete_SoPickedPointList

    def append(self, pp: "SoPickedPoint") -> "void":
        r"""append(SoPickedPointList self, SoPickedPoint pp)"""
        return _coin.SoPickedPointList_append(self, pp)

    def insert(self, pp: "SoPickedPoint", insertbefore: "int const") -> "void":
        r"""insert(SoPickedPointList self, SoPickedPoint pp, int const insertbefore)"""
        return _coin.SoPickedPointList_insert(self, pp, insertbefore)

    def truncate(self, start: "int const", fit: "int const"=0) -> "void":
        r"""truncate(SoPickedPointList self, int const start, int const fit=0)"""
        return _coin.SoPickedPointList_truncate(self, start, fit)

    def set(self, idx: "int const", pp: "SoPickedPoint") -> "void":
        r"""set(SoPickedPointList self, int const idx, SoPickedPoint pp)"""
        return _coin.SoPickedPointList_set(self, idx, pp)

    def __setitem__(self, i: "int const", value: "SoPickedPoint") -> "void":
        r"""__setitem__(SoPickedPointList self, int const i, SoPickedPoint value)"""
        return _coin.SoPickedPointList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoPickedPoint *":
        r"""__getitem__(SoPickedPointList self, int const i) -> SoPickedPoint"""
        return _coin.SoPickedPointList___getitem__(self, i)

    def get(self, i: "int const") -> "SoPickedPoint *":
        r"""get(SoPickedPointList self, int const i) -> SoPickedPoint"""
        return _coin.SoPickedPointList_get(self, i)

# Register SoPickedPointList in _coin:
_coin.SoPickedPointList_swigregister(SoPickedPointList)

class SoPath(SoBase):
    r"""Proxy of C++ SoPath class."""

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

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPath_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoPath self, int const approxlength=4) -> SoPath
        __init__(SoPath self, SoNode head) -> SoPath
        __init__(SoPath self, SoPath rhs) -> SoPath
        """
        _coin.SoPath_swiginit(self, _coin.new_SoPath(*args))

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPath_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPath self) -> SoType"""
        return _coin.SoPath_getTypeId(self)

    def setHead(self, head: "SoNode") -> "void":
        r"""setHead(SoPath self, SoNode head)"""
        return _coin.SoPath_setHead(self, head)

    def getHead(self) -> "SoNode *":
        r"""getHead(SoPath self) -> SoNode"""
        return _coin.SoPath_getHead(self)

    def append(self, *args) -> "void":
        r"""
        append(SoPath self, int const childindex)
        append(SoPath self, SoNode node)
        append(SoPath self, SoPath frompath)
        """
        return _coin.SoPath_append(self, *args)

    def push(self, childindex: "int const") -> "void":
        r"""push(SoPath self, int const childindex)"""
        return _coin.SoPath_push(self, childindex)

    def pop(self) -> "void":
        r"""pop(SoPath self)"""
        return _coin.SoPath_pop(self)

    def getTail(self) -> "SoNode *":
        r"""getTail(SoPath self) -> SoNode"""
        return _coin.SoPath_getTail(self)

    def getNode(self, index: "int const") -> "SoNode *":
        r"""getNode(SoPath self, int const index) -> SoNode"""
        return _coin.SoPath_getNode(self, index)

    def getNodeFromTail(self, index: "int const") -> "SoNode *":
        r"""getNodeFromTail(SoPath self, int const index) -> SoNode"""
        return _coin.SoPath_getNodeFromTail(self, index)

    def getIndex(self, index: "int const") -> "int":
        r"""getIndex(SoPath self, int const index) -> int"""
        return _coin.SoPath_getIndex(self, index)

    def getIndexFromTail(self, index: "int const") -> "int":
        r"""getIndexFromTail(SoPath self, int const index) -> int"""
        return _coin.SoPath_getIndexFromTail(self, index)

    def getLength(self) -> "int":
        r"""getLength(SoPath self) -> int"""
        return _coin.SoPath_getLength(self)

    def truncate(self, length: "int const") -> "void":
        r"""truncate(SoPath self, int const length)"""
        return _coin.SoPath_truncate(self, length)

    def findFork(self, path: "SoPath") -> "int":
        r"""findFork(SoPath self, SoPath path) -> int"""
        return _coin.SoPath_findFork(self, path)

    def findNode(self, node: "SoNode") -> "int":
        r"""findNode(SoPath self, SoNode node) -> int"""
        return _coin.SoPath_findNode(self, node)

    def containsNode(self, node: "SoNode") -> "SbBool":
        r"""containsNode(SoPath self, SoNode node) -> SbBool"""
        return _coin.SoPath_containsNode(self, node)

    def containsPath(self, path: "SoPath") -> "SbBool":
        r"""containsPath(SoPath self, SoPath path) -> SbBool"""
        return _coin.SoPath_containsPath(self, path)

    def copy(self, startfromnodeindex: "int const"=0, numnodes: "int"=0) -> "SoPath *":
        r"""copy(SoPath self, int const startfromnodeindex=0, int numnodes=0) -> SoPath"""
        return _coin.SoPath_copy(self, startfromnodeindex, numnodes)

    @staticmethod
    def getByName(*args) -> "int":
        r"""
        getByName(SbName name) -> SoPath
        getByName(SbName name, SoPathList l) -> int
        """
        return _coin.SoPath_getByName(*args)

    def insertIndex(self, parent: "SoNode", newindex: "int const") -> "void":
        r"""insertIndex(SoPath self, SoNode parent, int const newindex)"""
        return _coin.SoPath_insertIndex(self, parent, newindex)

    def removeIndex(self, parent: "SoNode", oldindex: "int const") -> "void":
        r"""removeIndex(SoPath self, SoNode parent, int const oldindex)"""
        return _coin.SoPath_removeIndex(self, parent, oldindex)

    def replaceIndex(self, parent: "SoNode", index: "int const", newchild: "SoNode") -> "void":
        r"""replaceIndex(SoPath self, SoNode parent, int const index, SoNode newchild)"""
        return _coin.SoPath_replaceIndex(self, parent, index, newchild)

    def isRelevantNotification(self, l: "SoNotList") -> "SbBool":
        r"""isRelevantNotification(SoPath self, SoNotList l) -> SbBool"""
        return _coin.SoPath_isRelevantNotification(self, l)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoPath self, SoWriteAction action)"""
        return _coin.SoPath_write(self, action)

    def __iter__(self):
       for i in range(self.getLength()):
          yield self.getNode(i)

    def index(self):
       for i in range(self.getLength()):
          yield self.getIndex(i)


    def __eq__(self, u: "SoPath") -> "int":
        r"""__eq__(SoPath self, SoPath u) -> int"""
        return _coin.SoPath___eq__(self, u)

    def __nq__(self, u: "SoPath") -> "int":
        r"""__nq__(SoPath self, SoPath u) -> int"""
        return _coin.SoPath___nq__(self, u)

# Register SoPath in _coin:
_coin.SoPath_swigregister(SoPath)

def SoPath_initClass() -> "void":
    r"""SoPath_initClass()"""
    return _coin.SoPath_initClass()

def SoPath_getClassTypeId() -> "SoType":
    r"""SoPath_getClassTypeId() -> SoType"""
    return _coin.SoPath_getClassTypeId()

def SoPath_getByName(*args) -> "int":
    r"""
    SoPath_getByName(SbName name) -> SoPath
    SoPath_getByName(SbName name, SoPathList l) -> int
    """
    return _coin.SoPath_getByName(*args)

class SoLightPath(object):
    r"""Proxy of C++ SoLightPath class."""

    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):
        r"""
        __init__(SoLightPath self, SoNode node, int const approxlength) -> SoLightPath
        __init__(SoLightPath self, int const approxlength) -> SoLightPath
        """
        _coin.SoLightPath_swiginit(self, _coin.new_SoLightPath(*args))
    __swig_destroy__ = _coin.delete_SoLightPath

    def setHead(self, node: "SoNode") -> "void":
        r"""setHead(SoLightPath self, SoNode node)"""
        return _coin.SoLightPath_setHead(self, node)

    def append(self, childindex: "int const") -> "void":
        r"""append(SoLightPath self, int const childindex)"""
        return _coin.SoLightPath_append(self, childindex)

    def push(self, childindex: "int const") -> "void":
        r"""push(SoLightPath self, int const childindex)"""
        return _coin.SoLightPath_push(self, childindex)

    def pop(self) -> "void":
        r"""pop(SoLightPath self)"""
        return _coin.SoLightPath_pop(self)

    def setTail(self, childindex: "int const") -> "void":
        r"""setTail(SoLightPath self, int const childindex)"""
        return _coin.SoLightPath_setTail(self, childindex)

    def getTail(self) -> "SoNode *":
        r"""getTail(SoLightPath self) -> SoNode"""
        return _coin.SoLightPath_getTail(self)

    def getHead(self) -> "SoNode *":
        r"""getHead(SoLightPath self) -> SoNode"""
        return _coin.SoLightPath_getHead(self)

    def getNode(self, index: "int const") -> "SoNode *":
        r"""getNode(SoLightPath self, int const index) -> SoNode"""
        return _coin.SoLightPath_getNode(self, index)

    def getIndex(self, index: "int const") -> "int":
        r"""getIndex(SoLightPath self, int const index) -> int"""
        return _coin.SoLightPath_getIndex(self, index)

    def getFullLength(self) -> "int":
        r"""getFullLength(SoLightPath self) -> int"""
        return _coin.SoLightPath_getFullLength(self)

    def truncate(self, startindex: "int const") -> "void":
        r"""truncate(SoLightPath self, int const startindex)"""
        return _coin.SoLightPath_truncate(self, startindex)

    def makeTempPath(self, path: "SoTempPath") -> "void":
        r"""makeTempPath(SoLightPath self, SoTempPath path)"""
        return _coin.SoLightPath_makeTempPath(self, path)

# Register SoLightPath in _coin:
_coin.SoLightPath_swigregister(SoLightPath)

class SoFullPath(SoPath):
    r"""Proxy of C++ SoFullPath class."""

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

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

    def pop(self) -> "void":
        r"""pop(SoFullPath self)"""
        return _coin.SoFullPath_pop(self)

    def getTail(self) -> "SoNode *":
        r"""getTail(SoFullPath self) -> SoNode"""
        return _coin.SoFullPath_getTail(self)

    def getNodeFromTail(self, index: "int const") -> "SoNode *":
        r"""getNodeFromTail(SoFullPath self, int const index) -> SoNode"""
        return _coin.SoFullPath_getNodeFromTail(self, index)

    def getIndexFromTail(self, index: "int const") -> "int":
        r"""getIndexFromTail(SoFullPath self, int const index) -> int"""
        return _coin.SoFullPath_getIndexFromTail(self, index)

    def getLength(self) -> "int":
        r"""getLength(SoFullPath self) -> int"""
        return _coin.SoFullPath_getLength(self)

    @staticmethod
    def fromSoPath(path: "SoPath") -> "SoFullPath *":
        r"""fromSoPath(SoPath path) -> SoFullPath"""
        return _coin.SoFullPath_fromSoPath(path)

# Register SoFullPath in _coin:
_coin.SoFullPath_swigregister(SoFullPath)

def SoFullPath_fromSoPath(path: "SoPath") -> "SoFullPath *":
    r"""SoFullPath_fromSoPath(SoPath path) -> SoFullPath"""
    return _coin.SoFullPath_fromSoPath(path)

class SoTempPath(SoFullPath):
    r"""Proxy of C++ SoTempPath class."""

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

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

    def simpleAppend(self, node: "SoNode", index: "int const") -> "void":
        r"""simpleAppend(SoTempPath self, SoNode node, int const index)"""
        return _coin.SoTempPath_simpleAppend(self, node, index)

    def replaceTail(self, node: "SoNode", index: "int const") -> "void":
        r"""replaceTail(SoTempPath self, SoNode node, int const index)"""
        return _coin.SoTempPath_replaceTail(self, node, index)

# Register SoTempPath in _coin:
_coin.SoTempPath_swigregister(SoTempPath)

class SoActionMethodList(SbPList):
    r"""Proxy of C++ SoActionMethodList class."""

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

    def __init__(self, parentlist: "SoActionMethodList"):
        r"""__init__(SoActionMethodList self, SoActionMethodList parentlist) -> SoActionMethodList"""
        _coin.SoActionMethodList_swiginit(self, _coin.new_SoActionMethodList(parentlist))
    __swig_destroy__ = _coin.delete_SoActionMethodList

    def addMethod(self, node: "SoType", method: "SoActionMethod const") -> "void":
        r"""addMethod(SoActionMethodList self, SoType node, SoActionMethod const method)"""
        return _coin.SoActionMethodList_addMethod(self, node, method)

    def setUp(self) -> "void":
        r"""setUp(SoActionMethodList self)"""
        return _coin.SoActionMethodList_setUp(self)

    def __setitem__(self, i: "int const", value: "SoActionMethod *") -> "void":
        r"""__setitem__(SoActionMethodList self, int const i, SoActionMethod * value)"""
        return _coin.SoActionMethodList___setitem__(self, i, value)

    def __getitem__(self, i: "int const") -> "SoActionMethod &":
        r"""__getitem__(SoActionMethodList self, int const i) -> SoActionMethod &"""
        return _coin.SoActionMethodList___getitem__(self, i)

    def get(self, i: "int const") -> "SoActionMethod":
        r"""get(SoActionMethodList self, int const i) -> SoActionMethod"""
        return _coin.SoActionMethodList_get(self, i)

# Register SoActionMethodList in _coin:
_coin.SoActionMethodList_swigregister(SoActionMethodList)

class SoAction(object):
    r"""Proxy of C++ SoAction class."""

    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 initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAction_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoAction_initClasses()
    NODE = _coin.SoAction_NODE
    
    PATH = _coin.SoAction_PATH
    
    PATH_LIST = _coin.SoAction_PATH_LIST
    
    NO_PATH = _coin.SoAction_NO_PATH
    
    IN_PATH = _coin.SoAction_IN_PATH
    
    BELOW_PATH = _coin.SoAction_BELOW_PATH
    
    OFF_PATH = _coin.SoAction_OFF_PATH
    
    __swig_destroy__ = _coin.delete_SoAction

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAction_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoAction self) -> SoType"""
        return _coin.SoAction_getTypeId(self)

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(SoAction self, SoType type) -> SbBool"""
        return _coin.SoAction_isOfType(self, type)

    def apply(self, *args) -> "void":
        r"""
        apply(SoAction self, SoNode root)
        apply(SoAction self, SoPath path)
        apply(SoAction self, SoPathList pathlist, SbBool obeysrules=0)
        apply(SoAction self, SoAction beingApplied)
        """
        return _coin.SoAction_apply(self, *args)

    def invalidateState(self) -> "void":
        r"""invalidateState(SoAction self)"""
        return _coin.SoAction_invalidateState(self)

    @staticmethod
    def nullAction(action: "SoAction", node: "SoNode") -> "void":
        r"""nullAction(SoAction action, SoNode node)"""
        return _coin.SoAction_nullAction(action, node)

    def getWhatAppliedTo(self) -> "SoAction::AppliedCode":
        r"""getWhatAppliedTo(SoAction self) -> SoAction::AppliedCode"""
        return _coin.SoAction_getWhatAppliedTo(self)

    def getNodeAppliedTo(self) -> "SoNode *":
        r"""getNodeAppliedTo(SoAction self) -> SoNode"""
        return _coin.SoAction_getNodeAppliedTo(self)

    def getPathAppliedTo(self) -> "SoPath *":
        r"""getPathAppliedTo(SoAction self) -> SoPath"""
        return _coin.SoAction_getPathAppliedTo(self)

    def getPathListAppliedTo(self) -> "SoPathList const *":
        r"""getPathListAppliedTo(SoAction self) -> SoPathList"""
        return _coin.SoAction_getPathListAppliedTo(self)

    def getOriginalPathListAppliedTo(self) -> "SoPathList const *":
        r"""getOriginalPathListAppliedTo(SoAction self) -> SoPathList"""
        return _coin.SoAction_getOriginalPathListAppliedTo(self)

    def isLastPathListAppliedTo(self) -> "SbBool":
        r"""isLastPathListAppliedTo(SoAction self) -> SbBool"""
        return _coin.SoAction_isLastPathListAppliedTo(self)

    def getPathCode(self, numindices: "int &", indices: "int const *&") -> "SoAction::PathCode":
        r"""getPathCode(SoAction self, int & numindices, int const *& indices) -> SoAction::PathCode"""
        return _coin.SoAction_getPathCode(self, numindices, indices)

    def traverse(self, node: "SoNode") -> "void":
        r"""traverse(SoAction self, SoNode node)"""
        return _coin.SoAction_traverse(self, node)

    def hasTerminated(self) -> "SbBool":
        r"""hasTerminated(SoAction self) -> SbBool"""
        return _coin.SoAction_hasTerminated(self)

    def getCurPath(self) -> "SoPath const *":
        r"""getCurPath(SoAction self) -> SoPath"""
        return _coin.SoAction_getCurPath(self)

    def getState(self) -> "SoState *":
        r"""getState(SoAction self) -> SoState"""
        return _coin.SoAction_getState(self)

    def getCurPathCode(self) -> "SoAction::PathCode":
        r"""getCurPathCode(SoAction self) -> SoAction::PathCode"""
        return _coin.SoAction_getCurPathCode(self)

    def getCurPathTail(self) -> "SoNode *":
        r"""getCurPathTail(SoAction self) -> SoNode"""
        return _coin.SoAction_getCurPathTail(self)

    def usePathCode(self, numindices: "int &", indices: "int const *&") -> "void":
        r"""usePathCode(SoAction self, int & numindices, int const *& indices)"""
        return _coin.SoAction_usePathCode(self, numindices, indices)

    def pushCurPath(self, *args) -> "void":
        r"""
        pushCurPath(SoAction self, int const childindex, SoNode node=None)
        pushCurPath(SoAction self)
        """
        return _coin.SoAction_pushCurPath(self, *args)

    def popPushCurPath(self, childindex: "int const", node: "SoNode"=None) -> "void":
        r"""popPushCurPath(SoAction self, int const childindex, SoNode node=None)"""
        return _coin.SoAction_popPushCurPath(self, childindex, node)

    def popCurPath(self, *args) -> "void":
        r"""
        popCurPath(SoAction self, SoAction::PathCode const prevpathcode)
        popCurPath(SoAction self)
        """
        return _coin.SoAction_popCurPath(self, *args)

    def switchToPathTraversal(self, path: "SoPath") -> "void":
        r"""switchToPathTraversal(SoAction self, SoPath path)"""
        return _coin.SoAction_switchToPathTraversal(self, path)

    def switchToNodeTraversal(self, node: "SoNode") -> "void":
        r"""switchToNodeTraversal(SoAction self, SoNode node)"""
        return _coin.SoAction_switchToNodeTraversal(self, node)

# Register SoAction in _coin:
_coin.SoAction_swigregister(SoAction)

def SoAction_initClass() -> "void":
    r"""SoAction_initClass()"""
    return _coin.SoAction_initClass()

def SoAction_initClasses() -> "void":
    r"""SoAction_initClasses()"""
    return _coin.SoAction_initClasses()

def SoAction_getClassTypeId() -> "SoType":
    r"""SoAction_getClassTypeId() -> SoType"""
    return _coin.SoAction_getClassTypeId()

def SoAction_nullAction(action: "SoAction", node: "SoNode") -> "void":
    r"""SoAction_nullAction(SoAction action, SoNode node)"""
    return _coin.SoAction_nullAction(action, node)

class SoState(object):
    r"""Proxy of C++ SoState class."""

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

    def __init__(self, action: "SoAction", enabledelements: "SoTypeList"):
        r"""__init__(SoState self, SoAction action, SoTypeList enabledelements) -> SoState"""
        _coin.SoState_swiginit(self, _coin.new_SoState(action, enabledelements))
    __swig_destroy__ = _coin.delete_SoState

    def getAction(self) -> "SoAction *":
        r"""getAction(SoState self) -> SoAction"""
        return _coin.SoState_getAction(self)

    def getElement(self, stackindex: "int const") -> "SoElement *":
        r"""getElement(SoState self, int const stackindex) -> SoElement"""
        return _coin.SoState_getElement(self, stackindex)

    def getConstElement(self, stackindex: "int const") -> "SoElement const *":
        r"""getConstElement(SoState self, int const stackindex) -> SoElement"""
        return _coin.SoState_getConstElement(self, stackindex)

    def push(self) -> "void":
        r"""push(SoState self)"""
        return _coin.SoState_push(self)

    def pop(self) -> "void":
        r"""pop(SoState self)"""
        return _coin.SoState_pop(self)

    def output(self, *args) -> "void":
        r"""output(SoState self, FILE *const file=stdout)"""
        return _coin.SoState_output(self, *args)

    def isElementEnabled(self, stackindex: "int const") -> "SbBool":
        r"""isElementEnabled(SoState self, int const stackindex) -> SbBool"""
        return _coin.SoState_isElementEnabled(self, stackindex)

    def getDepth(self) -> "int":
        r"""getDepth(SoState self) -> int"""
        return _coin.SoState_getDepth(self)

    def setCacheOpen(self, flag: "SbBool const") -> "void":
        r"""setCacheOpen(SoState self, SbBool const flag)"""
        return _coin.SoState_setCacheOpen(self, flag)

    def isCacheOpen(self) -> "SbBool":
        r"""isCacheOpen(SoState self) -> SbBool"""
        return _coin.SoState_isCacheOpen(self)

    def getElementNoPush(self, stackindex: "int const") -> "SoElement *":
        r"""getElementNoPush(SoState self, int const stackindex) -> SoElement"""
        return _coin.SoState_getElementNoPush(self, stackindex)

# Register SoState in _coin:
_coin.SoState_swigregister(SoState)

class SoElement(object):
    r"""Proxy of C++ SoElement class."""

    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 initClass() -> "void":
        r"""initClass()"""
        return _coin.SoElement_initClass()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoElement_getClassStackIndex()

    def getTypeId(self) -> "SoType const":
        r"""getTypeId(SoElement self) -> SoType"""
        return _coin.SoElement_getTypeId(self)

    def getStackIndex(self) -> "int":
        r"""getStackIndex(SoElement self) -> int"""
        return _coin.SoElement_getStackIndex(self)

    def init(self, state: "SoState") -> "void":
        r"""init(SoElement self, SoState state)"""
        return _coin.SoElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoElement self, SoState state)"""
        return _coin.SoElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoElement_pop(self, state, prevTopElement)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoElement self, SoElement element) -> SbBool"""
        return _coin.SoElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoElement self) -> SoElement"""
        return _coin.SoElement_copyMatchInfo(self)

    @staticmethod
    def initElements() -> "void":
        r"""initElements()"""
        return _coin.SoElement_initElements()

    @staticmethod
    def getNumStackIndices() -> "int":
        r"""getNumStackIndices() -> int"""
        return _coin.SoElement_getNumStackIndices()

    @staticmethod
    def getIdFromStackIndex(stackIndex: "int const") -> "SoType":
        r"""getIdFromStackIndex(int const stackIndex) -> SoType"""
        return _coin.SoElement_getIdFromStackIndex(stackIndex)

    def setDepth(self, depth: "int const") -> "void":
        r"""setDepth(SoElement self, int const depth)"""
        return _coin.SoElement_setDepth(self, depth)

    def getDepth(self) -> "int":
        r"""getDepth(SoElement self) -> int"""
        return _coin.SoElement_getDepth(self)

    def output(self, *args) -> "void":
        r"""output(SoElement self, FILE * file=stdout)"""
        return _coin.SoElement_output(self, *args)
    __swig_destroy__ = _coin.delete_SoElement

# Register SoElement in _coin:
_coin.SoElement_swigregister(SoElement)

def SoElement_initClass() -> "void":
    r"""SoElement_initClass()"""
    return _coin.SoElement_initClass()

def SoElement_getClassTypeId() -> "SoType":
    r"""SoElement_getClassTypeId() -> SoType"""
    return _coin.SoElement_getClassTypeId()

def SoElement_getClassStackIndex() -> "int":
    r"""SoElement_getClassStackIndex() -> int"""
    return _coin.SoElement_getClassStackIndex()

def SoElement_initElements() -> "void":
    r"""SoElement_initElements()"""
    return _coin.SoElement_initElements()

def SoElement_getNumStackIndices() -> "int":
    r"""SoElement_getNumStackIndices() -> int"""
    return _coin.SoElement_getNumStackIndices()

def SoElement_getIdFromStackIndex(stackIndex: "int const") -> "SoType":
    r"""SoElement_getIdFromStackIndex(int const stackIndex) -> SoType"""
    return _coin.SoElement_getIdFromStackIndex(stackIndex)

class SoInt32Element(SoElement):
    r"""Proxy of C++ SoInt32Element class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInt32Element_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoInt32Element_getClassStackIndex()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInt32Element_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoInt32Element self, SoState state)"""
        return _coin.SoInt32Element_init(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoInt32Element self, SoElement element) -> SbBool"""
        return _coin.SoInt32Element_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoInt32Element self) -> SoElement"""
        return _coin.SoInt32Element_copyMatchInfo(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoInt32Element self, FILE * file)"""
        return _coin.SoInt32Element_output(self, file)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(int const index, SoState state, SoNode node, int32_t const value)
        set(int const index, SoState state, int32_t const value)
        """
        return _coin.SoInt32Element_set(*args)

    @staticmethod
    def get(index: "int const", state: "SoState") -> "int32_t":
        r"""get(int const index, SoState state) -> int32_t"""
        return _coin.SoInt32Element_get(index, state)

    def setElt(self, value: "int32_t") -> "void":
        r"""setElt(SoInt32Element self, int32_t value)"""
        return _coin.SoInt32Element_setElt(self, value)

# Register SoInt32Element in _coin:
_coin.SoInt32Element_swigregister(SoInt32Element)

def SoInt32Element_getClassTypeId() -> "SoType":
    r"""SoInt32Element_getClassTypeId() -> SoType"""
    return _coin.SoInt32Element_getClassTypeId()

def SoInt32Element_getClassStackIndex() -> "int":
    r"""SoInt32Element_getClassStackIndex() -> int"""
    return _coin.SoInt32Element_getClassStackIndex()

def SoInt32Element_initClass() -> "void":
    r"""SoInt32Element_initClass()"""
    return _coin.SoInt32Element_initClass()

def SoInt32Element_set(*args) -> "void":
    r"""
    SoInt32Element_set(int const index, SoState state, SoNode node, int32_t const value)
    SoInt32Element_set(int const index, SoState state, int32_t const value)
    """
    return _coin.SoInt32Element_set(*args)

def SoInt32Element_get(index: "int const", state: "SoState") -> "int32_t":
    r"""SoInt32Element_get(int const index, SoState state) -> int32_t"""
    return _coin.SoInt32Element_get(index, state)

class SoDecimationTypeElement(SoInt32Element):
    r"""Proxy of C++ SoDecimationTypeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecimationTypeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoDecimationTypeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDecimationTypeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDecimationTypeElement_initClass()
    AUTOMATIC = _coin.SoDecimationTypeElement_AUTOMATIC
    
    HIGHEST = _coin.SoDecimationTypeElement_HIGHEST
    
    LOWEST = _coin.SoDecimationTypeElement_LOWEST
    
    PERCENTAGE = _coin.SoDecimationTypeElement_PERCENTAGE
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoDecimationTypeElement self, SoState state)"""
        return _coin.SoDecimationTypeElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoDecimationTypeElement::Type const type)
        set(SoState state, SoNode node, SoDecimationTypeElement::Type const type)
        """
        return _coin.SoDecimationTypeElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoDecimationTypeElement::Type":
        r"""get(SoState state) -> SoDecimationTypeElement::Type"""
        return _coin.SoDecimationTypeElement_get(state)

    @staticmethod
    def getDefault() -> "SoDecimationTypeElement::Type":
        r"""getDefault() -> SoDecimationTypeElement::Type"""
        return _coin.SoDecimationTypeElement_getDefault()

# Register SoDecimationTypeElement in _coin:
_coin.SoDecimationTypeElement_swigregister(SoDecimationTypeElement)

def SoDecimationTypeElement_getClassTypeId() -> "SoType":
    r"""SoDecimationTypeElement_getClassTypeId() -> SoType"""
    return _coin.SoDecimationTypeElement_getClassTypeId()

def SoDecimationTypeElement_getClassStackIndex() -> "int":
    r"""SoDecimationTypeElement_getClassStackIndex() -> int"""
    return _coin.SoDecimationTypeElement_getClassStackIndex()

def SoDecimationTypeElement_createInstance() -> "void *":
    r"""SoDecimationTypeElement_createInstance() -> void *"""
    return _coin.SoDecimationTypeElement_createInstance()

def SoDecimationTypeElement_initClass() -> "void":
    r"""SoDecimationTypeElement_initClass()"""
    return _coin.SoDecimationTypeElement_initClass()

def SoDecimationTypeElement_set(*args) -> "void":
    r"""
    SoDecimationTypeElement_set(SoState state, SoDecimationTypeElement::Type const type)
    SoDecimationTypeElement_set(SoState state, SoNode node, SoDecimationTypeElement::Type const type)
    """
    return _coin.SoDecimationTypeElement_set(*args)

def SoDecimationTypeElement_get(state: "SoState") -> "SoDecimationTypeElement::Type":
    r"""SoDecimationTypeElement_get(SoState state) -> SoDecimationTypeElement::Type"""
    return _coin.SoDecimationTypeElement_get(state)

def SoDecimationTypeElement_getDefault() -> "SoDecimationTypeElement::Type":
    r"""SoDecimationTypeElement_getDefault() -> SoDecimationTypeElement::Type"""
    return _coin.SoDecimationTypeElement_getDefault()

class SoFieldData(object):
    r"""Proxy of C++ SoFieldData class."""

    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):
        r"""
        __init__(SoFieldData self) -> SoFieldData
        __init__(SoFieldData self, SoFieldData fd) -> SoFieldData
        __init__(SoFieldData self, SoFieldData fd) -> SoFieldData
        __init__(SoFieldData self, int numfields) -> SoFieldData
        """
        _coin.SoFieldData_swiginit(self, _coin.new_SoFieldData(*args))
    __swig_destroy__ = _coin.delete_SoFieldData

    def addField(self, base: "SoFieldContainer", name: "char const *", field: "SoField") -> "void":
        r"""addField(SoFieldData self, SoFieldContainer base, char const * name, SoField field)"""
        return _coin.SoFieldData_addField(self, base, name, field)

    def overlay(self, destTo: "SoFieldContainer", srcFrom: "SoFieldContainer", copyconnections: "SbBool") -> "void":
        r"""overlay(SoFieldData self, SoFieldContainer destTo, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoFieldData_overlay(self, destTo, srcFrom, copyconnections)

    def getNumFields(self) -> "int":
        r"""getNumFields(SoFieldData self) -> int"""
        return _coin.SoFieldData_getNumFields(self)

    def getFieldName(self, index: "int") -> "SbName const &":
        r"""getFieldName(SoFieldData self, int index) -> SbName"""
        return _coin.SoFieldData_getFieldName(self, index)

    def getField(self, object: "SoFieldContainer", index: "int") -> "SoField *":
        r"""getField(SoFieldData self, SoFieldContainer object, int index) -> SoField"""
        return _coin.SoFieldData_getField(self, object, index)

    def getIndex(self, fc: "SoFieldContainer", field: "SoField") -> "int":
        r"""getIndex(SoFieldData self, SoFieldContainer fc, SoField field) -> int"""
        return _coin.SoFieldData_getIndex(self, fc, field)

    def addEnumValue(self, enumname: "char const *", valuename: "char const *", value: "int") -> "void":
        r"""addEnumValue(SoFieldData self, char const * enumname, char const * valuename, int value)"""
        return _coin.SoFieldData_addEnumValue(self, enumname, valuename, value)

    def getEnumData(self, enumname: "char const *", num: "int &", values: "int const *&", names: "SbName const *&") -> "void":
        r"""getEnumData(SoFieldData self, char const * enumname, int & num, int const *& values, SbName const *& names)"""
        return _coin.SoFieldData_getEnumData(self, enumname, num, values, names)

    def read(self, *args) -> "SbBool":
        r"""
        read(SoFieldData self, SoInput input, SoFieldContainer object, SbBool erroronunknownfield, SbBool & notbuiltin) -> SbBool
        read(SoFieldData self, SoInput input, SoFieldContainer object, SbName fieldname, SbBool & foundname) -> SbBool
        """
        return _coin.SoFieldData_read(self, *args)

    def write(self, out: "SoOutput", object: "SoFieldContainer") -> "void":
        r"""write(SoFieldData self, SoOutput out, SoFieldContainer object)"""
        return _coin.SoFieldData_write(self, out, object)

    def copy(self, src: "SoFieldData") -> "void":
        r"""copy(SoFieldData self, SoFieldData src)"""
        return _coin.SoFieldData_copy(self, src)

    def isSame(self, c1: "SoFieldContainer", c2: "SoFieldContainer") -> "SbBool":
        r"""isSame(SoFieldData self, SoFieldContainer c1, SoFieldContainer c2) -> SbBool"""
        return _coin.SoFieldData_isSame(self, c1, c2)

    def readFieldDescriptions(self, input: "SoInput", object: "SoFieldContainer", numdescriptionsexpected: "int", readfieldvalues: "SbBool const"=1) -> "SbBool":
        r"""readFieldDescriptions(SoFieldData self, SoInput input, SoFieldContainer object, int numdescriptionsexpected, SbBool const readfieldvalues=1) -> SbBool"""
        return _coin.SoFieldData_readFieldDescriptions(self, input, object, numdescriptionsexpected, readfieldvalues)

    def writeFieldDescriptions(self, out: "SoOutput", object: "SoFieldContainer") -> "void":
        r"""writeFieldDescriptions(SoFieldData self, SoOutput out, SoFieldContainer object)"""
        return _coin.SoFieldData_writeFieldDescriptions(self, out, object)

# Register SoFieldData in _coin:
_coin.SoFieldData_swigregister(SoFieldData)

class SoFieldContainer(SoBase):
    r"""Proxy of C++ SoFieldContainer class."""

    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 initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFieldContainer_initClass()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFieldContainer_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoFieldContainer_cleanupClass()

    def setToDefaults(self) -> "void":
        r"""setToDefaults(SoFieldContainer self)"""
        return _coin.SoFieldContainer_setToDefaults(self)

    def hasDefaultValues(self) -> "SbBool":
        r"""hasDefaultValues(SoFieldContainer self) -> SbBool"""
        return _coin.SoFieldContainer_hasDefaultValues(self)

    def fieldsAreEqual(self, container: "SoFieldContainer") -> "SbBool":
        r"""fieldsAreEqual(SoFieldContainer self, SoFieldContainer container) -> SbBool"""
        return _coin.SoFieldContainer_fieldsAreEqual(self, container)

    def copyFieldValues(self, container: "SoFieldContainer", copyconnections: "SbBool"=0) -> "void":
        r"""copyFieldValues(SoFieldContainer self, SoFieldContainer container, SbBool copyconnections=0)"""
        return _coin.SoFieldContainer_copyFieldValues(self, container, copyconnections)

    def getFields(self, l: "SoFieldList") -> "int":
        r"""getFields(SoFieldContainer self, SoFieldList l) -> int"""
        return _coin.SoFieldContainer_getFields(self, l)

    def getAllFields(self, l: "SoFieldList") -> "int":
        r"""getAllFields(SoFieldContainer self, SoFieldList l) -> int"""
        return _coin.SoFieldContainer_getAllFields(self, l)

    def getField(self, name: "SbName") -> "SoField *":
        r"""getField(SoFieldContainer self, SbName name) -> SoField"""
        return _coin.SoFieldContainer_getField(self, name)

    def getEventIn(self, name: "SbName") -> "SoField *":
        r"""getEventIn(SoFieldContainer self, SbName name) -> SoField"""
        return _coin.SoFieldContainer_getEventIn(self, name)

    def getEventOut(self, name: "SbName") -> "SoField *":
        r"""getEventOut(SoFieldContainer self, SbName name) -> SoField"""
        return _coin.SoFieldContainer_getEventOut(self, name)

    def enableNotify(self, flag: "SbBool const") -> "SbBool":
        r"""enableNotify(SoFieldContainer self, SbBool const flag) -> SbBool"""
        return _coin.SoFieldContainer_enableNotify(self, flag)

    def isNotifyEnabled(self) -> "SbBool":
        r"""isNotifyEnabled(SoFieldContainer self) -> SbBool"""
        return _coin.SoFieldContainer_isNotifyEnabled(self)

    def set(self, *args) -> "SbBool":
        r"""
        set(SoFieldContainer self, char const *const fielddata) -> SbBool
        set(SoFieldContainer self, char const * fielddata, SoInput input) -> SbBool
        """
        return _coin.SoFieldContainer_set(self, *args)

    def get(self, *args) -> "void":
        r"""
        get(SoFieldContainer self, SbString fielddata)
        get(SoFieldContainer self, SbString fielddata, SoOutput out)
        """
        return _coin.SoFieldContainer_get(self, *args)

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoFieldContainer self, SoNotList l)"""
        return _coin.SoFieldContainer_notify(self, l)

    def validateNewFieldValue(self, field: "SoField", newval: "void *") -> "SbBool":
        r"""validateNewFieldValue(SoFieldContainer self, SoField field, void * newval) -> SbBool"""
        return _coin.SoFieldContainer_validateNewFieldValue(self, field, newval)

    def addWriteReference(self, out: "SoOutput", isfromfield: "SbBool"=0) -> "void":
        r"""addWriteReference(SoFieldContainer self, SoOutput out, SbBool isfromfield=0)"""
        return _coin.SoFieldContainer_addWriteReference(self, out, isfromfield)

    def writeInstance(self, out: "SoOutput") -> "void":
        r"""writeInstance(SoFieldContainer self, SoOutput out)"""
        return _coin.SoFieldContainer_writeInstance(self, out)

    def getIsBuiltIn(self) -> "SbBool":
        r"""getIsBuiltIn(SoFieldContainer self) -> SbBool"""
        return _coin.SoFieldContainer_getIsBuiltIn(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoFieldContainer self) -> SoFieldData"""
        return _coin.SoFieldContainer_getFieldData(self)

    def copyContents(self, srcFrom: "SoFieldContainer", copyconnections: "SbBool") -> "void":
        r"""copyContents(SoFieldContainer self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoFieldContainer_copyContents(self, srcFrom, copyconnections)

    def copyThroughConnection(self) -> "SoFieldContainer *":
        r"""copyThroughConnection(SoFieldContainer self) -> SoFieldContainer"""
        return _coin.SoFieldContainer_copyThroughConnection(self)

    @staticmethod
    def initCopyDict() -> "void":
        r"""initCopyDict()"""
        return _coin.SoFieldContainer_initCopyDict()

    @staticmethod
    def addCopy(orig: "SoFieldContainer", copy: "SoFieldContainer") -> "void":
        r"""addCopy(SoFieldContainer orig, SoFieldContainer copy)"""
        return _coin.SoFieldContainer_addCopy(orig, copy)

    @staticmethod
    def checkCopy(orig: "SoFieldContainer") -> "SoFieldContainer *":
        r"""checkCopy(SoFieldContainer orig) -> SoFieldContainer"""
        return _coin.SoFieldContainer_checkCopy(orig)

    @staticmethod
    def findCopy(orig: "SoFieldContainer", copyconnections: "SbBool const") -> "SoFieldContainer *":
        r"""findCopy(SoFieldContainer orig, SbBool const copyconnections) -> SoFieldContainer"""
        return _coin.SoFieldContainer_findCopy(orig, copyconnections)

    @staticmethod
    def copyDone() -> "void":
        r"""copyDone()"""
        return _coin.SoFieldContainer_copyDone()

    def getFieldsMemorySize(self, managed: "size_t &", unmanaged: "size_t &") -> "void":
        r"""getFieldsMemorySize(SoFieldContainer self, size_t & managed, size_t & unmanaged)"""
        return _coin.SoFieldContainer_getFieldsMemorySize(self, managed, unmanaged)

    def setUserData(self, userdata: "void *") -> "void":
        r"""setUserData(SoFieldContainer self, void * userdata)"""
        return _coin.SoFieldContainer_setUserData(self, userdata)

    def getUserData(self) -> "void *":
        r"""getUserData(SoFieldContainer self) -> void *"""
        return _coin.SoFieldContainer_getUserData(self)

    def getFieldName(self, *args) -> "PyObject *":
        r"""
        getFieldName(SoFieldContainer self, SoField field, SbName name) -> SbBool
        getFieldName(SoFieldContainer self, SoField field) -> PyObject *
        """
        return _coin.SoFieldContainer_getFieldName(self, *args)

    def __getattr__(self, name):
        try:
            return SoBase.__getattribute__(self, name)
        except AttributeError as e:
    ##############################################################
            if name == "this":
                raise AttributeError
    ##############################################################
            field = self.getField(name)
            if field is None:
                raise e
            return field

    def __setattr__(self, name, value):
    # I don't understand why we need this, but otherwise it does not work :/
        if name == 'this':
            return SoBase.__setattr__(self, name, value)
        field = self.getField(name)
        if field is None:
            return SoBase.__setattr__(self, name, value)
        field.setValue(value)
        return field

    def __dir__(self):
        from pivy import coin
        fl = coin.SoFieldList()
        num_fields = self.getAllFields(fl)
        fields = [self.getFieldName(fl[i]) for i in range(num_fields)]
        return super(SoFieldContainer, self).__dir__() + fields


    @property
    def values(self):
        def _values(obj):
            for value in obj:
                if hasattr(value, "__iter__"):
                    yield list(_values(value))
                else:
                    yield value
        out = _values(self)
        return list(out)

    @values.setter
    def values(self, arr):
        self.deleteValues(0)
        self.setValues(0, len(arr), arr)



# Register SoFieldContainer in _coin:
_coin.SoFieldContainer_swigregister(SoFieldContainer)

def SoFieldContainer_initClass() -> "void":
    r"""SoFieldContainer_initClass()"""
    return _coin.SoFieldContainer_initClass()

def SoFieldContainer_getClassTypeId() -> "SoType":
    r"""SoFieldContainer_getClassTypeId() -> SoType"""
    return _coin.SoFieldContainer_getClassTypeId()

def SoFieldContainer_cleanupClass() -> "void":
    r"""SoFieldContainer_cleanupClass()"""
    return _coin.SoFieldContainer_cleanupClass()

def SoFieldContainer_initCopyDict() -> "void":
    r"""SoFieldContainer_initCopyDict()"""
    return _coin.SoFieldContainer_initCopyDict()

def SoFieldContainer_addCopy(orig: "SoFieldContainer", copy: "SoFieldContainer") -> "void":
    r"""SoFieldContainer_addCopy(SoFieldContainer orig, SoFieldContainer copy)"""
    return _coin.SoFieldContainer_addCopy(orig, copy)

def SoFieldContainer_checkCopy(orig: "SoFieldContainer") -> "SoFieldContainer *":
    r"""SoFieldContainer_checkCopy(SoFieldContainer orig) -> SoFieldContainer"""
    return _coin.SoFieldContainer_checkCopy(orig)

def SoFieldContainer_findCopy(orig: "SoFieldContainer", copyconnections: "SbBool const") -> "SoFieldContainer *":
    r"""SoFieldContainer_findCopy(SoFieldContainer orig, SbBool const copyconnections) -> SoFieldContainer"""
    return _coin.SoFieldContainer_findCopy(orig, copyconnections)

def SoFieldContainer_copyDone() -> "void":
    r"""SoFieldContainer_copyDone()"""
    return _coin.SoFieldContainer_copyDone()

class SoNode(SoFieldContainer):
    r"""Proxy of C++ SoNode class."""

    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
    FIRST_INSTANCE = _coin.SoNode_FIRST_INSTANCE
    
    PROTO_INSTANCE = _coin.SoNode_PROTO_INSTANCE
    
    OTHER_INSTANCE = _coin.SoNode_OTHER_INSTANCE
    

    def setOverride(self, state: "SbBool const") -> "void":
        r"""setOverride(SoNode self, SbBool const state)"""
        return _coin.SoNode_setOverride(self, state)

    def isOverride(self) -> "SbBool":
        r"""isOverride(SoNode self) -> SbBool"""
        return _coin.SoNode_isOverride(self)
    INVENTOR = _coin.SoNode_INVENTOR
    
    VRML1 = _coin.SoNode_VRML1
    
    VRML2 = _coin.SoNode_VRML2
    
    INVENTOR_1 = _coin.SoNode_INVENTOR_1
    
    INVENTOR_2_0 = _coin.SoNode_INVENTOR_2_0
    
    INVENTOR_2_1 = _coin.SoNode_INVENTOR_2_1
    
    INVENTOR_2_5 = _coin.SoNode_INVENTOR_2_5
    
    INVENTOR_2_6 = _coin.SoNode_INVENTOR_2_6
    
    COIN_1_0 = _coin.SoNode_COIN_1_0
    
    COIN_2_0 = _coin.SoNode_COIN_2_0
    
    EXTENSION = _coin.SoNode_EXTENSION
    
    COIN_2_2 = _coin.SoNode_COIN_2_2
    
    COIN_2_3 = _coin.SoNode_COIN_2_3
    
    COIN_2_4 = _coin.SoNode_COIN_2_4
    
    INVENTOR_5_0 = _coin.SoNode_INVENTOR_5_0
    
    COIN_2_5 = _coin.SoNode_COIN_2_5
    
    COIN_3_0 = _coin.SoNode_COIN_3_0
    
    INVENTOR_6_0 = _coin.SoNode_INVENTOR_6_0
    
    COIN_4_0 = _coin.SoNode_COIN_4_0
    

    @staticmethod
    def getCompatibilityTypes(nodetype: "SoType") -> "uint32_t":
        r"""getCompatibilityTypes(SoType nodetype) -> uint32_t"""
        return _coin.SoNode_getCompatibilityTypes(nodetype)

    def setNodeType(self, type: "SoNode::NodeType const") -> "void":
        r"""setNodeType(SoNode self, SoNode::NodeType const type)"""
        return _coin.SoNode_setNodeType(self, type)

    def getNodeType(self) -> "SoNode::NodeType":
        r"""getNodeType(SoNode self) -> SoNode::NodeType"""
        return _coin.SoNode_getNodeType(self)

    def copy(self, copyconnections: "SbBool"=0) -> "SoNode *":
        r"""copy(SoNode self, SbBool copyconnections=0) -> SoNode"""
        return _coin.SoNode_copy(self, copyconnections)

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoNode self) -> SbBool"""
        return _coin.SoNode_affectsState(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoNode self, SoAction action)"""
        return _coin.SoNode_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoNode self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRender(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoNode self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoNode self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderOffPath(SoNode self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRenderOffPath(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoNode self, SoCallbackAction action)"""
        return _coin.SoNode_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoNode self, SoGetBoundingBoxAction action)"""
        return _coin.SoNode_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoNode self, SoGetMatrixAction action)"""
        return _coin.SoNode_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoNode self, SoHandleEventAction action)"""
        return _coin.SoNode_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoNode self, SoPickAction action)"""
        return _coin.SoNode_pick(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoNode self, SoRayPickAction action)"""
        return _coin.SoNode_rayPick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoNode self, SoSearchAction action)"""
        return _coin.SoNode_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoNode self, SoWriteAction action)"""
        return _coin.SoNode_write(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoNode self, SoAudioRenderAction action)"""
        return _coin.SoNode_audioRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoNode self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNode_getPrimitiveCount(self, action)

    def grabEventsSetup(self) -> "void":
        r"""grabEventsSetup(SoNode self)"""
        return _coin.SoNode_grabEventsSetup(self)

    def grabEventsCleanup(self) -> "void":
        r"""grabEventsCleanup(SoNode self)"""
        return _coin.SoNode_grabEventsCleanup(self)

    def startNotify(self) -> "void":
        r"""startNotify(SoNode self)"""
        return _coin.SoNode_startNotify(self)

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoNode self, SoNotList l)"""
        return _coin.SoNode_notify(self, l)

    def getNodeId(self) -> "SbUniqueId":
        r"""getNodeId(SoNode self) -> SbUniqueId"""
        return _coin.SoNode_getNodeId(self)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoNode self) -> SoChildList"""
        return _coin.SoNode_getChildren(self)

    def writeInstance(self, out: "SoOutput") -> "void":
        r"""writeInstance(SoNode self, SoOutput out)"""
        return _coin.SoNode_writeInstance(self, out)

    def addToCopyDict(self) -> "SoNode *":
        r"""addToCopyDict(SoNode self) -> SoNode"""
        return _coin.SoNode_addToCopyDict(self)

    def copyContents(self, srcFrom: "SoFieldContainer", copyconnections: "SbBool") -> "void":
        r"""copyContents(SoNode self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoNode_copyContents(self, srcFrom, copyconnections)

    def copyThroughConnection(self) -> "SoFieldContainer *":
        r"""copyThroughConnection(SoNode self) -> SoFieldContainer"""
        return _coin.SoNode_copyThroughConnection(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNode_getClassTypeId()

    @staticmethod
    def getByName(*args) -> "int":
        r"""
        getByName(SbName name) -> SoNode
        getByName(SbName name, SoNodeList l) -> int
        """
        return _coin.SoNode_getByName(*args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNode_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoNode_initClasses()

    @staticmethod
    def getNextNodeId() -> "SbUniqueId":
        r"""getNextNodeId() -> SbUniqueId"""
        return _coin.SoNode_getNextNodeId()

    @staticmethod
    def getActionMethodIndex(type: "SoType") -> "int":
        r"""getActionMethodIndex(SoType type) -> int"""
        return _coin.SoNode_getActionMethodIndex(type)

    @staticmethod
    def getBoundingBoxS(action: "SoAction", node: "SoNode") -> "void":
        r"""getBoundingBoxS(SoAction action, SoNode node)"""
        return _coin.SoNode_getBoundingBoxS(action, node)

    @staticmethod
    def GLRenderS(action: "SoAction", node: "SoNode") -> "void":
        r"""GLRenderS(SoAction action, SoNode node)"""
        return _coin.SoNode_GLRenderS(action, node)

    @staticmethod
    def callbackS(action: "SoAction", node: "SoNode") -> "void":
        r"""callbackS(SoAction action, SoNode node)"""
        return _coin.SoNode_callbackS(action, node)

    @staticmethod
    def getMatrixS(action: "SoAction", node: "SoNode") -> "void":
        r"""getMatrixS(SoAction action, SoNode node)"""
        return _coin.SoNode_getMatrixS(action, node)

    @staticmethod
    def handleEventS(action: "SoAction", node: "SoNode") -> "void":
        r"""handleEventS(SoAction action, SoNode node)"""
        return _coin.SoNode_handleEventS(action, node)

    @staticmethod
    def pickS(action: "SoAction", node: "SoNode") -> "void":
        r"""pickS(SoAction action, SoNode node)"""
        return _coin.SoNode_pickS(action, node)

    @staticmethod
    def rayPickS(action: "SoAction", node: "SoNode") -> "void":
        r"""rayPickS(SoAction action, SoNode node)"""
        return _coin.SoNode_rayPickS(action, node)

    @staticmethod
    def searchS(action: "SoAction", node: "SoNode") -> "void":
        r"""searchS(SoAction action, SoNode node)"""
        return _coin.SoNode_searchS(action, node)

    @staticmethod
    def writeS(action: "SoAction", node: "SoNode") -> "void":
        r"""writeS(SoAction action, SoNode node)"""
        return _coin.SoNode_writeS(action, node)

    @staticmethod
    def audioRenderS(action: "SoAction", node: "SoNode") -> "void":
        r"""audioRenderS(SoAction action, SoNode node)"""
        return _coin.SoNode_audioRenderS(action, node)

    @staticmethod
    def getPrimitiveCountS(action: "SoAction", node: "SoNode") -> "void":
        r"""getPrimitiveCountS(SoAction action, SoNode node)"""
        return _coin.SoNode_getPrimitiveCountS(action, node)

# Register SoNode in _coin:
_coin.SoNode_swigregister(SoNode)

def SoNode_getCompatibilityTypes(nodetype: "SoType") -> "uint32_t":
    r"""SoNode_getCompatibilityTypes(SoType nodetype) -> uint32_t"""
    return _coin.SoNode_getCompatibilityTypes(nodetype)

def SoNode_getClassTypeId() -> "SoType":
    r"""SoNode_getClassTypeId() -> SoType"""
    return _coin.SoNode_getClassTypeId()

def SoNode_getByName(*args) -> "int":
    r"""
    SoNode_getByName(SbName name) -> SoNode
    SoNode_getByName(SbName name, SoNodeList l) -> int
    """
    return _coin.SoNode_getByName(*args)

def SoNode_initClass() -> "void":
    r"""SoNode_initClass()"""
    return _coin.SoNode_initClass()

def SoNode_initClasses() -> "void":
    r"""SoNode_initClasses()"""
    return _coin.SoNode_initClasses()

def SoNode_getNextNodeId() -> "SbUniqueId":
    r"""SoNode_getNextNodeId() -> SbUniqueId"""
    return _coin.SoNode_getNextNodeId()

def SoNode_getActionMethodIndex(type: "SoType") -> "int":
    r"""SoNode_getActionMethodIndex(SoType type) -> int"""
    return _coin.SoNode_getActionMethodIndex(type)

def SoNode_getBoundingBoxS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_getBoundingBoxS(SoAction action, SoNode node)"""
    return _coin.SoNode_getBoundingBoxS(action, node)

def SoNode_GLRenderS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_GLRenderS(SoAction action, SoNode node)"""
    return _coin.SoNode_GLRenderS(action, node)

def SoNode_callbackS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_callbackS(SoAction action, SoNode node)"""
    return _coin.SoNode_callbackS(action, node)

def SoNode_getMatrixS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_getMatrixS(SoAction action, SoNode node)"""
    return _coin.SoNode_getMatrixS(action, node)

def SoNode_handleEventS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_handleEventS(SoAction action, SoNode node)"""
    return _coin.SoNode_handleEventS(action, node)

def SoNode_pickS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_pickS(SoAction action, SoNode node)"""
    return _coin.SoNode_pickS(action, node)

def SoNode_rayPickS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_rayPickS(SoAction action, SoNode node)"""
    return _coin.SoNode_rayPickS(action, node)

def SoNode_searchS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_searchS(SoAction action, SoNode node)"""
    return _coin.SoNode_searchS(action, node)

def SoNode_writeS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_writeS(SoAction action, SoNode node)"""
    return _coin.SoNode_writeS(action, node)

def SoNode_audioRenderS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_audioRenderS(SoAction action, SoNode node)"""
    return _coin.SoNode_audioRenderS(action, node)

def SoNode_getPrimitiveCountS(action: "SoAction", node: "SoNode") -> "void":
    r"""SoNode_getPrimitiveCountS(SoAction action, SoNode node)"""
    return _coin.SoNode_getPrimitiveCountS(action, node)

class SoSensorManager(object):
    r"""Proxy of C++ SoSensorManager class."""

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

    def __init__(self):
        r"""__init__(SoSensorManager self) -> SoSensorManager"""
        _coin.SoSensorManager_swiginit(self, _coin.new_SoSensorManager())
    __swig_destroy__ = _coin.delete_SoSensorManager

    def insertDelaySensor(self, s: "SoDelayQueueSensor") -> "void":
        r"""insertDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"""
        return _coin.SoSensorManager_insertDelaySensor(self, s)

    def insertTimerSensor(self, s: "SoTimerQueueSensor") -> "void":
        r"""insertTimerSensor(SoSensorManager self, SoTimerQueueSensor s)"""
        return _coin.SoSensorManager_insertTimerSensor(self, s)

    def removeDelaySensor(self, s: "SoDelayQueueSensor") -> "void":
        r"""removeDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"""
        return _coin.SoSensorManager_removeDelaySensor(self, s)

    def removeTimerSensor(self, s: "SoTimerQueueSensor") -> "void":
        r"""removeTimerSensor(SoSensorManager self, SoTimerQueueSensor s)"""
        return _coin.SoSensorManager_removeTimerSensor(self, s)

    def rescheduleTimer(self, s: "SoTimerSensor") -> "void":
        r"""rescheduleTimer(SoSensorManager self, SoTimerSensor s)"""
        return _coin.SoSensorManager_rescheduleTimer(self, s)

    def removeRescheduledTimer(self, s: "SoTimerQueueSensor") -> "void":
        r"""removeRescheduledTimer(SoSensorManager self, SoTimerQueueSensor s)"""
        return _coin.SoSensorManager_removeRescheduledTimer(self, s)

    def processDelayQueue(self, isidle: "SbBool") -> "void":
        r"""processDelayQueue(SoSensorManager self, SbBool isidle)"""
        return _coin.SoSensorManager_processDelayQueue(self, isidle)

    def processImmediateQueue(self) -> "void":
        r"""processImmediateQueue(SoSensorManager self)"""
        return _coin.SoSensorManager_processImmediateQueue(self)

    def processTimerQueue(self) -> "void":
        r"""processTimerQueue(SoSensorManager self)"""
        return _coin.SoSensorManager_processTimerQueue(self)

    def isDelaySensorPending(self) -> "SbBool":
        r"""isDelaySensorPending(SoSensorManager self) -> SbBool"""
        return _coin.SoSensorManager_isDelaySensorPending(self)

    def setDelaySensorTimeout(self, t: "SbTime") -> "void":
        r"""setDelaySensorTimeout(SoSensorManager self, SbTime t)"""
        return _coin.SoSensorManager_setDelaySensorTimeout(self, t)

    def getDelaySensorTimeout(self) -> "SbTime const &":
        r"""getDelaySensorTimeout(SoSensorManager self) -> SbTime"""
        return _coin.SoSensorManager_getDelaySensorTimeout(self)

    def doSelect(self, nfds: "int", readfds: "void *", writefds: "void *", exceptfds: "void *", userTimeOut: "timeval *") -> "int":
        r"""doSelect(SoSensorManager self, int nfds, void * readfds, void * writefds, void * exceptfds, timeval * userTimeOut) -> int"""
        return _coin.SoSensorManager_doSelect(self, nfds, readfds, writefds, exceptfds, userTimeOut)

    def setChangedCallback(self, *args) -> "void":
        r"""
        setChangedCallback(SoSensorManager self, void (*)(void *) sensorQueueChangedCB, void * data)
        setChangedCallback(SoSensorManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoSensorManager_setChangedCallback(self, *args)

    def isTimerSensorPending(self, *args) -> "PyObject *":
        r"""
        isTimerSensorPending(SoSensorManager self, SbTime tm) -> SbBool
        isTimerSensorPending(SoSensorManager self) -> PyObject *
        """
        return _coin.SoSensorManager_isTimerSensorPending(self, *args)

# Register SoSensorManager in _coin:
_coin.SoSensorManager_swigregister(SoSensorManager)

class SoDB(object):
    r"""Proxy of C++ SoDB class."""

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

    @staticmethod
    def init() -> "void":
        r"""init()"""
        return _coin.SoDB_init()

    @staticmethod
    def finish() -> "void":
        r"""finish()"""
        return _coin.SoDB_finish()

    @staticmethod
    def cleanup() -> "void":
        r"""cleanup()"""
        return _coin.SoDB_cleanup()

    @staticmethod
    def getVersion() -> "char const *":
        r"""getVersion() -> char const *"""
        return _coin.SoDB_getVersion()

    @staticmethod
    def read(*args) -> "SbBool":
        r"""
        read(SoInput input, SoPath *& path) -> SbBool
        read(SoInput input, SoBase *& base) -> SbBool
        read(SoInput input, SoNode *& rootnode) -> SbBool
        """
        return _coin.SoDB_read(*args)

    @staticmethod
    def readAll(input: "SoInput") -> "SoSeparator *":
        r"""readAll(SoInput input) -> SoSeparator"""
        return _coin.SoDB_readAll(input)

    @staticmethod
    def readAllVRML(input: "SoInput") -> "SoVRMLGroup *":
        r"""readAllVRML(SoInput input) -> SoVRMLGroup"""
        return _coin.SoDB_readAllVRML(input)

    @staticmethod
    def isValidHeader(teststring: "char const *") -> "SbBool":
        r"""isValidHeader(char const * teststring) -> SbBool"""
        return _coin.SoDB_isValidHeader(teststring)

    @staticmethod
    def registerHeader(headerstring: "SbString", isbinary: "SbBool", ivversion: "float", precallback: "SoDBHeaderCB *", postcallback: "SoDBHeaderCB *", userdata: "void *"=None) -> "SbBool":
        r"""registerHeader(SbString headerstring, SbBool isbinary, float ivversion, SoDBHeaderCB * precallback, SoDBHeaderCB * postcallback, void * userdata=None) -> SbBool"""
        return _coin.SoDB_registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata)

    @staticmethod
    def getHeaderData(headerstring: "SbString", isbinary: "SbBool &", ivversion: "float &", precallback: "SoDBHeaderCB *&", postcallback: "SoDBHeaderCB *&", userdata: "void *&", substringok: "SbBool"=0) -> "SbBool":
        r"""getHeaderData(SbString headerstring, SbBool & isbinary, float & ivversion, SoDBHeaderCB *& precallback, SoDBHeaderCB *& postcallback, void *& userdata, SbBool substringok=0) -> SbBool"""
        return _coin.SoDB_getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok)

    @staticmethod
    def getNumHeaders() -> "int":
        r"""getNumHeaders() -> int"""
        return _coin.SoDB_getNumHeaders()

    @staticmethod
    def getHeaderString(i: "int const") -> "SbString":
        r"""getHeaderString(int const i) -> SbString"""
        return _coin.SoDB_getHeaderString(i)

    @staticmethod
    def createGlobalField(name: "SbName", type: "SoType") -> "SoField *":
        r"""createGlobalField(SbName name, SoType type) -> SoField"""
        return _coin.SoDB_createGlobalField(name, type)

    @staticmethod
    def getGlobalField(name: "SbName") -> "SoField *":
        r"""getGlobalField(SbName name) -> SoField"""
        return _coin.SoDB_getGlobalField(name)

    @staticmethod
    def renameGlobalField(srcFrom: "SbName", destTo: "SbName") -> "void":
        r"""renameGlobalField(SbName srcFrom, SbName destTo)"""
        return _coin.SoDB_renameGlobalField(srcFrom, destTo)

    @staticmethod
    def setRealTimeInterval(interval: "SbTime") -> "void":
        r"""setRealTimeInterval(SbTime interval)"""
        return _coin.SoDB_setRealTimeInterval(interval)

    @staticmethod
    def getRealTimeInterval() -> "SbTime const &":
        r"""getRealTimeInterval() -> SbTime"""
        return _coin.SoDB_getRealTimeInterval()

    @staticmethod
    def enableRealTimeSensor(on: "SbBool") -> "void":
        r"""enableRealTimeSensor(SbBool on)"""
        return _coin.SoDB_enableRealTimeSensor(on)

    @staticmethod
    def getSensorManager() -> "SoSensorManager *":
        r"""getSensorManager() -> SoSensorManager"""
        return _coin.SoDB_getSensorManager()

    @staticmethod
    def setDelaySensorTimeout(t: "SbTime") -> "void":
        r"""setDelaySensorTimeout(SbTime t)"""
        return _coin.SoDB_setDelaySensorTimeout(t)

    @staticmethod
    def getDelaySensorTimeout() -> "SbTime const &":
        r"""getDelaySensorTimeout() -> SbTime"""
        return _coin.SoDB_getDelaySensorTimeout()

    @staticmethod
    def doSelect(nfds: "int", readfds: "void *", writefds: "void *", exceptfds: "void *", usertimeout: "timeval *") -> "int":
        r"""doSelect(int nfds, void * readfds, void * writefds, void * exceptfds, timeval * usertimeout) -> int"""
        return _coin.SoDB_doSelect(nfds, readfds, writefds, exceptfds, usertimeout)

    @staticmethod
    def addConverter(srcFrom: "SoType", destTo: "SoType", converter: "SoType") -> "void":
        r"""addConverter(SoType srcFrom, SoType destTo, SoType converter)"""
        return _coin.SoDB_addConverter(srcFrom, destTo, converter)

    @staticmethod
    def getConverter(srcFrom: "SoType", destTo: "SoType") -> "SoType":
        r"""getConverter(SoType srcFrom, SoType destTo) -> SoType"""
        return _coin.SoDB_getConverter(srcFrom, destTo)

    @staticmethod
    def isInitialized() -> "SbBool":
        r"""isInitialized() -> SbBool"""
        return _coin.SoDB_isInitialized()

    @staticmethod
    def startNotify() -> "void":
        r"""startNotify()"""
        return _coin.SoDB_startNotify()

    @staticmethod
    def isNotifying() -> "SbBool":
        r"""isNotifying() -> SbBool"""
        return _coin.SoDB_isNotifying()

    @staticmethod
    def endNotify() -> "void":
        r"""endNotify()"""
        return _coin.SoDB_endNotify()

    @staticmethod
    def addProgressCallback(func: "SoDB::ProgressCallbackType *", userdata: "void *") -> "void":
        r"""addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
        return _coin.SoDB_addProgressCallback(func, userdata)

    @staticmethod
    def removeProgressCallback(func: "SoDB::ProgressCallbackType *", userdata: "void *") -> "void":
        r"""removeProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
        return _coin.SoDB_removeProgressCallback(func, userdata)

    @staticmethod
    def isMultiThread() -> "SbBool":
        r"""isMultiThread() -> SbBool"""
        return _coin.SoDB_isMultiThread()

    @staticmethod
    def readlock() -> "void":
        r"""readlock()"""
        return _coin.SoDB_readlock()

    @staticmethod
    def readunlock() -> "void":
        r"""readunlock()"""
        return _coin.SoDB_readunlock()

    @staticmethod
    def writelock() -> "void":
        r"""writelock()"""
        return _coin.SoDB_writelock()

    @staticmethod
    def writeunlock() -> "void":
        r"""writeunlock()"""
        return _coin.SoDB_writeunlock()

    @staticmethod
    def createRoute(srcFrom: "SoNode", eventout: "char const *", destTo: "SoNode", eventin: "char const *") -> "void":
        r"""createRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"""
        return _coin.SoDB_createRoute(srcFrom, eventout, destTo, eventin)

    @staticmethod
    def removeRoute(srcFrom: "SoNode", eventout: "char const *", destTo: "SoNode", eventin: "char const *") -> "void":
        r"""removeRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"""
        return _coin.SoDB_removeRoute(srcFrom, eventout, destTo, eventin)

    def __init__(self):
        r"""__init__(SoDB self) -> SoDB"""
        _coin.SoDB_swiginit(self, _coin.new_SoDB())
    __swig_destroy__ = _coin.delete_SoDB

# Register SoDB in _coin:
_coin.SoDB_swigregister(SoDB)

def SoDB_init() -> "void":
    r"""SoDB_init()"""
    return _coin.SoDB_init()

def SoDB_finish() -> "void":
    r"""SoDB_finish()"""
    return _coin.SoDB_finish()

def SoDB_cleanup() -> "void":
    r"""SoDB_cleanup()"""
    return _coin.SoDB_cleanup()

def SoDB_getVersion() -> "char const *":
    r"""SoDB_getVersion() -> char const *"""
    return _coin.SoDB_getVersion()

def SoDB_read(*args) -> "SbBool":
    r"""
    SoDB_read(SoInput input, SoPath *& path) -> SbBool
    SoDB_read(SoInput input, SoBase *& base) -> SbBool
    SoDB_read(SoInput input, SoNode *& rootnode) -> SbBool
    """
    return _coin.SoDB_read(*args)

def SoDB_readAll(input: "SoInput") -> "SoSeparator *":
    r"""SoDB_readAll(SoInput input) -> SoSeparator"""
    return _coin.SoDB_readAll(input)

def SoDB_readAllVRML(input: "SoInput") -> "SoVRMLGroup *":
    r"""SoDB_readAllVRML(SoInput input) -> SoVRMLGroup"""
    return _coin.SoDB_readAllVRML(input)

def SoDB_isValidHeader(teststring: "char const *") -> "SbBool":
    r"""SoDB_isValidHeader(char const * teststring) -> SbBool"""
    return _coin.SoDB_isValidHeader(teststring)

def SoDB_registerHeader(headerstring: "SbString", isbinary: "SbBool", ivversion: "float", precallback: "SoDBHeaderCB *", postcallback: "SoDBHeaderCB *", userdata: "void *"=None) -> "SbBool":
    r"""SoDB_registerHeader(SbString headerstring, SbBool isbinary, float ivversion, SoDBHeaderCB * precallback, SoDBHeaderCB * postcallback, void * userdata=None) -> SbBool"""
    return _coin.SoDB_registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata)

def SoDB_getHeaderData(headerstring: "SbString", isbinary: "SbBool &", ivversion: "float &", precallback: "SoDBHeaderCB *&", postcallback: "SoDBHeaderCB *&", userdata: "void *&", substringok: "SbBool"=0) -> "SbBool":
    r"""SoDB_getHeaderData(SbString headerstring, SbBool & isbinary, float & ivversion, SoDBHeaderCB *& precallback, SoDBHeaderCB *& postcallback, void *& userdata, SbBool substringok=0) -> SbBool"""
    return _coin.SoDB_getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok)

def SoDB_getNumHeaders() -> "int":
    r"""SoDB_getNumHeaders() -> int"""
    return _coin.SoDB_getNumHeaders()

def SoDB_getHeaderString(i: "int const") -> "SbString":
    r"""SoDB_getHeaderString(int const i) -> SbString"""
    return _coin.SoDB_getHeaderString(i)

def SoDB_createGlobalField(name: "SbName", type: "SoType") -> "SoField *":
    r"""SoDB_createGlobalField(SbName name, SoType type) -> SoField"""
    return _coin.SoDB_createGlobalField(name, type)

def SoDB_getGlobalField(name: "SbName") -> "SoField *":
    r"""SoDB_getGlobalField(SbName name) -> SoField"""
    return _coin.SoDB_getGlobalField(name)

def SoDB_renameGlobalField(srcFrom: "SbName", destTo: "SbName") -> "void":
    r"""SoDB_renameGlobalField(SbName srcFrom, SbName destTo)"""
    return _coin.SoDB_renameGlobalField(srcFrom, destTo)

def SoDB_setRealTimeInterval(interval: "SbTime") -> "void":
    r"""SoDB_setRealTimeInterval(SbTime interval)"""
    return _coin.SoDB_setRealTimeInterval(interval)

def SoDB_getRealTimeInterval() -> "SbTime const &":
    r"""SoDB_getRealTimeInterval() -> SbTime"""
    return _coin.SoDB_getRealTimeInterval()

def SoDB_enableRealTimeSensor(on: "SbBool") -> "void":
    r"""SoDB_enableRealTimeSensor(SbBool on)"""
    return _coin.SoDB_enableRealTimeSensor(on)

def SoDB_getSensorManager() -> "SoSensorManager *":
    r"""SoDB_getSensorManager() -> SoSensorManager"""
    return _coin.SoDB_getSensorManager()

def SoDB_setDelaySensorTimeout(t: "SbTime") -> "void":
    r"""SoDB_setDelaySensorTimeout(SbTime t)"""
    return _coin.SoDB_setDelaySensorTimeout(t)

def SoDB_getDelaySensorTimeout() -> "SbTime const &":
    r"""SoDB_getDelaySensorTimeout() -> SbTime"""
    return _coin.SoDB_getDelaySensorTimeout()

def SoDB_doSelect(nfds: "int", readfds: "void *", writefds: "void *", exceptfds: "void *", usertimeout: "timeval *") -> "int":
    r"""SoDB_doSelect(int nfds, void * readfds, void * writefds, void * exceptfds, timeval * usertimeout) -> int"""
    return _coin.SoDB_doSelect(nfds, readfds, writefds, exceptfds, usertimeout)

def SoDB_addConverter(srcFrom: "SoType", destTo: "SoType", converter: "SoType") -> "void":
    r"""SoDB_addConverter(SoType srcFrom, SoType destTo, SoType converter)"""
    return _coin.SoDB_addConverter(srcFrom, destTo, converter)

def SoDB_getConverter(srcFrom: "SoType", destTo: "SoType") -> "SoType":
    r"""SoDB_getConverter(SoType srcFrom, SoType destTo) -> SoType"""
    return _coin.SoDB_getConverter(srcFrom, destTo)

def SoDB_isInitialized() -> "SbBool":
    r"""SoDB_isInitialized() -> SbBool"""
    return _coin.SoDB_isInitialized()

def SoDB_startNotify() -> "void":
    r"""SoDB_startNotify()"""
    return _coin.SoDB_startNotify()

def SoDB_isNotifying() -> "SbBool":
    r"""SoDB_isNotifying() -> SbBool"""
    return _coin.SoDB_isNotifying()

def SoDB_endNotify() -> "void":
    r"""SoDB_endNotify()"""
    return _coin.SoDB_endNotify()

def SoDB_addProgressCallback(func: "SoDB::ProgressCallbackType *", userdata: "void *") -> "void":
    r"""SoDB_addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
    return _coin.SoDB_addProgressCallback(func, userdata)

def SoDB_removeProgressCallback(func: "SoDB::ProgressCallbackType *", userdata: "void *") -> "void":
    r"""SoDB_removeProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
    return _coin.SoDB_removeProgressCallback(func, userdata)

def SoDB_isMultiThread() -> "SbBool":
    r"""SoDB_isMultiThread() -> SbBool"""
    return _coin.SoDB_isMultiThread()

def SoDB_readlock() -> "void":
    r"""SoDB_readlock()"""
    return _coin.SoDB_readlock()

def SoDB_readunlock() -> "void":
    r"""SoDB_readunlock()"""
    return _coin.SoDB_readunlock()

def SoDB_writelock() -> "void":
    r"""SoDB_writelock()"""
    return _coin.SoDB_writelock()

def SoDB_writeunlock() -> "void":
    r"""SoDB_writeunlock()"""
    return _coin.SoDB_writeunlock()

def SoDB_createRoute(srcFrom: "SoNode", eventout: "char const *", destTo: "SoNode", eventin: "char const *") -> "void":
    r"""SoDB_createRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"""
    return _coin.SoDB_createRoute(srcFrom, eventout, destTo, eventin)

def SoDB_removeRoute(srcFrom: "SoNode", eventout: "char const *", destTo: "SoNode", eventin: "char const *") -> "void":
    r"""SoDB_removeRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"""
    return _coin.SoDB_removeRoute(srcFrom, eventout, destTo, eventin)

class SoInput(object):
    r"""Proxy of C++ SoInput class."""

    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):
        r"""
        __init__(SoInput self) -> SoInput
        __init__(SoInput self, SoInput dictIn) -> SoInput
        """
        _coin.SoInput_swiginit(self, _coin.new_SoInput(*args))

    def findProto(self, name: "SbName") -> "SoProto *":
        r"""findProto(SoInput self, SbName name) -> SoProto"""
        return _coin.SoInput_findProto(self, name)

    def addProto(self, proto: "SoProto") -> "void":
        r"""addProto(SoInput self, SoProto proto)"""
        return _coin.SoInput_addProto(self, proto)

    def pushProto(self, proto: "SoProto") -> "void":
        r"""pushProto(SoInput self, SoProto proto)"""
        return _coin.SoInput_pushProto(self, proto)

    def getCurrentProto(self) -> "SoProto *":
        r"""getCurrentProto(SoInput self) -> SoProto"""
        return _coin.SoInput_getCurrentProto(self)

    def popProto(self) -> "void":
        r"""popProto(SoInput self)"""
        return _coin.SoInput_popProto(self)

    def addRoute(self, fromnode: "SbName", fromfield: "SbName", tonode: "SbName", tofield: "SbName") -> "void":
        r"""addRoute(SoInput self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
        return _coin.SoInput_addRoute(self, fromnode, fromfield, tonode, tofield)

    def checkISReference(self, container: "SoFieldContainer", fieldname: "SbName", readok: "SbBool &") -> "SbBool":
        r"""checkISReference(SoInput self, SoFieldContainer container, SbName fieldname, SbBool & readok) -> SbBool"""
        return _coin.SoInput_checkISReference(self, container, fieldname, readok)
    __swig_destroy__ = _coin.delete_SoInput

    def setFilePointer(self, newFP: "FILE *") -> "void":
        r"""setFilePointer(SoInput self, FILE * newFP)"""
        return _coin.SoInput_setFilePointer(self, newFP)

    def openFile(self, fileName: "char const *", okIfNotFound: "SbBool"=0) -> "SbBool":
        r"""openFile(SoInput self, char const * fileName, SbBool okIfNotFound=0) -> SbBool"""
        return _coin.SoInput_openFile(self, fileName, okIfNotFound)

    def pushFile(self, fileName: "char const *") -> "SbBool":
        r"""pushFile(SoInput self, char const * fileName) -> SbBool"""
        return _coin.SoInput_pushFile(self, fileName)

    def closeFile(self) -> "void":
        r"""closeFile(SoInput self)"""
        return _coin.SoInput_closeFile(self)

    def isValidFile(self) -> "SbBool":
        r"""isValidFile(SoInput self) -> SbBool"""
        return _coin.SoInput_isValidFile(self)

    def isValidBuffer(self) -> "SbBool":
        r"""isValidBuffer(SoInput self) -> SbBool"""
        return _coin.SoInput_isValidBuffer(self)

    def getCurFile(self) -> "FILE *":
        r"""getCurFile(SoInput self) -> FILE *"""
        return _coin.SoInput_getCurFile(self)

    def getCurFileName(self) -> "char const *":
        r"""getCurFileName(SoInput self) -> char const *"""
        return _coin.SoInput_getCurFileName(self)

    def setBuffer(self, bufpointer: "void const *") -> "void":
        r"""setBuffer(SoInput self, void const * bufpointer)"""
        return _coin.SoInput_setBuffer(self, bufpointer)

    def setStringArray(self, strings: "char const *[]") -> "void":
        r"""setStringArray(SoInput self, char const *[] strings)"""
        return _coin.SoInput_setStringArray(self, strings)

    def getNumBytesRead(self) -> "size_t":
        r"""getNumBytesRead(SoInput self) -> size_t"""
        return _coin.SoInput_getNumBytesRead(self)

    def getHeader(self) -> "SbString":
        r"""getHeader(SoInput self) -> SbString"""
        return _coin.SoInput_getHeader(self)

    def getIVVersion(self) -> "float":
        r"""getIVVersion(SoInput self) -> float"""
        return _coin.SoInput_getIVVersion(self)

    def isBinary(self) -> "SbBool":
        r"""isBinary(SoInput self) -> SbBool"""
        return _coin.SoInput_isBinary(self)

    def get(self, c: "char &") -> "SbBool":
        r"""get(SoInput self, char & c) -> SbBool"""
        return _coin.SoInput_get(self, c)

    def getASCIIBuffer(self, c: "char &") -> "SbBool":
        r"""getASCIIBuffer(SoInput self, char & c) -> SbBool"""
        return _coin.SoInput_getASCIIBuffer(self, c)

    def getASCIIFile(self, c: "char &") -> "SbBool":
        r"""getASCIIFile(SoInput self, char & c) -> SbBool"""
        return _coin.SoInput_getASCIIFile(self, c)

    def readHex(self, l: "uint32_t &") -> "SbBool":
        r"""readHex(SoInput self, uint32_t & l) -> SbBool"""
        return _coin.SoInput_readHex(self, l)

    def read(self, *args) -> "SbBool":
        r"""
        read(SoInput self, char & c) -> SbBool
        read(SoInput self, char & c, SbBool skip) -> SbBool
        read(SoInput self, SbString s) -> SbBool
        read(SoInput self, SbName n, SbBool validIdent=0) -> SbBool
        read(SoInput self, int & i) -> SbBool
        read(SoInput self, unsigned int & i) -> SbBool
        read(SoInput self, short & s) -> SbBool
        read(SoInput self, unsigned short & s) -> SbBool
        read(SoInput self, float & f) -> SbBool
        read(SoInput self, double & d) -> SbBool
        """
        return _coin.SoInput_read(self, *args)

    def readByte(self, *args) -> "SbBool":
        r"""
        readByte(SoInput self, int8_t & b) -> SbBool
        readByte(SoInput self, uint8_t & b) -> SbBool
        """
        return _coin.SoInput_readByte(self, *args)

    def readBinaryArray(self, *args) -> "SbBool":
        r"""
        readBinaryArray(SoInput self, unsigned char * c, int length) -> SbBool
        readBinaryArray(SoInput self, int32_t * l, int length) -> SbBool
        readBinaryArray(SoInput self, float * f, int length) -> SbBool
        readBinaryArray(SoInput self, double * d, int length) -> SbBool
        """
        return _coin.SoInput_readBinaryArray(self, *args)

    def eof(self) -> "SbBool":
        r"""eof(SoInput self) -> SbBool"""
        return _coin.SoInput_eof(self)

    def isFileVRML1(self) -> "SbBool":
        r"""isFileVRML1(SoInput self) -> SbBool"""
        return _coin.SoInput_isFileVRML1(self)

    def isFileVRML2(self) -> "SbBool":
        r"""isFileVRML2(SoInput self) -> SbBool"""
        return _coin.SoInput_isFileVRML2(self)

    def resetFilePointer(self, fptr: "FILE *") -> "void":
        r"""resetFilePointer(SoInput self, FILE * fptr)"""
        return _coin.SoInput_resetFilePointer(self, fptr)

    def getLocationString(self, string: "SbString") -> "void":
        r"""getLocationString(SoInput self, SbString string)"""
        return _coin.SoInput_getLocationString(self, string)

    def putBack(self, *args) -> "void":
        r"""
        putBack(SoInput self, char const c)
        putBack(SoInput self, char const * str)
        """
        return _coin.SoInput_putBack(self, *args)

    def addReference(self, name: "SbName", base: "SoBase", addToGlobalDict: "SbBool"=1) -> "void":
        r"""addReference(SoInput self, SbName name, SoBase base, SbBool addToGlobalDict=1)"""
        return _coin.SoInput_addReference(self, name, base, addToGlobalDict)

    def removeReference(self, name: "SbName") -> "void":
        r"""removeReference(SoInput self, SbName name)"""
        return _coin.SoInput_removeReference(self, name)

    def findReference(self, name: "SbName") -> "SoBase *":
        r"""findReference(SoInput self, SbName name) -> SoBase"""
        return _coin.SoInput_findReference(self, name)

    @staticmethod
    def addDirectoryFirst(dirName: "char const *") -> "void":
        r"""addDirectoryFirst(char const * dirName)"""
        return _coin.SoInput_addDirectoryFirst(dirName)

    @staticmethod
    def addDirectoryLast(dirName: "char const *") -> "void":
        r"""addDirectoryLast(char const * dirName)"""
        return _coin.SoInput_addDirectoryLast(dirName)

    @staticmethod
    def addEnvDirectoriesFirst(*args) -> "void":
        r"""addEnvDirectoriesFirst(char const * envVarName, char const * separator=":\t ")"""
        return _coin.SoInput_addEnvDirectoriesFirst(*args)

    @staticmethod
    def addEnvDirectoriesLast(*args) -> "void":
        r"""addEnvDirectoriesLast(char const * envVarName, char const * separator=":\t ")"""
        return _coin.SoInput_addEnvDirectoriesLast(*args)

    @staticmethod
    def removeDirectory(dirName: "char const *") -> "void":
        r"""removeDirectory(char const * dirName)"""
        return _coin.SoInput_removeDirectory(dirName)

    @staticmethod
    def clearDirectories() -> "void":
        r"""clearDirectories()"""
        return _coin.SoInput_clearDirectories()

    @staticmethod
    def getDirectories() -> "SbStringList const &":
        r"""getDirectories() -> SbStringList"""
        return _coin.SoInput_getDirectories()

    @staticmethod
    def init() -> "void":
        r"""init()"""
        return _coin.SoInput_init()

    @staticmethod
    def getPathname(*args) -> "SbString":
        r"""
        getPathname(char const *const filename) -> SbString
        getPathname(SbString s) -> SbString
        """
        return _coin.SoInput_getPathname(*args)

    @staticmethod
    def getBasename(*args) -> "SbString":
        r"""
        getBasename(char const *const filename) -> SbString
        getBasename(SbString s) -> SbString
        """
        return _coin.SoInput_getBasename(*args)

    @staticmethod
    def searchForFile(basename: "SbString", directories: "SbStringList", subdirectories: "SbStringList") -> "SbString":
        r"""searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
        return _coin.SoInput_searchForFile(basename, directories, subdirectories)

# Register SoInput in _coin:
_coin.SoInput_swigregister(SoInput)

def SoInput_addDirectoryFirst(dirName: "char const *") -> "void":
    r"""SoInput_addDirectoryFirst(char const * dirName)"""
    return _coin.SoInput_addDirectoryFirst(dirName)

def SoInput_addDirectoryLast(dirName: "char const *") -> "void":
    r"""SoInput_addDirectoryLast(char const * dirName)"""
    return _coin.SoInput_addDirectoryLast(dirName)

def SoInput_addEnvDirectoriesFirst(*args) -> "void":
    r"""SoInput_addEnvDirectoriesFirst(char const * envVarName, char const * separator=":\t ")"""
    return _coin.SoInput_addEnvDirectoriesFirst(*args)

def SoInput_addEnvDirectoriesLast(*args) -> "void":
    r"""SoInput_addEnvDirectoriesLast(char const * envVarName, char const * separator=":\t ")"""
    return _coin.SoInput_addEnvDirectoriesLast(*args)

def SoInput_removeDirectory(dirName: "char const *") -> "void":
    r"""SoInput_removeDirectory(char const * dirName)"""
    return _coin.SoInput_removeDirectory(dirName)

def SoInput_clearDirectories() -> "void":
    r"""SoInput_clearDirectories()"""
    return _coin.SoInput_clearDirectories()

def SoInput_getDirectories() -> "SbStringList const &":
    r"""SoInput_getDirectories() -> SbStringList"""
    return _coin.SoInput_getDirectories()

def SoInput_init() -> "void":
    r"""SoInput_init()"""
    return _coin.SoInput_init()

def SoInput_getPathname(*args) -> "SbString":
    r"""
    SoInput_getPathname(char const *const filename) -> SbString
    SoInput_getPathname(SbString s) -> SbString
    """
    return _coin.SoInput_getPathname(*args)

def SoInput_getBasename(*args) -> "SbString":
    r"""
    SoInput_getBasename(char const *const filename) -> SbString
    SoInput_getBasename(SbString s) -> SbString
    """
    return _coin.SoInput_getBasename(*args)

def SoInput_searchForFile(basename: "SbString", directories: "SbStringList", subdirectories: "SbStringList") -> "SbString":
    r"""SoInput_searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
    return _coin.SoInput_searchForFile(basename, directories, subdirectories)

class SoOutput(object):
    r"""Proxy of C++ SoOutput class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    COUNT_REFS = _coin.SoOutput_COUNT_REFS
    
    WRITE = _coin.SoOutput_WRITE
    
    ADDRESSES = _coin.SoOutput_ADDRESSES
    
    REF_COUNTS = _coin.SoOutput_REF_COUNTS
    

    def __init__(self, *args):
        r"""
        __init__(SoOutput self) -> SoOutput
        __init__(SoOutput self, SoOutput dictOut) -> SoOutput
        """
        _coin.SoOutput_swiginit(self, _coin.new_SoOutput(*args))
    __swig_destroy__ = _coin.delete_SoOutput

    def setFilePointer(self, newFP: "FILE *") -> "void":
        r"""setFilePointer(SoOutput self, FILE * newFP)"""
        return _coin.SoOutput_setFilePointer(self, newFP)

    def getFilePointer(self) -> "FILE *":
        r"""getFilePointer(SoOutput self) -> FILE *"""
        return _coin.SoOutput_getFilePointer(self)

    def openFile(self, fileName: "char const *const") -> "SbBool":
        r"""openFile(SoOutput self, char const *const fileName) -> SbBool"""
        return _coin.SoOutput_openFile(self, fileName)

    def closeFile(self) -> "void":
        r"""closeFile(SoOutput self)"""
        return _coin.SoOutput_closeFile(self)

    def setCompression(self, compmethod: "SbName", level: "float const"=0.5) -> "SbBool":
        r"""setCompression(SoOutput self, SbName compmethod, float const level=0.5) -> SbBool"""
        return _coin.SoOutput_setCompression(self, compmethod, level)

    @staticmethod
    def getAvailableCompressionMethods(num: "unsigned int &") -> "SbName const *":
        r"""getAvailableCompressionMethods(unsigned int & num) -> SbName"""
        return _coin.SoOutput_getAvailableCompressionMethods(num)

    def setBuffer(self, bufPointer: "void *", initSize: "size_t", reallocFunc: "SoOutputReallocCB *", offset: "int32_t"=0) -> "void":
        r"""setBuffer(SoOutput self, void * bufPointer, size_t initSize, SoOutputReallocCB * reallocFunc, int32_t offset=0)"""
        return _coin.SoOutput_setBuffer(self, bufPointer, initSize, reallocFunc, offset)

    def getBuffer(self, bufPointer: "void *&", nBytes: "size_t &") -> "SbBool":
        r"""getBuffer(SoOutput self, void *& bufPointer, size_t & nBytes) -> SbBool"""
        return _coin.SoOutput_getBuffer(self, bufPointer, nBytes)

    def getBufferSize(self) -> "size_t":
        r"""getBufferSize(SoOutput self) -> size_t"""
        return _coin.SoOutput_getBufferSize(self)

    def resetBuffer(self) -> "void":
        r"""resetBuffer(SoOutput self)"""
        return _coin.SoOutput_resetBuffer(self)

    def setBinary(self, flag: "SbBool const") -> "void":
        r"""setBinary(SoOutput self, SbBool const flag)"""
        return _coin.SoOutput_setBinary(self, flag)

    def isBinary(self) -> "SbBool":
        r"""isBinary(SoOutput self) -> SbBool"""
        return _coin.SoOutput_isBinary(self)

    def setHeaderString(self, str: "SbString") -> "void":
        r"""setHeaderString(SoOutput self, SbString str)"""
        return _coin.SoOutput_setHeaderString(self, str)

    def resetHeaderString(self) -> "void":
        r"""resetHeaderString(SoOutput self)"""
        return _coin.SoOutput_resetHeaderString(self)

    def setFloatPrecision(self, precision: "int const") -> "void":
        r"""setFloatPrecision(SoOutput self, int const precision)"""
        return _coin.SoOutput_setFloatPrecision(self, precision)

    def setStage(self, stage: "SoOutput::Stage") -> "void":
        r"""setStage(SoOutput self, SoOutput::Stage stage)"""
        return _coin.SoOutput_setStage(self, stage)

    def getStage(self) -> "SoOutput::Stage":
        r"""getStage(SoOutput self) -> SoOutput::Stage"""
        return _coin.SoOutput_getStage(self)

    def incrementIndent(self, levels: "int const"=1) -> "void":
        r"""incrementIndent(SoOutput self, int const levels=1)"""
        return _coin.SoOutput_incrementIndent(self, levels)

    def decrementIndent(self, levels: "int const"=1) -> "void":
        r"""decrementIndent(SoOutput self, int const levels=1)"""
        return _coin.SoOutput_decrementIndent(self, levels)

    def write(self, *args) -> "void":
        r"""
        write(SoOutput self, char const c)
        write(SoOutput self, char const * s)
        write(SoOutput self, SbString s)
        write(SoOutput self, SbName n)
        write(SoOutput self, int const i)
        write(SoOutput self, unsigned int const i)
        write(SoOutput self, short const s)
        write(SoOutput self, unsigned short const s)
        write(SoOutput self, float const f)
        write(SoOutput self, double const d)
        """
        return _coin.SoOutput_write(self, *args)

    def writeBinaryArray(self, *args) -> "void":
        r"""
        writeBinaryArray(SoOutput self, unsigned char const * c, int const length)
        writeBinaryArray(SoOutput self, int32_t const *const l, int const length)
        writeBinaryArray(SoOutput self, float const *const f, int const length)
        writeBinaryArray(SoOutput self, double const *const d, int const length)
        """
        return _coin.SoOutput_writeBinaryArray(self, *args)

    def indent(self) -> "void":
        r"""indent(SoOutput self)"""
        return _coin.SoOutput_indent(self)

    def reset(self) -> "void":
        r"""reset(SoOutput self)"""
        return _coin.SoOutput_reset(self)

    def setCompact(self, flag: "SbBool") -> "void":
        r"""setCompact(SoOutput self, SbBool flag)"""
        return _coin.SoOutput_setCompact(self, flag)

    def isCompact(self) -> "SbBool":
        r"""isCompact(SoOutput self) -> SbBool"""
        return _coin.SoOutput_isCompact(self)

    def setAnnotation(self, bits: "uint32_t") -> "void":
        r"""setAnnotation(SoOutput self, uint32_t bits)"""
        return _coin.SoOutput_setAnnotation(self, bits)

    def getAnnotation(self) -> "uint32_t":
        r"""getAnnotation(SoOutput self) -> uint32_t"""
        return _coin.SoOutput_getAnnotation(self)

    @staticmethod
    def getDefaultASCIIHeader() -> "SbString":
        r"""getDefaultASCIIHeader() -> SbString"""
        return _coin.SoOutput_getDefaultASCIIHeader()

    @staticmethod
    def getDefaultBinaryHeader() -> "SbString":
        r"""getDefaultBinaryHeader() -> SbString"""
        return _coin.SoOutput_getDefaultBinaryHeader()

    def addReference(self, base: "SoBase") -> "int":
        r"""addReference(SoOutput self, SoBase base) -> int"""
        return _coin.SoOutput_addReference(self, base)

    def findReference(self, base: "SoBase") -> "int":
        r"""findReference(SoOutput self, SoBase base) -> int"""
        return _coin.SoOutput_findReference(self, base)

    def setReference(self, base: "SoBase", refid: "int") -> "void":
        r"""setReference(SoOutput self, SoBase base, int refid)"""
        return _coin.SoOutput_setReference(self, base, refid)

    def addDEFNode(self, name: "SbName") -> "void":
        r"""addDEFNode(SoOutput self, SbName name)"""
        return _coin.SoOutput_addDEFNode(self, name)

    def lookupDEFNode(self, name: "SbName") -> "SbBool":
        r"""lookupDEFNode(SoOutput self, SbName name) -> SbBool"""
        return _coin.SoOutput_lookupDEFNode(self, name)

    def removeDEFNode(self, name: "SbName") -> "void":
        r"""removeDEFNode(SoOutput self, SbName name)"""
        return _coin.SoOutput_removeDEFNode(self, name)

    def pushProto(self, proto: "SoProto") -> "void":
        r"""pushProto(SoOutput self, SoProto proto)"""
        return _coin.SoOutput_pushProto(self, proto)

    def getCurrentProto(self) -> "SoProto *":
        r"""getCurrentProto(SoOutput self) -> SoProto"""
        return _coin.SoOutput_getCurrentProto(self)

    def popProto(self) -> "void":
        r"""popProto(SoOutput self)"""
        return _coin.SoOutput_popProto(self)

    def addRoute(self, srcFrom: "SoFieldContainer", fromfield: "SbName", destTo: "SoFieldContainer", tofield: "SbName") -> "void":
        r"""addRoute(SoOutput self, SoFieldContainer srcFrom, SbName fromfield, SoFieldContainer destTo, SbName tofield)"""
        return _coin.SoOutput_addRoute(self, srcFrom, fromfield, destTo, tofield)

    def resolveRoutes(self) -> "void":
        r"""resolveRoutes(SoOutput self)"""
        return _coin.SoOutput_resolveRoutes(self)

# Register SoOutput in _coin:
_coin.SoOutput_swigregister(SoOutput)

def SoOutput_getAvailableCompressionMethods(num: "unsigned int &") -> "SbName const *":
    r"""SoOutput_getAvailableCompressionMethods(unsigned int & num) -> SbName"""
    return _coin.SoOutput_getAvailableCompressionMethods(num)

def SoOutput_getDefaultASCIIHeader() -> "SbString":
    r"""SoOutput_getDefaultASCIIHeader() -> SbString"""
    return _coin.SoOutput_getDefaultASCIIHeader()

def SoOutput_getDefaultBinaryHeader() -> "SbString":
    r"""SoOutput_getDefaultBinaryHeader() -> SbString"""
    return _coin.SoOutput_getDefaultBinaryHeader()

class SoSFEnum(SoSField):
    r"""Proxy of C++ SoSFEnum class."""

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

    def __init__(self):
        r"""__init__(SoSFEnum self) -> SoSFEnum"""
        _coin.SoSFEnum_swiginit(self, _coin.new_SoSFEnum())
    __swig_destroy__ = _coin.delete_SoSFEnum

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFEnum_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFEnum_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFEnum self) -> SoType"""
        return _coin.SoSFEnum_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFEnum self, SoField field)"""
        return _coin.SoSFEnum_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFEnum self, SoField field) -> SbBool"""
        return _coin.SoSFEnum_isSame(self, field)

    def getValue(self) -> "int":
        r"""getValue(SoSFEnum self) -> int"""
        return _coin.SoSFEnum_getValue(self)

    def __eq__(self, field: "SoSFEnum") -> "int":
        r"""__eq__(SoSFEnum self, SoSFEnum field) -> int"""
        return _coin.SoSFEnum___eq__(self, field)

    def __ne__(self, field: "SoSFEnum") -> "int":
        r"""__ne__(SoSFEnum self, SoSFEnum field) -> int"""
        return _coin.SoSFEnum___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFEnum_initClass()

    def setEnums(self, num: "int const", vals: "int const *", names: "SbName") -> "void":
        r"""setEnums(SoSFEnum self, int const num, int const * vals, SbName names)"""
        return _coin.SoSFEnum_setEnums(self, num, vals, names)

    def getNumEnums(self) -> "int":
        r"""getNumEnums(SoSFEnum self) -> int"""
        return _coin.SoSFEnum_getNumEnums(self)

    def getEnum(self, idx: "int const", name: "SbName") -> "int":
        r"""getEnum(SoSFEnum self, int const idx, SbName name) -> int"""
        return _coin.SoSFEnum_getEnum(self, idx, name)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFEnum self, int newvalue)
        setValue(SoSFEnum self, SbName name)
        setValue(SoSFEnum self, SoSFEnum other)
        """
        return _coin.SoSFEnum_setValue(self, *args)

# Register SoSFEnum in _coin:
_coin.SoSFEnum_swigregister(SoSFEnum)

def SoSFEnum_createInstance() -> "void *":
    r"""SoSFEnum_createInstance() -> void *"""
    return _coin.SoSFEnum_createInstance()

def SoSFEnum_getClassTypeId() -> "SoType":
    r"""SoSFEnum_getClassTypeId() -> SoType"""
    return _coin.SoSFEnum_getClassTypeId()

def SoSFEnum_initClass() -> "void":
    r"""SoSFEnum_initClass()"""
    return _coin.SoSFEnum_initClass()

class SoSFFloat(SoSField):
    r"""Proxy of C++ SoSFFloat class."""

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

    def __init__(self):
        r"""__init__(SoSFFloat self) -> SoSFFloat"""
        _coin.SoSFFloat_swiginit(self, _coin.new_SoSFFloat())
    __swig_destroy__ = _coin.delete_SoSFFloat

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFFloat_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFFloat_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFFloat self) -> SoType"""
        return _coin.SoSFFloat_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFFloat self, SoField field)"""
        return _coin.SoSFFloat_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFFloat self, SoField field) -> SbBool"""
        return _coin.SoSFFloat_isSame(self, field)

    def getValue(self) -> "float":
        r"""getValue(SoSFFloat self) -> float"""
        return _coin.SoSFFloat_getValue(self)

    def __eq__(self, field: "SoSFFloat") -> "int":
        r"""__eq__(SoSFFloat self, SoSFFloat field) -> int"""
        return _coin.SoSFFloat___eq__(self, field)

    def __ne__(self, field: "SoSFFloat") -> "int":
        r"""__ne__(SoSFFloat self, SoSFFloat field) -> int"""
        return _coin.SoSFFloat___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFFloat_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFFloat self, float newvalue)
        setValue(SoSFFloat self, SoSFFloat other)
        """
        return _coin.SoSFFloat_setValue(self, *args)

# Register SoSFFloat in _coin:
_coin.SoSFFloat_swigregister(SoSFFloat)

def SoSFFloat_createInstance() -> "void *":
    r"""SoSFFloat_createInstance() -> void *"""
    return _coin.SoSFFloat_createInstance()

def SoSFFloat_getClassTypeId() -> "SoType":
    r"""SoSFFloat_getClassTypeId() -> SoType"""
    return _coin.SoSFFloat_getClassTypeId()

def SoSFFloat_initClass() -> "void":
    r"""SoSFFloat_initClass()"""
    return _coin.SoSFFloat_initClass()

class SoComplexityTypeElement(SoInt32Element):
    r"""Proxy of C++ SoComplexityTypeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComplexityTypeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoComplexityTypeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComplexityTypeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComplexityTypeElement_initClass()
    OBJECT_SPACE = _coin.SoComplexityTypeElement_OBJECT_SPACE
    
    SCREEN_SPACE = _coin.SoComplexityTypeElement_SCREEN_SPACE
    
    BOUNDING_BOX = _coin.SoComplexityTypeElement_BOUNDING_BOX
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoComplexityTypeElement self, SoState state)"""
        return _coin.SoComplexityTypeElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoComplexityTypeElement::Type const type)
        set(SoState state, SoComplexityTypeElement::Type const type)
        """
        return _coin.SoComplexityTypeElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoComplexityTypeElement::Type":
        r"""get(SoState state) -> SoComplexityTypeElement::Type"""
        return _coin.SoComplexityTypeElement_get(state)

    @staticmethod
    def getDefault() -> "SoComplexityTypeElement::Type":
        r"""getDefault() -> SoComplexityTypeElement::Type"""
        return _coin.SoComplexityTypeElement_getDefault()

# Register SoComplexityTypeElement in _coin:
_coin.SoComplexityTypeElement_swigregister(SoComplexityTypeElement)

def SoComplexityTypeElement_getClassTypeId() -> "SoType":
    r"""SoComplexityTypeElement_getClassTypeId() -> SoType"""
    return _coin.SoComplexityTypeElement_getClassTypeId()

def SoComplexityTypeElement_getClassStackIndex() -> "int":
    r"""SoComplexityTypeElement_getClassStackIndex() -> int"""
    return _coin.SoComplexityTypeElement_getClassStackIndex()

def SoComplexityTypeElement_createInstance() -> "void *":
    r"""SoComplexityTypeElement_createInstance() -> void *"""
    return _coin.SoComplexityTypeElement_createInstance()

def SoComplexityTypeElement_initClass() -> "void":
    r"""SoComplexityTypeElement_initClass()"""
    return _coin.SoComplexityTypeElement_initClass()

def SoComplexityTypeElement_set(*args) -> "void":
    r"""
    SoComplexityTypeElement_set(SoState state, SoNode node, SoComplexityTypeElement::Type const type)
    SoComplexityTypeElement_set(SoState state, SoComplexityTypeElement::Type const type)
    """
    return _coin.SoComplexityTypeElement_set(*args)

def SoComplexityTypeElement_get(state: "SoState") -> "SoComplexityTypeElement::Type":
    r"""SoComplexityTypeElement_get(SoState state) -> SoComplexityTypeElement::Type"""
    return _coin.SoComplexityTypeElement_get(state)

def SoComplexityTypeElement_getDefault() -> "SoComplexityTypeElement::Type":
    r"""SoComplexityTypeElement_getDefault() -> SoComplexityTypeElement::Type"""
    return _coin.SoComplexityTypeElement_getDefault()

class SoComplexity(SoNode):
    r"""Proxy of C++ SoComplexity class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComplexity_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComplexity self) -> SoType"""
        return _coin.SoComplexity_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComplexity_initClass()

    def __init__(self):
        r"""__init__(SoComplexity self) -> SoComplexity"""
        _coin.SoComplexity_swiginit(self, _coin.new_SoComplexity())
    OBJECT_SPACE = _coin.SoComplexity_OBJECT_SPACE
    
    SCREEN_SPACE = _coin.SoComplexity_SCREEN_SPACE
    
    BOUNDING_BOX = _coin.SoComplexity_BOUNDING_BOX
    
    type = property(_coin.SoComplexity_type_get, _coin.SoComplexity_type_set, doc=r"""type : SoSFEnum""")
    value = property(_coin.SoComplexity_value_get, _coin.SoComplexity_value_set, doc=r"""value : SoSFFloat""")
    textureQuality = property(_coin.SoComplexity_textureQuality_get, _coin.SoComplexity_textureQuality_set, doc=r"""textureQuality : SoSFFloat""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoComplexity self, SoAction action)"""
        return _coin.SoComplexity_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoComplexity self, SoCallbackAction action)"""
        return _coin.SoComplexity_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoComplexity self, SoGetBoundingBoxAction action)"""
        return _coin.SoComplexity_getBoundingBox(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoComplexity self, SoGLRenderAction action)"""
        return _coin.SoComplexity_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoComplexity self, SoPickAction action)"""
        return _coin.SoComplexity_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoComplexity self, SoGetPrimitiveCountAction action)"""
        return _coin.SoComplexity_getPrimitiveCount(self, action)

# Register SoComplexity in _coin:
_coin.SoComplexity_swigregister(SoComplexity)

def SoComplexity_getClassTypeId() -> "SoType":
    r"""SoComplexity_getClassTypeId() -> SoType"""
    return _coin.SoComplexity_getClassTypeId()

def SoComplexity_initClass() -> "void":
    r"""SoComplexity_initClass()"""
    return _coin.SoComplexity_initClass()

class SoDrawStyleElement(SoInt32Element):
    r"""Proxy of C++ SoDrawStyleElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDrawStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoDrawStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDrawStyleElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDrawStyleElement_initClass()
    FILLED = _coin.SoDrawStyleElement_FILLED
    
    LINES = _coin.SoDrawStyleElement_LINES
    
    POINTS = _coin.SoDrawStyleElement_POINTS
    
    INVISIBLE = _coin.SoDrawStyleElement_INVISIBLE
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoDrawStyleElement self, SoState state)"""
        return _coin.SoDrawStyleElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoDrawStyleElement::Style const style)
        set(SoState state, SoDrawStyleElement::Style const style)
        """
        return _coin.SoDrawStyleElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoDrawStyleElement::Style":
        r"""get(SoState state) -> SoDrawStyleElement::Style"""
        return _coin.SoDrawStyleElement_get(state)

    @staticmethod
    def getDefault() -> "SoDrawStyleElement::Style":
        r"""getDefault() -> SoDrawStyleElement::Style"""
        return _coin.SoDrawStyleElement_getDefault()

# Register SoDrawStyleElement in _coin:
_coin.SoDrawStyleElement_swigregister(SoDrawStyleElement)

def SoDrawStyleElement_getClassTypeId() -> "SoType":
    r"""SoDrawStyleElement_getClassTypeId() -> SoType"""
    return _coin.SoDrawStyleElement_getClassTypeId()

def SoDrawStyleElement_getClassStackIndex() -> "int":
    r"""SoDrawStyleElement_getClassStackIndex() -> int"""
    return _coin.SoDrawStyleElement_getClassStackIndex()

def SoDrawStyleElement_createInstance() -> "void *":
    r"""SoDrawStyleElement_createInstance() -> void *"""
    return _coin.SoDrawStyleElement_createInstance()

def SoDrawStyleElement_initClass() -> "void":
    r"""SoDrawStyleElement_initClass()"""
    return _coin.SoDrawStyleElement_initClass()

def SoDrawStyleElement_set(*args) -> "void":
    r"""
    SoDrawStyleElement_set(SoState state, SoNode node, SoDrawStyleElement::Style const style)
    SoDrawStyleElement_set(SoState state, SoDrawStyleElement::Style const style)
    """
    return _coin.SoDrawStyleElement_set(*args)

def SoDrawStyleElement_get(state: "SoState") -> "SoDrawStyleElement::Style":
    r"""SoDrawStyleElement_get(SoState state) -> SoDrawStyleElement::Style"""
    return _coin.SoDrawStyleElement_get(state)

def SoDrawStyleElement_getDefault() -> "SoDrawStyleElement::Style":
    r"""SoDrawStyleElement_getDefault() -> SoDrawStyleElement::Style"""
    return _coin.SoDrawStyleElement_getDefault()

class SoSFUShort(SoSField):
    r"""Proxy of C++ SoSFUShort class."""

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

    def __init__(self):
        r"""__init__(SoSFUShort self) -> SoSFUShort"""
        _coin.SoSFUShort_swiginit(self, _coin.new_SoSFUShort())
    __swig_destroy__ = _coin.delete_SoSFUShort

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFUShort_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFUShort_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFUShort self) -> SoType"""
        return _coin.SoSFUShort_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFUShort self, SoField field)"""
        return _coin.SoSFUShort_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFUShort self, SoField field) -> SbBool"""
        return _coin.SoSFUShort_isSame(self, field)

    def getValue(self) -> "unsigned short":
        r"""getValue(SoSFUShort self) -> unsigned short"""
        return _coin.SoSFUShort_getValue(self)

    def __eq__(self, field: "SoSFUShort") -> "int":
        r"""__eq__(SoSFUShort self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___eq__(self, field)

    def __ne__(self, field: "SoSFUShort") -> "int":
        r"""__ne__(SoSFUShort self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFUShort_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFUShort self, unsigned short newvalue)
        setValue(SoSFUShort self, SoSFUShort other)
        """
        return _coin.SoSFUShort_setValue(self, *args)

# Register SoSFUShort in _coin:
_coin.SoSFUShort_swigregister(SoSFUShort)

def SoSFUShort_createInstance() -> "void *":
    r"""SoSFUShort_createInstance() -> void *"""
    return _coin.SoSFUShort_createInstance()

def SoSFUShort_getClassTypeId() -> "SoType":
    r"""SoSFUShort_getClassTypeId() -> SoType"""
    return _coin.SoSFUShort_getClassTypeId()

def SoSFUShort_initClass() -> "void":
    r"""SoSFUShort_initClass()"""
    return _coin.SoSFUShort_initClass()

class SoSFInt32(SoSField):
    r"""Proxy of C++ SoSFInt32 class."""

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

    def __init__(self):
        r"""__init__(SoSFInt32 self) -> SoSFInt32"""
        _coin.SoSFInt32_swiginit(self, _coin.new_SoSFInt32())
    __swig_destroy__ = _coin.delete_SoSFInt32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFInt32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFInt32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFInt32 self) -> SoType"""
        return _coin.SoSFInt32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFInt32 self, SoField field)"""
        return _coin.SoSFInt32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFInt32 self, SoField field) -> SbBool"""
        return _coin.SoSFInt32_isSame(self, field)

    def getValue(self) -> "int32_t":
        r"""getValue(SoSFInt32 self) -> int32_t"""
        return _coin.SoSFInt32_getValue(self)

    def __eq__(self, field: "SoSFInt32") -> "int":
        r"""__eq__(SoSFInt32 self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___eq__(self, field)

    def __ne__(self, field: "SoSFInt32") -> "int":
        r"""__ne__(SoSFInt32 self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFInt32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFInt32 self, int32_t newvalue)
        setValue(SoSFInt32 self, SoSFInt32 other)
        """
        return _coin.SoSFInt32_setValue(self, *args)

# Register SoSFInt32 in _coin:
_coin.SoSFInt32_swigregister(SoSFInt32)

def SoSFInt32_createInstance() -> "void *":
    r"""SoSFInt32_createInstance() -> void *"""
    return _coin.SoSFInt32_createInstance()

def SoSFInt32_getClassTypeId() -> "SoType":
    r"""SoSFInt32_getClassTypeId() -> SoType"""
    return _coin.SoSFInt32_getClassTypeId()

def SoSFInt32_initClass() -> "void":
    r"""SoSFInt32_initClass()"""
    return _coin.SoSFInt32_initClass()

class SoDrawStyle(SoNode):
    r"""Proxy of C++ SoDrawStyle class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDrawStyle_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDrawStyle self) -> SoType"""
        return _coin.SoDrawStyle_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDrawStyle_initClass()

    def __init__(self):
        r"""__init__(SoDrawStyle self) -> SoDrawStyle"""
        _coin.SoDrawStyle_swiginit(self, _coin.new_SoDrawStyle())
    FILLED = _coin.SoDrawStyle_FILLED
    
    LINES = _coin.SoDrawStyle_LINES
    
    POINTS = _coin.SoDrawStyle_POINTS
    
    INVISIBLE = _coin.SoDrawStyle_INVISIBLE
    
    style = property(_coin.SoDrawStyle_style_get, _coin.SoDrawStyle_style_set, doc=r"""style : SoSFEnum""")
    pointSize = property(_coin.SoDrawStyle_pointSize_get, _coin.SoDrawStyle_pointSize_set, doc=r"""pointSize : SoSFFloat""")
    lineWidth = property(_coin.SoDrawStyle_lineWidth_get, _coin.SoDrawStyle_lineWidth_set, doc=r"""lineWidth : SoSFFloat""")
    linePattern = property(_coin.SoDrawStyle_linePattern_get, _coin.SoDrawStyle_linePattern_set, doc=r"""linePattern : SoSFUShort""")
    linePatternScaleFactor = property(_coin.SoDrawStyle_linePatternScaleFactor_get, _coin.SoDrawStyle_linePatternScaleFactor_set, doc=r"""linePatternScaleFactor : SoSFInt32""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoDrawStyle self, SoAction action)"""
        return _coin.SoDrawStyle_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoDrawStyle self, SoGLRenderAction action)"""
        return _coin.SoDrawStyle_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoDrawStyle self, SoCallbackAction action)"""
        return _coin.SoDrawStyle_callback(self, action)

# Register SoDrawStyle in _coin:
_coin.SoDrawStyle_swigregister(SoDrawStyle)

def SoDrawStyle_getClassTypeId() -> "SoType":
    r"""SoDrawStyle_getClassTypeId() -> SoType"""
    return _coin.SoDrawStyle_getClassTypeId()

def SoDrawStyle_initClass() -> "void":
    r"""SoDrawStyle_initClass()"""
    return _coin.SoDrawStyle_initClass()

class SbVec3f(object):
    r"""Proxy of C++ SbVec3f class."""

    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):
        r"""
        __init__(SbVec3f self) -> SbVec3f
        __init__(SbVec3f self, float const [3] v) -> SbVec3f
        __init__(SbVec3f self, float x, float y, float z) -> SbVec3f
        __init__(SbVec3f self, SbVec3d v) -> SbVec3f
        __init__(SbVec3f self, SbVec3b v) -> SbVec3f
        __init__(SbVec3f self, SbVec3s v) -> SbVec3f
        __init__(SbVec3f self, SbVec3i32 v) -> SbVec3f
        __init__(SbVec3f self, SbPlane p0, SbPlane p1, SbPlane p2) -> SbVec3f
        """
        _coin.SbVec3f_swiginit(self, _coin.new_SbVec3f(*args))

    def setValue(self, *args) -> "SbVec3f &":
        r"""
        setValue(SbVec3f self, float const [3] v) -> SbVec3f
        setValue(SbVec3f self, float x, float y, float z) -> SbVec3f
        setValue(SbVec3f self, SbVec3f barycentric, SbVec3f v0, SbVec3f v1, SbVec3f v2) -> SbVec3f
        setValue(SbVec3f self, SbVec3d v) -> SbVec3f
        setValue(SbVec3f self, SbVec3b v) -> SbVec3f
        setValue(SbVec3f self, SbVec3s v) -> SbVec3f
        setValue(SbVec3f self, SbVec3i32 v) -> SbVec3f
        """
        return _coin.SbVec3f_setValue(self, *args)

    def getValue(self) -> "float const *":
        r"""getValue(SbVec3f self) -> float const *"""
        return _coin.SbVec3f_getValue(self)

    def equals(self, v: "SbVec3f", tolerance: "float") -> "SbBool":
        r"""equals(SbVec3f self, SbVec3f v, float tolerance) -> SbBool"""
        return _coin.SbVec3f_equals(self, v, tolerance)

    def cross(self, v: "SbVec3f") -> "SbVec3f":
        r"""cross(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f_cross(self, v)

    def dot(self, v: "SbVec3f") -> "float":
        r"""dot(SbVec3f self, SbVec3f v) -> float"""
        return _coin.SbVec3f_dot(self, v)

    def getClosestAxis(self) -> "SbVec3f":
        r"""getClosestAxis(SbVec3f self) -> SbVec3f"""
        return _coin.SbVec3f_getClosestAxis(self)

    def length(self) -> "float":
        r"""length(SbVec3f self) -> float"""
        return _coin.SbVec3f_length(self)

    def sqrLength(self) -> "float":
        r"""sqrLength(SbVec3f self) -> float"""
        return _coin.SbVec3f_sqrLength(self)

    def normalize(self) -> "float":
        r"""normalize(SbVec3f self) -> float"""
        return _coin.SbVec3f_normalize(self)

    def negate(self) -> "void":
        r"""negate(SbVec3f self)"""
        return _coin.SbVec3f_negate(self)

    def __imul__(self, d: "float") -> "SbVec3f &":
        r"""__imul__(SbVec3f self, float d) -> SbVec3f"""
        return _coin.SbVec3f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec3f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec3f") -> "SbVec3f &":
        r"""__iadd__(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___iadd__(self, v)

    def __isub__(self, v: "SbVec3f") -> "SbVec3f &":
        r"""__isub__(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___isub__(self, v)

    def __neg__(self) -> "SbVec3f":
        r"""__neg__(SbVec3f self) -> SbVec3f"""
        return _coin.SbVec3f___neg__(self)

    def toString(self) -> "SbString":
        r"""toString(SbVec3f self) -> SbString"""
        return _coin.SbVec3f_toString(self)

    def fromString(self, str: "SbString") -> "SbBool":
        r"""fromString(SbVec3f self, SbString str) -> SbBool"""
        return _coin.SbVec3f_fromString(self, str)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec3f self, FILE * fp)"""
        return _coin.SbVec3f_output(self, fp)

    def __add__(self, u: "SbVec3f") -> "SbVec3f":
        r"""__add__(SbVec3f self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___add__(self, u)

    def __sub__(self, u: "SbVec3f") -> "SbVec3f":
        r"""__sub__(SbVec3f self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___sub__(self, u)

    def __mul__(self, *args) -> "SbVec3f":
        r"""
        __mul__(SbVec3f self, float const d) -> SbVec3f
        __mul__(SbVec3f self, SbMatrix m) -> SbVec3f
        """
        return _coin.SbVec3f___mul__(self, *args)

    def __rmul__(self, d: "float const") -> "SbVec3f":
        r"""__rmul__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___rmul__(self, d)

    def __div__(self, d: "float const") -> "SbVec3f":
        r"""__div__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___div__(self, d)

    def __truediv__(self, d: "float const") -> "SbVec3f":
        r"""__truediv__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___truediv__(self, d)

    def __eq__(self, u: "SbVec3f") -> "int":
        r"""__eq__(SbVec3f self, SbVec3f u) -> int"""
        return _coin.SbVec3f___eq__(self, u)

    def __nq__(self, u: "SbVec3f") -> "int":
        r"""__nq__(SbVec3f self, SbVec3f u) -> int"""
        return _coin.SbVec3f___nq__(self, u)

    def __getitem__(self, i: "int") -> "float":
        r"""__getitem__(SbVec3f self, int i) -> float"""
        return _coin.SbVec3f___getitem__(self, i)

    def __setitem__(self, i: "int", value: "float") -> "void":
        r"""__setitem__(SbVec3f self, int i, float value)"""
        return _coin.SbVec3f___setitem__(self, i, value)

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

    def __len__(self):
          return 3

    __swig_destroy__ = _coin.delete_SbVec3f

# Register SbVec3f in _coin:
_coin.SbVec3f_swigregister(SbVec3f)

class SbColor(SbVec3f):
    r"""Proxy of C++ SbColor class."""

    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):
        r"""
        __init__(SbColor self) -> SbColor
        __init__(SbColor self, SbVec3f v) -> SbColor
        __init__(SbColor self, float const *const rgb) -> SbColor
        __init__(SbColor self, float const r, float const g, float const b) -> SbColor
        """
        _coin.SbColor_swiginit(self, _coin.new_SbColor(*args))

    def setHSVValue(self, *args) -> "SbColor &":
        r"""
        setHSVValue(SbColor self, float h, float s, float v) -> SbColor
        setHSVValue(SbColor self, float const [3] hsv) -> SbColor
        """
        return _coin.SbColor_setHSVValue(self, *args)

    def getHSVValue(self) -> "void":
        r"""getHSVValue(SbColor self)"""
        return _coin.SbColor_getHSVValue(self)

    def setPackedValue(self, rgba: "uint32_t const", transparency: "float &") -> "SbColor &":
        r"""setPackedValue(SbColor self, uint32_t const rgba, float & transparency) -> SbColor"""
        return _coin.SbColor_setPackedValue(self, rgba, transparency)

    def getPackedValue(self, transparency: "float const"=0.0) -> "uint32_t":
        r"""getPackedValue(SbColor self, float const transparency=0.0) -> uint32_t"""
        return _coin.SbColor_getPackedValue(self, transparency)

    def __add__(self, u: "SbColor") -> "SbColor":
        r"""__add__(SbColor self, SbColor u) -> SbColor"""
        return _coin.SbColor___add__(self, u)

    def __sub__(self, u: "SbColor") -> "SbColor":
        r"""__sub__(SbColor self, SbColor u) -> SbColor"""
        return _coin.SbColor___sub__(self, u)

    def __mul__(self, d: "float const") -> "SbColor":
        r"""__mul__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___mul__(self, d)

    def __rmul__(self, d: "float const") -> "SbColor":
        r"""__rmul__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___rmul__(self, d)

    def __div__(self, d: "float const") -> "SbColor":
        r"""__div__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___div__(self, d)

    def __eq__(self, u: "SbColor") -> "int":
        r"""__eq__(SbColor self, SbColor u) -> int"""
        return _coin.SbColor___eq__(self, u)

    def __nq__(self, u: "SbColor") -> "int":
        r"""__nq__(SbColor self, SbColor u) -> int"""
        return _coin.SbColor___nq__(self, u)

    def __getitem__(self, i: "int") -> "float":
        r"""__getitem__(SbColor self, int i) -> float"""
        return _coin.SbColor___getitem__(self, i)

    def __setitem__(self, i: "int", value: "float") -> "void":
        r"""__setitem__(SbColor self, int i, float value)"""
        return _coin.SbColor___setitem__(self, i, value)
    __swig_destroy__ = _coin.delete_SbColor

# Register SbColor in _coin:
_coin.SbColor_swigregister(SbColor)

SO_LAZY_SHINY_THRESHOLD = _coin.SO_LAZY_SHINY_THRESHOLD

class SoLazyElement(SoElement):
    r"""Proxy of C++ SoLazyElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLazyElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoLazyElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoLazyElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLazyElement_initClass()
    LIGHT_MODEL_CASE = _coin.SoLazyElement_LIGHT_MODEL_CASE
    
    COLOR_MATERIAL_CASE = _coin.SoLazyElement_COLOR_MATERIAL_CASE
    
    DIFFUSE_CASE = _coin.SoLazyElement_DIFFUSE_CASE
    
    AMBIENT_CASE = _coin.SoLazyElement_AMBIENT_CASE
    
    EMISSIVE_CASE = _coin.SoLazyElement_EMISSIVE_CASE
    
    SPECULAR_CASE = _coin.SoLazyElement_SPECULAR_CASE
    
    SHININESS_CASE = _coin.SoLazyElement_SHININESS_CASE
    
    BLENDING_CASE = _coin.SoLazyElement_BLENDING_CASE
    
    TRANSPARENCY_CASE = _coin.SoLazyElement_TRANSPARENCY_CASE
    
    VERTEXORDERING_CASE = _coin.SoLazyElement_VERTEXORDERING_CASE
    
    TWOSIDE_CASE = _coin.SoLazyElement_TWOSIDE_CASE
    
    CULLING_CASE = _coin.SoLazyElement_CULLING_CASE
    
    SHADE_MODEL_CASE = _coin.SoLazyElement_SHADE_MODEL_CASE
    
    ALPHATEST_CASE = _coin.SoLazyElement_ALPHATEST_CASE
    
    GLIMAGE_CASE = _coin.SoLazyElement_GLIMAGE_CASE
    
    LAZYCASES_LAST = _coin.SoLazyElement_LAZYCASES_LAST
    
    LIGHT_MODEL_MASK = _coin.SoLazyElement_LIGHT_MODEL_MASK
    
    COLOR_MATERIAL_MASK = _coin.SoLazyElement_COLOR_MATERIAL_MASK
    
    DIFFUSE_MASK = _coin.SoLazyElement_DIFFUSE_MASK
    
    AMBIENT_MASK = _coin.SoLazyElement_AMBIENT_MASK
    
    EMISSIVE_MASK = _coin.SoLazyElement_EMISSIVE_MASK
    
    SPECULAR_MASK = _coin.SoLazyElement_SPECULAR_MASK
    
    SHININESS_MASK = _coin.SoLazyElement_SHININESS_MASK
    
    TRANSPARENCY_MASK = _coin.SoLazyElement_TRANSPARENCY_MASK
    
    BLENDING_MASK = _coin.SoLazyElement_BLENDING_MASK
    
    VERTEXORDERING_MASK = _coin.SoLazyElement_VERTEXORDERING_MASK
    
    TWOSIDE_MASK = _coin.SoLazyElement_TWOSIDE_MASK
    
    CULLING_MASK = _coin.SoLazyElement_CULLING_MASK
    
    SHADE_MODEL_MASK = _coin.SoLazyElement_SHADE_MODEL_MASK
    
    ALPHATEST_MASK = _coin.SoLazyElement_ALPHATEST_MASK
    
    GLIMAGE_MASK = _coin.SoLazyElement_GLIMAGE_MASK
    
    ALL_MASK = _coin.SoLazyElement_ALL_MASK
    
    OTHER_COLOR_MASK = _coin.SoLazyElement_OTHER_COLOR_MASK
    
    ALL_COLOR_MASK = _coin.SoLazyElement_ALL_COLOR_MASK
    
    NO_COLOR_MASK = _coin.SoLazyElement_NO_COLOR_MASK
    
    ALL_BUT_DIFFUSE_MASK = _coin.SoLazyElement_ALL_BUT_DIFFUSE_MASK
    
    DIFFUSE_ONLY_MASK = _coin.SoLazyElement_DIFFUSE_ONLY_MASK
    
    BASE_COLOR = _coin.SoLazyElement_BASE_COLOR
    
    PHONG = _coin.SoLazyElement_PHONG
    
    CW = _coin.SoLazyElement_CW
    
    CCW = _coin.SoLazyElement_CCW
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoLazyElement self, SoState state)"""
        return _coin.SoLazyElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoLazyElement self, SoState state)"""
        return _coin.SoLazyElement_push(self, state)

    def matches(self, arg2: "SoElement") -> "SbBool":
        r"""matches(SoLazyElement self, SoElement arg2) -> SbBool"""
        return _coin.SoLazyElement_matches(self, arg2)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoLazyElement self) -> SoElement"""
        return _coin.SoLazyElement_copyMatchInfo(self)

    @staticmethod
    def setToDefault(state: "SoState") -> "void":
        r"""setToDefault(SoState state)"""
        return _coin.SoLazyElement_setToDefault(state)

    @staticmethod
    def setDiffuse(state: "SoState", node: "SoNode", numcolors: "int32_t", colors: "SbColor", packer: "SoColorPacker") -> "void":
        r"""setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
        return _coin.SoLazyElement_setDiffuse(state, node, numcolors, colors, packer)

    @staticmethod
    def setTransparency(state: "SoState", node: "SoNode", numvalues: "int32_t", transparency: "float const *", packer: "SoColorPacker") -> "void":
        r"""setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"""
        return _coin.SoLazyElement_setTransparency(state, node, numvalues, transparency, packer)

    @staticmethod
    def setColorIndices(state: "SoState", node: "SoNode", numindices: "int32_t", indices: "int32_t const *") -> "void":
        r"""setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"""
        return _coin.SoLazyElement_setColorIndices(state, node, numindices, indices)

    @staticmethod
    def setAmbient(state: "SoState", color: "SbColor") -> "void":
        r"""setAmbient(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setAmbient(state, color)

    @staticmethod
    def setEmissive(state: "SoState", color: "SbColor") -> "void":
        r"""setEmissive(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setEmissive(state, color)

    @staticmethod
    def setSpecular(state: "SoState", color: "SbColor") -> "void":
        r"""setSpecular(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setSpecular(state, color)

    @staticmethod
    def setShininess(state: "SoState", value: "float") -> "void":
        r"""setShininess(SoState state, float value)"""
        return _coin.SoLazyElement_setShininess(state, value)

    @staticmethod
    def setColorMaterial(state: "SoState", value: "SbBool") -> "void":
        r"""setColorMaterial(SoState state, SbBool value)"""
        return _coin.SoLazyElement_setColorMaterial(state, value)

    @staticmethod
    def enableBlending(state: "SoState", sfactor: "int", dfactor: "int") -> "void":
        r"""enableBlending(SoState state, int sfactor, int dfactor)"""
        return _coin.SoLazyElement_enableBlending(state, sfactor, dfactor)

    @staticmethod
    def enableSeparateBlending(state: "SoState", sfactor: "int", dfactor: "int", alpha_sfactor: "int", alpha_dfactor: "int") -> "void":
        r"""enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
        return _coin.SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor)

    @staticmethod
    def disableBlending(state: "SoState") -> "void":
        r"""disableBlending(SoState state)"""
        return _coin.SoLazyElement_disableBlending(state)

    @staticmethod
    def setLightModel(state: "SoState", model: "int32_t const") -> "void":
        r"""setLightModel(SoState state, int32_t const model)"""
        return _coin.SoLazyElement_setLightModel(state, model)

    @staticmethod
    def setVertexOrdering(state: "SoState", ordering: "SoLazyElement::VertexOrdering") -> "void":
        r"""setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"""
        return _coin.SoLazyElement_setVertexOrdering(state, ordering)

    @staticmethod
    def setBackfaceCulling(state: "SoState", onoff: "SbBool") -> "void":
        r"""setBackfaceCulling(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setBackfaceCulling(state, onoff)

    @staticmethod
    def setTwosideLighting(state: "SoState", onoff: "SbBool") -> "void":
        r"""setTwosideLighting(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setTwosideLighting(state, onoff)

    @staticmethod
    def setShadeModel(state: "SoState", flatshading: "SbBool") -> "void":
        r"""setShadeModel(SoState state, SbBool flatshading)"""
        return _coin.SoLazyElement_setShadeModel(state, flatshading)

    @staticmethod
    def setAlphaTest(state: "SoState", func: "int", value: "float") -> "void":
        r"""setAlphaTest(SoState state, int func, float value)"""
        return _coin.SoLazyElement_setAlphaTest(state, func, value)

    @staticmethod
    def getDiffuse(state: "SoState", index: "int") -> "SbColor const &":
        r"""getDiffuse(SoState state, int index) -> SbColor"""
        return _coin.SoLazyElement_getDiffuse(state, index)

    @staticmethod
    def getTransparency(arg1: "SoState", index: "int") -> "float":
        r"""getTransparency(SoState arg1, int index) -> float"""
        return _coin.SoLazyElement_getTransparency(arg1, index)

    @staticmethod
    def getPackedColors(arg1: "SoState") -> "uint32_t const *":
        r"""getPackedColors(SoState arg1) -> uint32_t const *"""
        return _coin.SoLazyElement_getPackedColors(arg1)

    @staticmethod
    def getColorIndices(arg1: "SoState") -> "int32_t const *":
        r"""getColorIndices(SoState arg1) -> int32_t const *"""
        return _coin.SoLazyElement_getColorIndices(arg1)

    @staticmethod
    def getColorIndex(arg1: "SoState", num: "int") -> "int32_t":
        r"""getColorIndex(SoState arg1, int num) -> int32_t"""
        return _coin.SoLazyElement_getColorIndex(arg1, num)

    @staticmethod
    def getAmbient(arg1: "SoState") -> "SbColor const &":
        r"""getAmbient(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getAmbient(arg1)

    @staticmethod
    def getEmissive(arg1: "SoState") -> "SbColor const &":
        r"""getEmissive(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getEmissive(arg1)

    @staticmethod
    def getSpecular(arg1: "SoState") -> "SbColor const &":
        r"""getSpecular(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getSpecular(arg1)

    @staticmethod
    def getShininess(arg1: "SoState") -> "float":
        r"""getShininess(SoState arg1) -> float"""
        return _coin.SoLazyElement_getShininess(arg1)

    @staticmethod
    def getColorMaterial(arg1: "SoState") -> "SbBool":
        r"""getColorMaterial(SoState arg1) -> SbBool"""
        return _coin.SoLazyElement_getColorMaterial(arg1)

    @staticmethod
    def getBlending(arg1: "SoState", sfactor: "int &", dfactor: "int &") -> "SbBool":
        r"""getBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
        return _coin.SoLazyElement_getBlending(arg1, sfactor, dfactor)

    @staticmethod
    def getAlphaBlending(arg1: "SoState", sfactor: "int &", dfactor: "int &") -> "SbBool":
        r"""getAlphaBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
        return _coin.SoLazyElement_getAlphaBlending(arg1, sfactor, dfactor)

    @staticmethod
    def getLightModel(arg1: "SoState") -> "int32_t":
        r"""getLightModel(SoState arg1) -> int32_t"""
        return _coin.SoLazyElement_getLightModel(arg1)

    @staticmethod
    def getAlphaTest(state: "SoState", value: "float &") -> "int":
        r"""getAlphaTest(SoState state, float & value) -> int"""
        return _coin.SoLazyElement_getAlphaTest(state, value)

    @staticmethod
    def getTwoSidedLighting(state: "SoState") -> "SbBool":
        r"""getTwoSidedLighting(SoState state) -> SbBool"""
        return _coin.SoLazyElement_getTwoSidedLighting(state)

    def getNumDiffuse(self) -> "int32_t":
        r"""getNumDiffuse(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumDiffuse(self)

    def getNumTransparencies(self) -> "int32_t":
        r"""getNumTransparencies(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumTransparencies(self)

    def getNumColorIndices(self) -> "int32_t":
        r"""getNumColorIndices(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumColorIndices(self)

    def isPacked(self) -> "SbBool":
        r"""isPacked(SoLazyElement self) -> SbBool"""
        return _coin.SoLazyElement_isPacked(self)

    def isTransparent(self) -> "SbBool":
        r"""isTransparent(SoLazyElement self) -> SbBool"""
        return _coin.SoLazyElement_isTransparent(self)

    @staticmethod
    def getInstance(state: "SoState") -> "SoLazyElement *":
        r"""getInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getInstance(state)

    @staticmethod
    def getDefaultAmbientIntensity() -> "float":
        r"""getDefaultAmbientIntensity() -> float"""
        return _coin.SoLazyElement_getDefaultAmbientIntensity()

    @staticmethod
    def getDefaultDiffuse() -> "SbColor":
        r"""getDefaultDiffuse() -> SbColor"""
        return _coin.SoLazyElement_getDefaultDiffuse()

    @staticmethod
    def getDefaultAmbient() -> "SbColor":
        r"""getDefaultAmbient() -> SbColor"""
        return _coin.SoLazyElement_getDefaultAmbient()

    @staticmethod
    def getDefaultSpecular() -> "SbColor":
        r"""getDefaultSpecular() -> SbColor"""
        return _coin.SoLazyElement_getDefaultSpecular()

    @staticmethod
    def getDefaultEmissive() -> "SbColor":
        r"""getDefaultEmissive() -> SbColor"""
        return _coin.SoLazyElement_getDefaultEmissive()

    @staticmethod
    def getDefaultShininess() -> "float":
        r"""getDefaultShininess() -> float"""
        return _coin.SoLazyElement_getDefaultShininess()

    @staticmethod
    def getDefaultPacked() -> "uint32_t":
        r"""getDefaultPacked() -> uint32_t"""
        return _coin.SoLazyElement_getDefaultPacked()

    @staticmethod
    def getDefaultTransparency() -> "float":
        r"""getDefaultTransparency() -> float"""
        return _coin.SoLazyElement_getDefaultTransparency()

    @staticmethod
    def getDefaultLightModel() -> "int32_t":
        r"""getDefaultLightModel() -> int32_t"""
        return _coin.SoLazyElement_getDefaultLightModel()

    @staticmethod
    def getDefaultColorIndex() -> "int32_t":
        r"""getDefaultColorIndex() -> int32_t"""
        return _coin.SoLazyElement_getDefaultColorIndex()

    @staticmethod
    def setMaterials(state: "SoState", node: "SoNode", bitmask: "uint32_t", cPacker: "SoColorPacker", diffuse: "SbColor", numdiffuse: "int const", transp: "float const *", numtransp: "int const", ambient: "SbColor", emissive: "SbColor", specular: "SbColor", shininess: "float const", istransparent: "SbBool const") -> "void":
        r"""setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
        return _coin.SoLazyElement_setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)

    @staticmethod
    def getWInstance(state: "SoState") -> "SoLazyElement *":
        r"""getWInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getWInstance(state)

    def getPackedPointer(self) -> "uint32_t const *":
        r"""getPackedPointer(SoLazyElement self) -> uint32_t const *"""
        return _coin.SoLazyElement_getPackedPointer(self)

    def getDiffusePointer(self) -> "SbColor const *":
        r"""getDiffusePointer(SoLazyElement self) -> SbColor"""
        return _coin.SoLazyElement_getDiffusePointer(self)

    def getColorIndexPointer(self) -> "int32_t const *":
        r"""getColorIndexPointer(SoLazyElement self) -> int32_t const *"""
        return _coin.SoLazyElement_getColorIndexPointer(self)

    def getTransparencyPointer(self) -> "float const *":
        r"""getTransparencyPointer(SoLazyElement self) -> float const *"""
        return _coin.SoLazyElement_getTransparencyPointer(self)

    @staticmethod
    def setTransparencyType(state: "SoState", type: "int32_t") -> "void":
        r"""setTransparencyType(SoState state, int32_t type)"""
        return _coin.SoLazyElement_setTransparencyType(state, type)

# Register SoLazyElement in _coin:
_coin.SoLazyElement_swigregister(SoLazyElement)

def SoLazyElement_getClassTypeId() -> "SoType":
    r"""SoLazyElement_getClassTypeId() -> SoType"""
    return _coin.SoLazyElement_getClassTypeId()

def SoLazyElement_getClassStackIndex() -> "int":
    r"""SoLazyElement_getClassStackIndex() -> int"""
    return _coin.SoLazyElement_getClassStackIndex()

def SoLazyElement_createInstance() -> "void *":
    r"""SoLazyElement_createInstance() -> void *"""
    return _coin.SoLazyElement_createInstance()

def SoLazyElement_initClass() -> "void":
    r"""SoLazyElement_initClass()"""
    return _coin.SoLazyElement_initClass()

def SoLazyElement_setToDefault(state: "SoState") -> "void":
    r"""SoLazyElement_setToDefault(SoState state)"""
    return _coin.SoLazyElement_setToDefault(state)

def SoLazyElement_setDiffuse(state: "SoState", node: "SoNode", numcolors: "int32_t", colors: "SbColor", packer: "SoColorPacker") -> "void":
    r"""SoLazyElement_setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
    return _coin.SoLazyElement_setDiffuse(state, node, numcolors, colors, packer)

def SoLazyElement_setTransparency(state: "SoState", node: "SoNode", numvalues: "int32_t", transparency: "float const *", packer: "SoColorPacker") -> "void":
    r"""SoLazyElement_setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"""
    return _coin.SoLazyElement_setTransparency(state, node, numvalues, transparency, packer)

def SoLazyElement_setColorIndices(state: "SoState", node: "SoNode", numindices: "int32_t", indices: "int32_t const *") -> "void":
    r"""SoLazyElement_setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"""
    return _coin.SoLazyElement_setColorIndices(state, node, numindices, indices)

def SoLazyElement_setAmbient(state: "SoState", color: "SbColor") -> "void":
    r"""SoLazyElement_setAmbient(SoState state, SbColor color)"""
    return _coin.SoLazyElement_setAmbient(state, color)

def SoLazyElement_setEmissive(state: "SoState", color: "SbColor") -> "void":
    r"""SoLazyElement_setEmissive(SoState state, SbColor color)"""
    return _coin.SoLazyElement_setEmissive(state, color)

def SoLazyElement_setSpecular(state: "SoState", color: "SbColor") -> "void":
    r"""SoLazyElement_setSpecular(SoState state, SbColor color)"""
    return _coin.SoLazyElement_setSpecular(state, color)

def SoLazyElement_setShininess(state: "SoState", value: "float") -> "void":
    r"""SoLazyElement_setShininess(SoState state, float value)"""
    return _coin.SoLazyElement_setShininess(state, value)

def SoLazyElement_setColorMaterial(state: "SoState", value: "SbBool") -> "void":
    r"""SoLazyElement_setColorMaterial(SoState state, SbBool value)"""
    return _coin.SoLazyElement_setColorMaterial(state, value)

def SoLazyElement_enableBlending(state: "SoState", sfactor: "int", dfactor: "int") -> "void":
    r"""SoLazyElement_enableBlending(SoState state, int sfactor, int dfactor)"""
    return _coin.SoLazyElement_enableBlending(state, sfactor, dfactor)

def SoLazyElement_enableSeparateBlending(state: "SoState", sfactor: "int", dfactor: "int", alpha_sfactor: "int", alpha_dfactor: "int") -> "void":
    r"""SoLazyElement_enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
    return _coin.SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor)

def SoLazyElement_disableBlending(state: "SoState") -> "void":
    r"""SoLazyElement_disableBlending(SoState state)"""
    return _coin.SoLazyElement_disableBlending(state)

def SoLazyElement_setLightModel(state: "SoState", model: "int32_t const") -> "void":
    r"""SoLazyElement_setLightModel(SoState state, int32_t const model)"""
    return _coin.SoLazyElement_setLightModel(state, model)

def SoLazyElement_setVertexOrdering(state: "SoState", ordering: "SoLazyElement::VertexOrdering") -> "void":
    r"""SoLazyElement_setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"""
    return _coin.SoLazyElement_setVertexOrdering(state, ordering)

def SoLazyElement_setBackfaceCulling(state: "SoState", onoff: "SbBool") -> "void":
    r"""SoLazyElement_setBackfaceCulling(SoState state, SbBool onoff)"""
    return _coin.SoLazyElement_setBackfaceCulling(state, onoff)

def SoLazyElement_setTwosideLighting(state: "SoState", onoff: "SbBool") -> "void":
    r"""SoLazyElement_setTwosideLighting(SoState state, SbBool onoff)"""
    return _coin.SoLazyElement_setTwosideLighting(state, onoff)

def SoLazyElement_setShadeModel(state: "SoState", flatshading: "SbBool") -> "void":
    r"""SoLazyElement_setShadeModel(SoState state, SbBool flatshading)"""
    return _coin.SoLazyElement_setShadeModel(state, flatshading)

def SoLazyElement_setAlphaTest(state: "SoState", func: "int", value: "float") -> "void":
    r"""SoLazyElement_setAlphaTest(SoState state, int func, float value)"""
    return _coin.SoLazyElement_setAlphaTest(state, func, value)

def SoLazyElement_getDiffuse(state: "SoState", index: "int") -> "SbColor const &":
    r"""SoLazyElement_getDiffuse(SoState state, int index) -> SbColor"""
    return _coin.SoLazyElement_getDiffuse(state, index)

def SoLazyElement_getTransparency(arg1: "SoState", index: "int") -> "float":
    r"""SoLazyElement_getTransparency(SoState arg1, int index) -> float"""
    return _coin.SoLazyElement_getTransparency(arg1, index)

def SoLazyElement_getPackedColors(arg1: "SoState") -> "uint32_t const *":
    r"""SoLazyElement_getPackedColors(SoState arg1) -> uint32_t const *"""
    return _coin.SoLazyElement_getPackedColors(arg1)

def SoLazyElement_getColorIndices(arg1: "SoState") -> "int32_t const *":
    r"""SoLazyElement_getColorIndices(SoState arg1) -> int32_t const *"""
    return _coin.SoLazyElement_getColorIndices(arg1)

def SoLazyElement_getColorIndex(arg1: "SoState", num: "int") -> "int32_t":
    r"""SoLazyElement_getColorIndex(SoState arg1, int num) -> int32_t"""
    return _coin.SoLazyElement_getColorIndex(arg1, num)

def SoLazyElement_getAmbient(arg1: "SoState") -> "SbColor const &":
    r"""SoLazyElement_getAmbient(SoState arg1) -> SbColor"""
    return _coin.SoLazyElement_getAmbient(arg1)

def SoLazyElement_getEmissive(arg1: "SoState") -> "SbColor const &":
    r"""SoLazyElement_getEmissive(SoState arg1) -> SbColor"""
    return _coin.SoLazyElement_getEmissive(arg1)

def SoLazyElement_getSpecular(arg1: "SoState") -> "SbColor const &":
    r"""SoLazyElement_getSpecular(SoState arg1) -> SbColor"""
    return _coin.SoLazyElement_getSpecular(arg1)

def SoLazyElement_getShininess(arg1: "SoState") -> "float":
    r"""SoLazyElement_getShininess(SoState arg1) -> float"""
    return _coin.SoLazyElement_getShininess(arg1)

def SoLazyElement_getColorMaterial(arg1: "SoState") -> "SbBool":
    r"""SoLazyElement_getColorMaterial(SoState arg1) -> SbBool"""
    return _coin.SoLazyElement_getColorMaterial(arg1)

def SoLazyElement_getBlending(arg1: "SoState", sfactor: "int &", dfactor: "int &") -> "SbBool":
    r"""SoLazyElement_getBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
    return _coin.SoLazyElement_getBlending(arg1, sfactor, dfactor)

def SoLazyElement_getAlphaBlending(arg1: "SoState", sfactor: "int &", dfactor: "int &") -> "SbBool":
    r"""SoLazyElement_getAlphaBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
    return _coin.SoLazyElement_getAlphaBlending(arg1, sfactor, dfactor)

def SoLazyElement_getLightModel(arg1: "SoState") -> "int32_t":
    r"""SoLazyElement_getLightModel(SoState arg1) -> int32_t"""
    return _coin.SoLazyElement_getLightModel(arg1)

def SoLazyElement_getAlphaTest(state: "SoState", value: "float &") -> "int":
    r"""SoLazyElement_getAlphaTest(SoState state, float & value) -> int"""
    return _coin.SoLazyElement_getAlphaTest(state, value)

def SoLazyElement_getTwoSidedLighting(state: "SoState") -> "SbBool":
    r"""SoLazyElement_getTwoSidedLighting(SoState state) -> SbBool"""
    return _coin.SoLazyElement_getTwoSidedLighting(state)

def SoLazyElement_getInstance(state: "SoState") -> "SoLazyElement *":
    r"""SoLazyElement_getInstance(SoState state) -> SoLazyElement"""
    return _coin.SoLazyElement_getInstance(state)

def SoLazyElement_getDefaultAmbientIntensity() -> "float":
    r"""SoLazyElement_getDefaultAmbientIntensity() -> float"""
    return _coin.SoLazyElement_getDefaultAmbientIntensity()

def SoLazyElement_getDefaultDiffuse() -> "SbColor":
    r"""SoLazyElement_getDefaultDiffuse() -> SbColor"""
    return _coin.SoLazyElement_getDefaultDiffuse()

def SoLazyElement_getDefaultAmbient() -> "SbColor":
    r"""SoLazyElement_getDefaultAmbient() -> SbColor"""
    return _coin.SoLazyElement_getDefaultAmbient()

def SoLazyElement_getDefaultSpecular() -> "SbColor":
    r"""SoLazyElement_getDefaultSpecular() -> SbColor"""
    return _coin.SoLazyElement_getDefaultSpecular()

def SoLazyElement_getDefaultEmissive() -> "SbColor":
    r"""SoLazyElement_getDefaultEmissive() -> SbColor"""
    return _coin.SoLazyElement_getDefaultEmissive()

def SoLazyElement_getDefaultShininess() -> "float":
    r"""SoLazyElement_getDefaultShininess() -> float"""
    return _coin.SoLazyElement_getDefaultShininess()

def SoLazyElement_getDefaultPacked() -> "uint32_t":
    r"""SoLazyElement_getDefaultPacked() -> uint32_t"""
    return _coin.SoLazyElement_getDefaultPacked()

def SoLazyElement_getDefaultTransparency() -> "float":
    r"""SoLazyElement_getDefaultTransparency() -> float"""
    return _coin.SoLazyElement_getDefaultTransparency()

def SoLazyElement_getDefaultLightModel() -> "int32_t":
    r"""SoLazyElement_getDefaultLightModel() -> int32_t"""
    return _coin.SoLazyElement_getDefaultLightModel()

def SoLazyElement_getDefaultColorIndex() -> "int32_t":
    r"""SoLazyElement_getDefaultColorIndex() -> int32_t"""
    return _coin.SoLazyElement_getDefaultColorIndex()

def SoLazyElement_setMaterials(state: "SoState", node: "SoNode", bitmask: "uint32_t", cPacker: "SoColorPacker", diffuse: "SbColor", numdiffuse: "int const", transp: "float const *", numtransp: "int const", ambient: "SbColor", emissive: "SbColor", specular: "SbColor", shininess: "float const", istransparent: "SbBool const") -> "void":
    r"""SoLazyElement_setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
    return _coin.SoLazyElement_setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)

def SoLazyElement_getWInstance(state: "SoState") -> "SoLazyElement *":
    r"""SoLazyElement_getWInstance(SoState state) -> SoLazyElement"""
    return _coin.SoLazyElement_getWInstance(state)

def SoLazyElement_setTransparencyType(state: "SoState", type: "int32_t") -> "void":
    r"""SoLazyElement_setTransparencyType(SoState state, int32_t type)"""
    return _coin.SoLazyElement_setTransparencyType(state, type)

class SoColorPacker(object):
    r"""Proxy of C++ SoColorPacker class."""

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

    def __init__(self):
        r"""__init__(SoColorPacker self) -> SoColorPacker"""
        _coin.SoColorPacker_swiginit(self, _coin.new_SoColorPacker())
    __swig_destroy__ = _coin.delete_SoColorPacker

    def getPackedColors(self) -> "uint32_t *":
        r"""getPackedColors(SoColorPacker self) -> uint32_t *"""
        return _coin.SoColorPacker_getPackedColors(self)

    def diffuseMatch(self, nodeid: "SbUniqueId const") -> "SbBool":
        r"""diffuseMatch(SoColorPacker self, SbUniqueId const nodeid) -> SbBool"""
        return _coin.SoColorPacker_diffuseMatch(self, nodeid)

    def transpMatch(self, nodeid: "SbUniqueId const") -> "SbBool":
        r"""transpMatch(SoColorPacker self, SbUniqueId const nodeid) -> SbBool"""
        return _coin.SoColorPacker_transpMatch(self, nodeid)

    def setNodeIds(self, diffuse: "SbUniqueId const", transp: "SbUniqueId const") -> "void":
        r"""setNodeIds(SoColorPacker self, SbUniqueId const diffuse, SbUniqueId const transp)"""
        return _coin.SoColorPacker_setNodeIds(self, diffuse, transp)

    def getSize(self) -> "int32_t":
        r"""getSize(SoColorPacker self) -> int32_t"""
        return _coin.SoColorPacker_getSize(self)

    def reallocate(self, size: "int32_t const") -> "void":
        r"""reallocate(SoColorPacker self, int32_t const size)"""
        return _coin.SoColorPacker_reallocate(self, size)

    def getDiffuseId(self) -> "SbUniqueId":
        r"""getDiffuseId(SoColorPacker self) -> SbUniqueId"""
        return _coin.SoColorPacker_getDiffuseId(self)

    def getTranspId(self) -> "SbUniqueId":
        r"""getTranspId(SoColorPacker self) -> SbUniqueId"""
        return _coin.SoColorPacker_getTranspId(self)

# Register SoColorPacker in _coin:
_coin.SoColorPacker_swigregister(SoColorPacker)

class SoLightModel(SoNode):
    r"""Proxy of C++ SoLightModel class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightModel_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLightModel self) -> SoType"""
        return _coin.SoLightModel_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLightModel_initClass()

    def __init__(self):
        r"""__init__(SoLightModel self) -> SoLightModel"""
        _coin.SoLightModel_swiginit(self, _coin.new_SoLightModel())
    BASE_COLOR = _coin.SoLightModel_BASE_COLOR
    
    PHONG = _coin.SoLightModel_PHONG
    
    model = property(_coin.SoLightModel_model_get, _coin.SoLightModel_model_set, doc=r"""model : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoLightModel self, SoAction action)"""
        return _coin.SoLightModel_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoLightModel self, SoGLRenderAction action)"""
        return _coin.SoLightModel_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoLightModel self, SoCallbackAction action)"""
        return _coin.SoLightModel_callback(self, action)

# Register SoLightModel in _coin:
_coin.SoLightModel_swigregister(SoLightModel)

def SoLightModel_getClassTypeId() -> "SoType":
    r"""SoLightModel_getClassTypeId() -> SoType"""
    return _coin.SoLightModel_getClassTypeId()

def SoLightModel_initClass() -> "void":
    r"""SoLightModel_initClass()"""
    return _coin.SoLightModel_initClass()

class SoMaterialBindingElement(SoInt32Element):
    r"""Proxy of C++ SoMaterialBindingElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMaterialBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoMaterialBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMaterialBindingElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMaterialBindingElement_initClass()
    OVERALL = _coin.SoMaterialBindingElement_OVERALL
    
    PER_PART = _coin.SoMaterialBindingElement_PER_PART
    
    PER_PART_INDEXED = _coin.SoMaterialBindingElement_PER_PART_INDEXED
    
    PER_FACE = _coin.SoMaterialBindingElement_PER_FACE
    
    PER_FACE_INDEXED = _coin.SoMaterialBindingElement_PER_FACE_INDEXED
    
    PER_VERTEX = _coin.SoMaterialBindingElement_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoMaterialBindingElement_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoMaterialBindingElement_DEFAULT
    
    NONE = _coin.SoMaterialBindingElement_NONE
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoMaterialBindingElement self, SoState state)"""
        return _coin.SoMaterialBindingElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoMaterialBindingElement::Binding const binding)
        set(SoState state, SoMaterialBindingElement::Binding const binding)
        """
        return _coin.SoMaterialBindingElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoMaterialBindingElement::Binding":
        r"""get(SoState state) -> SoMaterialBindingElement::Binding"""
        return _coin.SoMaterialBindingElement_get(state)

    @staticmethod
    def getDefault() -> "SoMaterialBindingElement::Binding":
        r"""getDefault() -> SoMaterialBindingElement::Binding"""
        return _coin.SoMaterialBindingElement_getDefault()

# Register SoMaterialBindingElement in _coin:
_coin.SoMaterialBindingElement_swigregister(SoMaterialBindingElement)

def SoMaterialBindingElement_getClassTypeId() -> "SoType":
    r"""SoMaterialBindingElement_getClassTypeId() -> SoType"""
    return _coin.SoMaterialBindingElement_getClassTypeId()

def SoMaterialBindingElement_getClassStackIndex() -> "int":
    r"""SoMaterialBindingElement_getClassStackIndex() -> int"""
    return _coin.SoMaterialBindingElement_getClassStackIndex()

def SoMaterialBindingElement_createInstance() -> "void *":
    r"""SoMaterialBindingElement_createInstance() -> void *"""
    return _coin.SoMaterialBindingElement_createInstance()

def SoMaterialBindingElement_initClass() -> "void":
    r"""SoMaterialBindingElement_initClass()"""
    return _coin.SoMaterialBindingElement_initClass()

def SoMaterialBindingElement_set(*args) -> "void":
    r"""
    SoMaterialBindingElement_set(SoState state, SoNode node, SoMaterialBindingElement::Binding const binding)
    SoMaterialBindingElement_set(SoState state, SoMaterialBindingElement::Binding const binding)
    """
    return _coin.SoMaterialBindingElement_set(*args)

def SoMaterialBindingElement_get(state: "SoState") -> "SoMaterialBindingElement::Binding":
    r"""SoMaterialBindingElement_get(SoState state) -> SoMaterialBindingElement::Binding"""
    return _coin.SoMaterialBindingElement_get(state)

def SoMaterialBindingElement_getDefault() -> "SoMaterialBindingElement::Binding":
    r"""SoMaterialBindingElement_getDefault() -> SoMaterialBindingElement::Binding"""
    return _coin.SoMaterialBindingElement_getDefault()

class SoMaterialBinding(SoNode):
    r"""Proxy of C++ SoMaterialBinding class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMaterialBinding_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMaterialBinding self) -> SoType"""
        return _coin.SoMaterialBinding_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMaterialBinding_initClass()

    def __init__(self):
        r"""__init__(SoMaterialBinding self) -> SoMaterialBinding"""
        _coin.SoMaterialBinding_swiginit(self, _coin.new_SoMaterialBinding())
    OVERALL = _coin.SoMaterialBinding_OVERALL
    
    PER_PART = _coin.SoMaterialBinding_PER_PART
    
    PER_PART_INDEXED = _coin.SoMaterialBinding_PER_PART_INDEXED
    
    PER_FACE = _coin.SoMaterialBinding_PER_FACE
    
    PER_FACE_INDEXED = _coin.SoMaterialBinding_PER_FACE_INDEXED
    
    PER_VERTEX = _coin.SoMaterialBinding_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoMaterialBinding_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoMaterialBinding_DEFAULT
    
    NONE = _coin.SoMaterialBinding_NONE
    
    value = property(_coin.SoMaterialBinding_value_get, _coin.SoMaterialBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoMaterialBinding self, SoAction action)"""
        return _coin.SoMaterialBinding_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoMaterialBinding self, SoGLRenderAction action)"""
        return _coin.SoMaterialBinding_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoMaterialBinding self, SoCallbackAction action)"""
        return _coin.SoMaterialBinding_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoMaterialBinding self, SoPickAction action)"""
        return _coin.SoMaterialBinding_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoMaterialBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMaterialBinding_getPrimitiveCount(self, action)

# Register SoMaterialBinding in _coin:
_coin.SoMaterialBinding_swigregister(SoMaterialBinding)

def SoMaterialBinding_getClassTypeId() -> "SoType":
    r"""SoMaterialBinding_getClassTypeId() -> SoType"""
    return _coin.SoMaterialBinding_getClassTypeId()

def SoMaterialBinding_initClass() -> "void":
    r"""SoMaterialBinding_initClass()"""
    return _coin.SoMaterialBinding_initClass()

class SoNormalBindingElement(SoInt32Element):
    r"""Proxy of C++ SoNormalBindingElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormalBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoNormalBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoNormalBindingElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNormalBindingElement_initClass()
    OVERALL = _coin.SoNormalBindingElement_OVERALL
    
    PER_PART = _coin.SoNormalBindingElement_PER_PART
    
    PER_PART_INDEXED = _coin.SoNormalBindingElement_PER_PART_INDEXED
    
    PER_FACE = _coin.SoNormalBindingElement_PER_FACE
    
    PER_FACE_INDEXED = _coin.SoNormalBindingElement_PER_FACE_INDEXED
    
    PER_VERTEX = _coin.SoNormalBindingElement_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoNormalBindingElement_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoNormalBindingElement_DEFAULT
    
    NONE = _coin.SoNormalBindingElement_NONE
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoNormalBindingElement self, SoState state)"""
        return _coin.SoNormalBindingElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoNormalBindingElement::Binding const binding)
        set(SoState state, SoNormalBindingElement::Binding const binding)
        """
        return _coin.SoNormalBindingElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoNormalBindingElement::Binding":
        r"""get(SoState state) -> SoNormalBindingElement::Binding"""
        return _coin.SoNormalBindingElement_get(state)

    @staticmethod
    def getDefault() -> "SoNormalBindingElement::Binding":
        r"""getDefault() -> SoNormalBindingElement::Binding"""
        return _coin.SoNormalBindingElement_getDefault()

# Register SoNormalBindingElement in _coin:
_coin.SoNormalBindingElement_swigregister(SoNormalBindingElement)

def SoNormalBindingElement_getClassTypeId() -> "SoType":
    r"""SoNormalBindingElement_getClassTypeId() -> SoType"""
    return _coin.SoNormalBindingElement_getClassTypeId()

def SoNormalBindingElement_getClassStackIndex() -> "int":
    r"""SoNormalBindingElement_getClassStackIndex() -> int"""
    return _coin.SoNormalBindingElement_getClassStackIndex()

def SoNormalBindingElement_createInstance() -> "void *":
    r"""SoNormalBindingElement_createInstance() -> void *"""
    return _coin.SoNormalBindingElement_createInstance()

def SoNormalBindingElement_initClass() -> "void":
    r"""SoNormalBindingElement_initClass()"""
    return _coin.SoNormalBindingElement_initClass()

def SoNormalBindingElement_set(*args) -> "void":
    r"""
    SoNormalBindingElement_set(SoState state, SoNode node, SoNormalBindingElement::Binding const binding)
    SoNormalBindingElement_set(SoState state, SoNormalBindingElement::Binding const binding)
    """
    return _coin.SoNormalBindingElement_set(*args)

def SoNormalBindingElement_get(state: "SoState") -> "SoNormalBindingElement::Binding":
    r"""SoNormalBindingElement_get(SoState state) -> SoNormalBindingElement::Binding"""
    return _coin.SoNormalBindingElement_get(state)

def SoNormalBindingElement_getDefault() -> "SoNormalBindingElement::Binding":
    r"""SoNormalBindingElement_getDefault() -> SoNormalBindingElement::Binding"""
    return _coin.SoNormalBindingElement_getDefault()

class SoNormalBinding(SoNode):
    r"""Proxy of C++ SoNormalBinding class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormalBinding_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNormalBinding self) -> SoType"""
        return _coin.SoNormalBinding_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNormalBinding_initClass()

    def __init__(self):
        r"""__init__(SoNormalBinding self) -> SoNormalBinding"""
        _coin.SoNormalBinding_swiginit(self, _coin.new_SoNormalBinding())
    OVERALL = _coin.SoNormalBinding_OVERALL
    
    PER_PART = _coin.SoNormalBinding_PER_PART
    
    PER_PART_INDEXED = _coin.SoNormalBinding_PER_PART_INDEXED
    
    PER_FACE = _coin.SoNormalBinding_PER_FACE
    
    PER_FACE_INDEXED = _coin.SoNormalBinding_PER_FACE_INDEXED
    
    PER_VERTEX = _coin.SoNormalBinding_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoNormalBinding_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoNormalBinding_DEFAULT
    
    NONE = _coin.SoNormalBinding_NONE
    
    value = property(_coin.SoNormalBinding_value_get, _coin.SoNormalBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoNormalBinding self, SoAction action)"""
        return _coin.SoNormalBinding_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoNormalBinding self, SoGLRenderAction action)"""
        return _coin.SoNormalBinding_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoNormalBinding self, SoCallbackAction action)"""
        return _coin.SoNormalBinding_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoNormalBinding self, SoPickAction action)"""
        return _coin.SoNormalBinding_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoNormalBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormalBinding_getPrimitiveCount(self, action)

# Register SoNormalBinding in _coin:
_coin.SoNormalBinding_swigregister(SoNormalBinding)

def SoNormalBinding_getClassTypeId() -> "SoType":
    r"""SoNormalBinding_getClassTypeId() -> SoType"""
    return _coin.SoNormalBinding_getClassTypeId()

def SoNormalBinding_initClass() -> "void":
    r"""SoNormalBinding_initClass()"""
    return _coin.SoNormalBinding_initClass()

class SoPickStyleElement(SoInt32Element):
    r"""Proxy of C++ SoPickStyleElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoPickStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoPickStyleElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPickStyleElement_initClass()
    SHAPE = _coin.SoPickStyleElement_SHAPE
    
    BOUNDING_BOX = _coin.SoPickStyleElement_BOUNDING_BOX
    
    UNPICKABLE = _coin.SoPickStyleElement_UNPICKABLE
    
    SHAPE_ON_TOP = _coin.SoPickStyleElement_SHAPE_ON_TOP
    
    BOUNDING_BOX_ON_TOP = _coin.SoPickStyleElement_BOUNDING_BOX_ON_TOP
    
    SHAPE_FRONTFACES = _coin.SoPickStyleElement_SHAPE_FRONTFACES
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoPickStyleElement self, SoState state)"""
        return _coin.SoPickStyleElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, int32_t const style)
        set(SoState state, SoPickStyleElement::Style const style)
        """
        return _coin.SoPickStyleElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoPickStyleElement::Style":
        r"""get(SoState state) -> SoPickStyleElement::Style"""
        return _coin.SoPickStyleElement_get(state)

    @staticmethod
    def getDefault() -> "SoPickStyleElement::Style":
        r"""getDefault() -> SoPickStyleElement::Style"""
        return _coin.SoPickStyleElement_getDefault()

# Register SoPickStyleElement in _coin:
_coin.SoPickStyleElement_swigregister(SoPickStyleElement)

def SoPickStyleElement_getClassTypeId() -> "SoType":
    r"""SoPickStyleElement_getClassTypeId() -> SoType"""
    return _coin.SoPickStyleElement_getClassTypeId()

def SoPickStyleElement_getClassStackIndex() -> "int":
    r"""SoPickStyleElement_getClassStackIndex() -> int"""
    return _coin.SoPickStyleElement_getClassStackIndex()

def SoPickStyleElement_createInstance() -> "void *":
    r"""SoPickStyleElement_createInstance() -> void *"""
    return _coin.SoPickStyleElement_createInstance()

def SoPickStyleElement_initClass() -> "void":
    r"""SoPickStyleElement_initClass()"""
    return _coin.SoPickStyleElement_initClass()

def SoPickStyleElement_set(*args) -> "void":
    r"""
    SoPickStyleElement_set(SoState state, SoNode node, int32_t const style)
    SoPickStyleElement_set(SoState state, SoPickStyleElement::Style const style)
    """
    return _coin.SoPickStyleElement_set(*args)

def SoPickStyleElement_get(state: "SoState") -> "SoPickStyleElement::Style":
    r"""SoPickStyleElement_get(SoState state) -> SoPickStyleElement::Style"""
    return _coin.SoPickStyleElement_get(state)

def SoPickStyleElement_getDefault() -> "SoPickStyleElement::Style":
    r"""SoPickStyleElement_getDefault() -> SoPickStyleElement::Style"""
    return _coin.SoPickStyleElement_getDefault()

class SoPickStyle(SoNode):
    r"""Proxy of C++ SoPickStyle class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickStyle_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPickStyle self) -> SoType"""
        return _coin.SoPickStyle_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPickStyle_initClass()

    def __init__(self):
        r"""__init__(SoPickStyle self) -> SoPickStyle"""
        _coin.SoPickStyle_swiginit(self, _coin.new_SoPickStyle())
    SHAPE = _coin.SoPickStyle_SHAPE
    
    BOUNDING_BOX = _coin.SoPickStyle_BOUNDING_BOX
    
    UNPICKABLE = _coin.SoPickStyle_UNPICKABLE
    
    SHAPE_ON_TOP = _coin.SoPickStyle_SHAPE_ON_TOP
    
    BOUNDING_BOX_ON_TOP = _coin.SoPickStyle_BOUNDING_BOX_ON_TOP
    
    SHAPE_FRONTFACES = _coin.SoPickStyle_SHAPE_FRONTFACES
    
    style = property(_coin.SoPickStyle_style_get, _coin.SoPickStyle_style_set, doc=r"""style : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoPickStyle self, SoAction action)"""
        return _coin.SoPickStyle_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoPickStyle self, SoCallbackAction action)"""
        return _coin.SoPickStyle_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoPickStyle self, SoPickAction action)"""
        return _coin.SoPickStyle_pick(self, action)

# Register SoPickStyle in _coin:
_coin.SoPickStyle_swigregister(SoPickStyle)

def SoPickStyle_getClassTypeId() -> "SoType":
    r"""SoPickStyle_getClassTypeId() -> SoType"""
    return _coin.SoPickStyle_getClassTypeId()

def SoPickStyle_initClass() -> "void":
    r"""SoPickStyle_initClass()"""
    return _coin.SoPickStyle_initClass()

class SoShapeHintsElement(SoElement):
    r"""Proxy of C++ SoShapeHintsElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeHintsElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoShapeHintsElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoShapeHintsElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShapeHintsElement_initClass()
    UNKNOWN_ORDERING = _coin.SoShapeHintsElement_UNKNOWN_ORDERING
    
    CLOCKWISE = _coin.SoShapeHintsElement_CLOCKWISE
    
    COUNTERCLOCKWISE = _coin.SoShapeHintsElement_COUNTERCLOCKWISE
    
    ORDERING_AS_IS = _coin.SoShapeHintsElement_ORDERING_AS_IS
    
    UNKNOWN_SHAPE_TYPE = _coin.SoShapeHintsElement_UNKNOWN_SHAPE_TYPE
    
    SOLID = _coin.SoShapeHintsElement_SOLID
    
    SHAPE_TYPE_AS_IS = _coin.SoShapeHintsElement_SHAPE_TYPE_AS_IS
    
    UNKNOWN_FACE_TYPE = _coin.SoShapeHintsElement_UNKNOWN_FACE_TYPE
    
    CONVEX = _coin.SoShapeHintsElement_CONVEX
    
    FACE_TYPE_AS_IS = _coin.SoShapeHintsElement_FACE_TYPE_AS_IS
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoShapeHintsElement self, SoState state)"""
        return _coin.SoShapeHintsElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoShapeHintsElement self, SoState state)"""
        return _coin.SoShapeHintsElement_push(self, state)

    def pop(self, state: "SoState", prevtopelement: "SoElement") -> "void":
        r"""pop(SoShapeHintsElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoShapeHintsElement_pop(self, state, prevtopelement)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoShapeHintsElement self, SoElement element) -> SbBool"""
        return _coin.SoShapeHintsElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoShapeHintsElement self) -> SoElement"""
        return _coin.SoShapeHintsElement_copyMatchInfo(self)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
        set(SoState state, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
        """
        return _coin.SoShapeHintsElement_set(*args)

    @staticmethod
    def get(state: "SoState", vertexOrdering: "SoShapeHintsElement::VertexOrdering &", shapeType: "SoShapeHintsElement::ShapeType &", faceType: "SoShapeHintsElement::FaceType &") -> "void":
        r"""get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"""
        return _coin.SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType)

    @staticmethod
    def getVertexOrdering(state: "SoState") -> "SoShapeHintsElement::VertexOrdering":
        r"""getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"""
        return _coin.SoShapeHintsElement_getVertexOrdering(state)

    @staticmethod
    def getShapeType(state: "SoState") -> "SoShapeHintsElement::ShapeType":
        r"""getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"""
        return _coin.SoShapeHintsElement_getShapeType(state)

    @staticmethod
    def getFaceType(state: "SoState") -> "SoShapeHintsElement::FaceType":
        r"""getFaceType(SoState state) -> SoShapeHintsElement::FaceType"""
        return _coin.SoShapeHintsElement_getFaceType(state)

    @staticmethod
    def getDefaultVertexOrdering() -> "SoShapeHintsElement::VertexOrdering":
        r"""getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"""
        return _coin.SoShapeHintsElement_getDefaultVertexOrdering()

    @staticmethod
    def getDefaultShapeType() -> "SoShapeHintsElement::ShapeType":
        r"""getDefaultShapeType() -> SoShapeHintsElement::ShapeType"""
        return _coin.SoShapeHintsElement_getDefaultShapeType()

    @staticmethod
    def getDefaultFaceType() -> "SoShapeHintsElement::FaceType":
        r"""getDefaultFaceType() -> SoShapeHintsElement::FaceType"""
        return _coin.SoShapeHintsElement_getDefaultFaceType()

    def output(self, file: "FILE *") -> "void":
        r"""output(SoShapeHintsElement self, FILE * file)"""
        return _coin.SoShapeHintsElement_output(self, file)

# Register SoShapeHintsElement in _coin:
_coin.SoShapeHintsElement_swigregister(SoShapeHintsElement)

def SoShapeHintsElement_getClassTypeId() -> "SoType":
    r"""SoShapeHintsElement_getClassTypeId() -> SoType"""
    return _coin.SoShapeHintsElement_getClassTypeId()

def SoShapeHintsElement_getClassStackIndex() -> "int":
    r"""SoShapeHintsElement_getClassStackIndex() -> int"""
    return _coin.SoShapeHintsElement_getClassStackIndex()

def SoShapeHintsElement_createInstance() -> "void *":
    r"""SoShapeHintsElement_createInstance() -> void *"""
    return _coin.SoShapeHintsElement_createInstance()

def SoShapeHintsElement_initClass() -> "void":
    r"""SoShapeHintsElement_initClass()"""
    return _coin.SoShapeHintsElement_initClass()

def SoShapeHintsElement_set(*args) -> "void":
    r"""
    SoShapeHintsElement_set(SoState state, SoNode node, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
    SoShapeHintsElement_set(SoState state, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
    """
    return _coin.SoShapeHintsElement_set(*args)

def SoShapeHintsElement_get(state: "SoState", vertexOrdering: "SoShapeHintsElement::VertexOrdering &", shapeType: "SoShapeHintsElement::ShapeType &", faceType: "SoShapeHintsElement::FaceType &") -> "void":
    r"""SoShapeHintsElement_get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"""
    return _coin.SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType)

def SoShapeHintsElement_getVertexOrdering(state: "SoState") -> "SoShapeHintsElement::VertexOrdering":
    r"""SoShapeHintsElement_getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"""
    return _coin.SoShapeHintsElement_getVertexOrdering(state)

def SoShapeHintsElement_getShapeType(state: "SoState") -> "SoShapeHintsElement::ShapeType":
    r"""SoShapeHintsElement_getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"""
    return _coin.SoShapeHintsElement_getShapeType(state)

def SoShapeHintsElement_getFaceType(state: "SoState") -> "SoShapeHintsElement::FaceType":
    r"""SoShapeHintsElement_getFaceType(SoState state) -> SoShapeHintsElement::FaceType"""
    return _coin.SoShapeHintsElement_getFaceType(state)

def SoShapeHintsElement_getDefaultVertexOrdering() -> "SoShapeHintsElement::VertexOrdering":
    r"""SoShapeHintsElement_getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"""
    return _coin.SoShapeHintsElement_getDefaultVertexOrdering()

def SoShapeHintsElement_getDefaultShapeType() -> "SoShapeHintsElement::ShapeType":
    r"""SoShapeHintsElement_getDefaultShapeType() -> SoShapeHintsElement::ShapeType"""
    return _coin.SoShapeHintsElement_getDefaultShapeType()

def SoShapeHintsElement_getDefaultFaceType() -> "SoShapeHintsElement::FaceType":
    r"""SoShapeHintsElement_getDefaultFaceType() -> SoShapeHintsElement::FaceType"""
    return _coin.SoShapeHintsElement_getDefaultFaceType()

class SoSFBool(SoSField):
    r"""Proxy of C++ SoSFBool class."""

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

    def __init__(self):
        r"""__init__(SoSFBool self) -> SoSFBool"""
        _coin.SoSFBool_swiginit(self, _coin.new_SoSFBool())
    __swig_destroy__ = _coin.delete_SoSFBool

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBool_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBool_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBool self) -> SoType"""
        return _coin.SoSFBool_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBool self, SoField field)"""
        return _coin.SoSFBool_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBool self, SoField field) -> SbBool"""
        return _coin.SoSFBool_isSame(self, field)

    def getValue(self) -> "SbBool":
        r"""getValue(SoSFBool self) -> SbBool"""
        return _coin.SoSFBool_getValue(self)

    def __eq__(self, field: "SoSFBool") -> "int":
        r"""__eq__(SoSFBool self, SoSFBool field) -> int"""
        return _coin.SoSFBool___eq__(self, field)

    def __ne__(self, field: "SoSFBool") -> "int":
        r"""__ne__(SoSFBool self, SoSFBool field) -> int"""
        return _coin.SoSFBool___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBool_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBool self, SbBool newvalue)
        setValue(SoSFBool self, SoSFBool other)
        """
        return _coin.SoSFBool_setValue(self, *args)

# Register SoSFBool in _coin:
_coin.SoSFBool_swigregister(SoSFBool)

def SoSFBool_createInstance() -> "void *":
    r"""SoSFBool_createInstance() -> void *"""
    return _coin.SoSFBool_createInstance()

def SoSFBool_getClassTypeId() -> "SoType":
    r"""SoSFBool_getClassTypeId() -> SoType"""
    return _coin.SoSFBool_getClassTypeId()

def SoSFBool_initClass() -> "void":
    r"""SoSFBool_initClass()"""
    return _coin.SoSFBool_initClass()

class SoShapeHints(SoNode):
    r"""Proxy of C++ SoShapeHints class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeHints_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShapeHints self) -> SoType"""
        return _coin.SoShapeHints_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShapeHints_initClass()

    def __init__(self):
        r"""__init__(SoShapeHints self) -> SoShapeHints"""
        _coin.SoShapeHints_swiginit(self, _coin.new_SoShapeHints())
    UNKNOWN_ORDERING = _coin.SoShapeHints_UNKNOWN_ORDERING
    
    CLOCKWISE = _coin.SoShapeHints_CLOCKWISE
    
    COUNTERCLOCKWISE = _coin.SoShapeHints_COUNTERCLOCKWISE
    
    UNKNOWN_SHAPE_TYPE = _coin.SoShapeHints_UNKNOWN_SHAPE_TYPE
    
    SOLID = _coin.SoShapeHints_SOLID
    
    UNKNOWN_FACE_TYPE = _coin.SoShapeHints_UNKNOWN_FACE_TYPE
    
    CONVEX = _coin.SoShapeHints_CONVEX
    
    NO_WINDING_TYPE = _coin.SoShapeHints_NO_WINDING_TYPE
    
    vertexOrdering = property(_coin.SoShapeHints_vertexOrdering_get, _coin.SoShapeHints_vertexOrdering_set, doc=r"""vertexOrdering : SoSFEnum""")
    shapeType = property(_coin.SoShapeHints_shapeType_get, _coin.SoShapeHints_shapeType_set, doc=r"""shapeType : SoSFEnum""")
    faceType = property(_coin.SoShapeHints_faceType_get, _coin.SoShapeHints_faceType_set, doc=r"""faceType : SoSFEnum""")
    windingType = property(_coin.SoShapeHints_windingType_get, _coin.SoShapeHints_windingType_set, doc=r"""windingType : SoSFEnum""")
    useVBO = property(_coin.SoShapeHints_useVBO_get, _coin.SoShapeHints_useVBO_set, doc=r"""useVBO : SoSFBool""")
    creaseAngle = property(_coin.SoShapeHints_creaseAngle_get, _coin.SoShapeHints_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoShapeHints self, SoAction action)"""
        return _coin.SoShapeHints_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoShapeHints self, SoGLRenderAction action)"""
        return _coin.SoShapeHints_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoShapeHints self, SoCallbackAction action)"""
        return _coin.SoShapeHints_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoShapeHints self, SoGetBoundingBoxAction action)"""
        return _coin.SoShapeHints_getBoundingBox(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoShapeHints self, SoPickAction action)"""
        return _coin.SoShapeHints_pick(self, action)

# Register SoShapeHints in _coin:
_coin.SoShapeHints_swigregister(SoShapeHints)

def SoShapeHints_getClassTypeId() -> "SoType":
    r"""SoShapeHints_getClassTypeId() -> SoType"""
    return _coin.SoShapeHints_getClassTypeId()

def SoShapeHints_initClass() -> "void":
    r"""SoShapeHints_initClass()"""
    return _coin.SoShapeHints_initClass()

class SoTexture(SoNode):
    r"""Proxy of C++ SoTexture class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTexture self) -> SoType"""
        return _coin.SoTexture_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTexture_initClass()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoTexture_cleanupClass()

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTexture self, SoAction action)"""
        return _coin.SoTexture_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTexture self, SoGLRenderAction action)"""
        return _coin.SoTexture_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTexture self, SoCallbackAction action)"""
        return _coin.SoTexture_callback(self, action)

# Register SoTexture in _coin:
_coin.SoTexture_swigregister(SoTexture)

def SoTexture_getClassTypeId() -> "SoType":
    r"""SoTexture_getClassTypeId() -> SoType"""
    return _coin.SoTexture_getClassTypeId()

def SoTexture_initClass() -> "void":
    r"""SoTexture_initClass()"""
    return _coin.SoTexture_initClass()

def SoTexture_cleanupClass() -> "void":
    r"""SoTexture_cleanupClass()"""
    return _coin.SoTexture_cleanupClass()

class SoSFImage(SoSField):
    r"""Proxy of C++ SoSFImage class."""

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

    def __init__(self):
        r"""__init__(SoSFImage self) -> SoSFImage"""
        _coin.SoSFImage_swiginit(self, _coin.new_SoSFImage())
    __swig_destroy__ = _coin.delete_SoSFImage

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFImage_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFImage_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFImage self) -> SoType"""
        return _coin.SoSFImage_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFImage self, SoField field)"""
        return _coin.SoSFImage_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFImage self, SoField field) -> SbBool"""
        return _coin.SoSFImage_isSame(self, field)
    COPY = _coin.SoSFImage_COPY
    
    NO_COPY = _coin.SoSFImage_NO_COPY
    
    NO_COPY_AND_DELETE = _coin.SoSFImage_NO_COPY_AND_DELETE
    
    NO_COPY_AND_FREE = _coin.SoSFImage_NO_COPY_AND_FREE
    

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFImage_initClass()

    def getValue(self, *args) -> "SbImage const &":
        r"""
        getValue(SoSFImage self) -> unsigned char const
        getValue(SoSFImage self) -> SbImage
        """
        return _coin.SoSFImage_getValue(self, *args)

    def __eq__(self, field: "SoSFImage") -> "int":
        r"""__eq__(SoSFImage self, SoSFImage field) -> int"""
        return _coin.SoSFImage___eq__(self, field)

    def __ne__(self, field: "SoSFImage") -> "int":
        r"""__ne__(SoSFImage self, SoSFImage field) -> int"""
        return _coin.SoSFImage___ne__(self, field)

    def startEditing(self) -> "unsigned char *":
        r"""startEditing(SoSFImage self) -> unsigned char *"""
        return _coin.SoSFImage_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoSFImage self)"""
        return _coin.SoSFImage_finishEditing(self)

    def setSubValue(self, dims: "SbVec2s", offset: "SbVec2s", pixels: "unsigned char *") -> "void":
        r"""setSubValue(SoSFImage self, SbVec2s dims, SbVec2s offset, unsigned char * pixels)"""
        return _coin.SoSFImage_setSubValue(self, dims, offset, pixels)

    def setSubValues(self, dims: "SbVec2s", offsets: "SbVec2s", num: "int", pixelblocks: "unsigned char **") -> "void":
        r"""setSubValues(SoSFImage self, SbVec2s dims, SbVec2s offsets, int num, unsigned char ** pixelblocks)"""
        return _coin.SoSFImage_setSubValues(self, dims, offsets, num, pixelblocks)

    def getSubTexture(self, idx: "int", dims: "SbVec2s", offset: "SbVec2s") -> "unsigned char *":
        r"""getSubTexture(SoSFImage self, int idx, SbVec2s dims, SbVec2s offset) -> unsigned char *"""
        return _coin.SoSFImage_getSubTexture(self, idx, dims, offset)

    def hasSubTextures(self, numsubtextures: "int &") -> "SbBool":
        r"""hasSubTextures(SoSFImage self, int & numsubtextures) -> SbBool"""
        return _coin.SoSFImage_hasSubTextures(self, numsubtextures)

    def setNeverWrite(self, flag: "SbBool") -> "void":
        r"""setNeverWrite(SoSFImage self, SbBool flag)"""
        return _coin.SoSFImage_setNeverWrite(self, flag)

    def isNeverWrite(self) -> "SbBool":
        r"""isNeverWrite(SoSFImage self) -> SbBool"""
        return _coin.SoSFImage_isNeverWrite(self)

    def hasTransparency(self) -> "SbBool":
        r"""hasTransparency(SoSFImage self) -> SbBool"""
        return _coin.SoSFImage_hasTransparency(self)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFImage self, SbVec2s size, int const nc, unsigned char const * pixels, SoSFImage::CopyPolicy copypolicy=COPY)
        setValue(SoSFImage self, SbVec2s size, int const nc, PyObject * pixels)
        setValue(SoSFImage self, SoSFImage other)
        """
        return _coin.SoSFImage_setValue(self, *args)

# Register SoSFImage in _coin:
_coin.SoSFImage_swigregister(SoSFImage)

def SoSFImage_createInstance() -> "void *":
    r"""SoSFImage_createInstance() -> void *"""
    return _coin.SoSFImage_createInstance()

def SoSFImage_getClassTypeId() -> "SoType":
    r"""SoSFImage_getClassTypeId() -> SoType"""
    return _coin.SoSFImage_getClassTypeId()

def SoSFImage_initClass() -> "void":
    r"""SoSFImage_initClass()"""
    return _coin.SoSFImage_initClass()

class SoSFString(SoSField):
    r"""Proxy of C++ SoSFString class."""

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

    def __init__(self):
        r"""__init__(SoSFString self) -> SoSFString"""
        _coin.SoSFString_swiginit(self, _coin.new_SoSFString())
    __swig_destroy__ = _coin.delete_SoSFString

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFString_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFString_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFString self) -> SoType"""
        return _coin.SoSFString_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFString self, SoField field)"""
        return _coin.SoSFString_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFString self, SoField field) -> SbBool"""
        return _coin.SoSFString_isSame(self, field)

    def getValue(self) -> "SbString const &":
        r"""getValue(SoSFString self) -> SbString"""
        return _coin.SoSFString_getValue(self)

    def __eq__(self, field: "SoSFString") -> "int":
        r"""__eq__(SoSFString self, SoSFString field) -> int"""
        return _coin.SoSFString___eq__(self, field)

    def __ne__(self, field: "SoSFString") -> "int":
        r"""__ne__(SoSFString self, SoSFString field) -> int"""
        return _coin.SoSFString___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFString_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFString self, SbString newvalue)
        setValue(SoSFString self, char const * str)
        setValue(SoSFString self, SoSFString other)
        """
        return _coin.SoSFString_setValue(self, *args)

# Register SoSFString in _coin:
_coin.SoSFString_swigregister(SoSFString)

def SoSFString_createInstance() -> "void *":
    r"""SoSFString_createInstance() -> void *"""
    return _coin.SoSFString_createInstance()

def SoSFString_getClassTypeId() -> "SoType":
    r"""SoSFString_getClassTypeId() -> SoType"""
    return _coin.SoSFString_getClassTypeId()

def SoSFString_initClass() -> "void":
    r"""SoSFString_initClass()"""
    return _coin.SoSFString_initClass()

class SoSFColor(SoSField):
    r"""Proxy of C++ SoSFColor class."""

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

    def __init__(self):
        r"""__init__(SoSFColor self) -> SoSFColor"""
        _coin.SoSFColor_swiginit(self, _coin.new_SoSFColor())
    __swig_destroy__ = _coin.delete_SoSFColor

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFColor_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFColor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFColor self) -> SoType"""
        return _coin.SoSFColor_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFColor self, SoField field)"""
        return _coin.SoSFColor_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFColor self, SoField field) -> SbBool"""
        return _coin.SoSFColor_isSame(self, field)

    def getValue(self) -> "SbColor const &":
        r"""getValue(SoSFColor self) -> SbColor"""
        return _coin.SoSFColor_getValue(self)

    def __eq__(self, field: "SoSFColor") -> "int":
        r"""__eq__(SoSFColor self, SoSFColor field) -> int"""
        return _coin.SoSFColor___eq__(self, field)

    def __ne__(self, field: "SoSFColor") -> "int":
        r"""__ne__(SoSFColor self, SoSFColor field) -> int"""
        return _coin.SoSFColor___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFColor_initClass()

    def setHSVValue(self, *args) -> "void":
        r"""
        setHSVValue(SoSFColor self, float h, float s, float v)
        setHSVValue(SoSFColor self, float const [3] hsv)
        """
        return _coin.SoSFColor_setHSVValue(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFColor self, SbColor newvalue)
        setValue(SoSFColor self, SbVec3f vec)
        setValue(SoSFColor self, float red, float green, float blue)
        setValue(SoSFColor self, float const [3] rgb)
        setValue(SoSFColor self, SoSFColor other)
        """
        return _coin.SoSFColor_setValue(self, *args)

# Register SoSFColor in _coin:
_coin.SoSFColor_swigregister(SoSFColor)

def SoSFColor_createInstance() -> "void *":
    r"""SoSFColor_createInstance() -> void *"""
    return _coin.SoSFColor_createInstance()

def SoSFColor_getClassTypeId() -> "SoType":
    r"""SoSFColor_getClassTypeId() -> SoType"""
    return _coin.SoSFColor_getClassTypeId()

def SoSFColor_initClass() -> "void":
    r"""SoSFColor_initClass()"""
    return _coin.SoSFColor_initClass()

class SoReplacedElement(SoElement):
    r"""Proxy of C++ SoReplacedElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoReplacedElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoReplacedElement_getClassStackIndex()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoReplacedElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoReplacedElement self, SoState state)"""
        return _coin.SoReplacedElement_init(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoReplacedElement self, SoElement element) -> SbBool"""
        return _coin.SoReplacedElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoReplacedElement self) -> SoElement"""
        return _coin.SoReplacedElement_copyMatchInfo(self)

    def getNodeId(self) -> "SbUniqueId":
        r"""getNodeId(SoReplacedElement self) -> SbUniqueId"""
        return _coin.SoReplacedElement_getNodeId(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoReplacedElement self, FILE * file)"""
        return _coin.SoReplacedElement_output(self, file)

# Register SoReplacedElement in _coin:
_coin.SoReplacedElement_swigregister(SoReplacedElement)

def SoReplacedElement_getClassTypeId() -> "SoType":
    r"""SoReplacedElement_getClassTypeId() -> SoType"""
    return _coin.SoReplacedElement_getClassTypeId()

def SoReplacedElement_getClassStackIndex() -> "int":
    r"""SoReplacedElement_getClassStackIndex() -> int"""
    return _coin.SoReplacedElement_getClassStackIndex()

def SoReplacedElement_initClass() -> "void":
    r"""SoReplacedElement_initClass()"""
    return _coin.SoReplacedElement_initClass()

class SbVec3s(object):
    r"""Proxy of C++ SbVec3s class."""

    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):
        r"""
        __init__(SbVec3s self) -> SbVec3s
        __init__(SbVec3s self, short const [3] v) -> SbVec3s
        __init__(SbVec3s self, short x, short y, short z) -> SbVec3s
        __init__(SbVec3s self, SbVec3us const & v) -> SbVec3s
        __init__(SbVec3s self, SbVec3b v) -> SbVec3s
        __init__(SbVec3s self, SbVec3i32 v) -> SbVec3s
        __init__(SbVec3s self, SbVec3f v) -> SbVec3s
        __init__(SbVec3s self, SbVec3d v) -> SbVec3s
        """
        _coin.SbVec3s_swiginit(self, _coin.new_SbVec3s(*args))

    def setValue(self, *args) -> "SbVec3s &":
        r"""
        setValue(SbVec3s self, short const [3] v) -> SbVec3s
        setValue(SbVec3s self, short x, short y, short z) -> SbVec3s
        setValue(SbVec3s self, SbVec3us const & v) -> SbVec3s
        setValue(SbVec3s self, SbVec3b v) -> SbVec3s
        setValue(SbVec3s self, SbVec3i32 v) -> SbVec3s
        setValue(SbVec3s self, SbVec3f v) -> SbVec3s
        setValue(SbVec3s self, SbVec3d v) -> SbVec3s
        """
        return _coin.SbVec3s_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec3s self) -> short const
        getValue(SbVec3s self)
        """
        return _coin.SbVec3s_getValue(self, *args)

    def dot(self, v: "SbVec3s") -> "int32_t":
        r"""dot(SbVec3s self, SbVec3s v) -> int32_t"""
        return _coin.SbVec3s_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec3s self)"""
        return _coin.SbVec3s_negate(self)

    def __imul__(self, *args) -> "SbVec3s &":
        r"""
        __imul__(SbVec3s self, int d) -> SbVec3s
        __imul__(SbVec3s self, double d) -> SbVec3s
        """
        return _coin.SbVec3s___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec3s___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec3s") -> "SbVec3s &":
        r"""__iadd__(SbVec3s self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___iadd__(self, v)

    def __isub__(self, v: "SbVec3s") -> "SbVec3s &":
        r"""__isub__(SbVec3s self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___isub__(self, v)

    def __neg__(self) -> "SbVec3s":
        r"""__neg__(SbVec3s self) -> SbVec3s"""
        return _coin.SbVec3s___neg__(self)

    def toString(self) -> "SbString":
        r"""toString(SbVec3s self) -> SbString"""
        return _coin.SbVec3s_toString(self)

    def fromString(self, str: "SbString") -> "SbBool":
        r"""fromString(SbVec3s self, SbString str) -> SbBool"""
        return _coin.SbVec3s_fromString(self, str)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec3s self, FILE * fp)"""
        return _coin.SbVec3s_output(self, fp)

    def __add__(self, u: "SbVec3s") -> "SbVec3s":
        r"""__add__(SbVec3s self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___add__(self, u)

    def __sub__(self, u: "SbVec3s") -> "SbVec3s":
        r"""__sub__(SbVec3s self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___sub__(self, u)

    def __mul__(self, d: "double const") -> "SbVec3s":
        r"""__mul__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___mul__(self, d)

    def __rmul__(self, d: "double const") -> "SbVec3s":
        r"""__rmul__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___rmul__(self, d)

    def __div__(self, d: "double const") -> "SbVec3s":
        r"""__div__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___div__(self, d)

    def __truediv__(self, d: "double const") -> "SbVec3s":
        r"""__truediv__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___truediv__(self, d)

    def __eq__(self, u: "SbVec3s") -> "int":
        r"""__eq__(SbVec3s self, SbVec3s u) -> int"""
        return _coin.SbVec3s___eq__(self, u)

    def __nq__(self, u: "SbVec3s") -> "int":
        r"""__nq__(SbVec3s self, SbVec3s u) -> int"""
        return _coin.SbVec3s___nq__(self, u)

    def __getitem__(self, i: "int") -> "short":
        r"""__getitem__(SbVec3s self, int i) -> short"""
        return _coin.SbVec3s___getitem__(self, i)

    def __setitem__(self, i: "int", value: "short") -> "void":
        r"""__setitem__(SbVec3s self, int i, short value)"""
        return _coin.SbVec3s___setitem__(self, i, value)

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

    def __len__(self):
          return 3

    __swig_destroy__ = _coin.delete_SbVec3s

# Register SbVec3s in _coin:
_coin.SbVec3s_swigregister(SbVec3s)

class SoMultiTextureImageElement(SoElement):
    r"""Proxy of C++ SoMultiTextureImageElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureImageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureImageElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureImageElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMultiTextureImageElement_initClass()
    BLEND = _coin.SoMultiTextureImageElement_BLEND
    
    MODULATE = _coin.SoMultiTextureImageElement_MODULATE
    
    DECAL = _coin.SoMultiTextureImageElement_DECAL
    
    REPLACE = _coin.SoMultiTextureImageElement_REPLACE
    
    CLAMP = _coin.SoMultiTextureImageElement_CLAMP
    
    REPEAT = _coin.SoMultiTextureImageElement_REPEAT
    
    CLAMP_TO_BORDER = _coin.SoMultiTextureImageElement_CLAMP_TO_BORDER
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoMultiTextureImageElement self, SoState state)"""
        return _coin.SoMultiTextureImageElement_init(self, state)

    @staticmethod
    def setDefault(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
        r"""setDefault(SoState state, SoNode node, int const unit=0)"""
        return _coin.SoMultiTextureImageElement_setDefault(state, node, unit)

    @staticmethod
    def getBlendColor(state: "SoState", unit: "int const"=0) -> "SbColor const &":
        r"""getBlendColor(SoState state, int const unit=0) -> SbColor"""
        return _coin.SoMultiTextureImageElement_getBlendColor(state, unit)

    @staticmethod
    def getModel(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Model":
        r"""getModel(SoState state, int const unit=0) -> SoMultiTextureImageElement::Model"""
        return _coin.SoMultiTextureImageElement_getModel(state, unit)

    @staticmethod
    def getWrapS(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Wrap":
        r"""getWrapS(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapS(state, unit)

    @staticmethod
    def getWrapT(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Wrap":
        r"""getWrapT(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapT(state, unit)

    @staticmethod
    def getWrapR(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Wrap":
        r"""getWrapR(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapR(state, unit)

    @staticmethod
    def containsTransparency(state: "SoState") -> "SbBool":
        r"""containsTransparency(SoState state) -> SbBool"""
        return _coin.SoMultiTextureImageElement_containsTransparency(state)

    @staticmethod
    def getDefault(*args) -> "unsigned char const *":
        r"""
        getDefault(SbVec2s size, int & numComponents) -> unsigned char const
        getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
        """
        return _coin.SoMultiTextureImageElement_getDefault(*args)

    def push(self, state: "SoState") -> "void":
        r"""push(SoMultiTextureImageElement self, SoState state)"""
        return _coin.SoMultiTextureImageElement_push(self, state)

    def matches(self, elem: "SoElement") -> "SbBool":
        r"""matches(SoMultiTextureImageElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureImageElement_matches(self, elem)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoMultiTextureImageElement self) -> SoElement"""
        return _coin.SoMultiTextureImageElement_copyMatchInfo(self)

    def setElt(self, *args) -> "void":
        r"""
        setElt(SoMultiTextureImageElement self, int const unit, SbUniqueId const nodeid, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        setElt(SoMultiTextureImageElement self, int const unit, SbUniqueId const nodeid, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        """
        return _coin.SoMultiTextureImageElement_setElt(self, *args)

    def hasTransparency(self, unit: "int const"=0) -> "SbBool":
        r"""hasTransparency(SoMultiTextureImageElement self, int const unit=0) -> SbBool"""
        return _coin.SoMultiTextureImageElement_hasTransparency(self, unit)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, int const unit, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        set(SoState state, SoNode node, int const unit, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const wrapR, int const model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        """
        return _coin.SoMultiTextureImageElement_set(*args)

    @staticmethod
    def get(*args) -> "unsigned char const *":
        r"""
        get(SoState state, int const unit, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
        get(SoState state, int const unit, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
        get(SoState state, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
        get(SoState state, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
        get(SoState state, SbVec2s size, int & numComponents, int & wrapS, int & wrapT, int & model, SbColor blendColor) -> unsigned char const
        get(SoState state, SbVec3s size, int & numComponents, int & wrapS, int & wrapT, int & wrapR, int & model, SbColor blendColor) -> unsigned char const *
        """
        return _coin.SoMultiTextureImageElement_get(*args)

    @staticmethod
    def getImage(*args) -> "unsigned char const *":
        r"""
        getImage(SoState state, int const unit, SbVec2s size, int & numComponents) -> unsigned char const
        getImage(SoState state, int const unit, SbVec3s size, int & numComponents) -> unsigned char const
        getImage(SoState state, SbVec2s size, int & numComponents) -> unsigned char const
        getImage(SoState state, SbVec3s size, int & numComponents) -> unsigned char const *
        """
        return _coin.SoMultiTextureImageElement_getImage(*args)

# Register SoMultiTextureImageElement in _coin:
_coin.SoMultiTextureImageElement_swigregister(SoMultiTextureImageElement)

def SoMultiTextureImageElement_getClassTypeId() -> "SoType":
    r"""SoMultiTextureImageElement_getClassTypeId() -> SoType"""
    return _coin.SoMultiTextureImageElement_getClassTypeId()

def SoMultiTextureImageElement_getClassStackIndex() -> "int":
    r"""SoMultiTextureImageElement_getClassStackIndex() -> int"""
    return _coin.SoMultiTextureImageElement_getClassStackIndex()

def SoMultiTextureImageElement_createInstance() -> "void *":
    r"""SoMultiTextureImageElement_createInstance() -> void *"""
    return _coin.SoMultiTextureImageElement_createInstance()

def SoMultiTextureImageElement_initClass() -> "void":
    r"""SoMultiTextureImageElement_initClass()"""
    return _coin.SoMultiTextureImageElement_initClass()

def SoMultiTextureImageElement_setDefault(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
    r"""SoMultiTextureImageElement_setDefault(SoState state, SoNode node, int const unit=0)"""
    return _coin.SoMultiTextureImageElement_setDefault(state, node, unit)

def SoMultiTextureImageElement_getBlendColor(state: "SoState", unit: "int const"=0) -> "SbColor const &":
    r"""SoMultiTextureImageElement_getBlendColor(SoState state, int const unit=0) -> SbColor"""
    return _coin.SoMultiTextureImageElement_getBlendColor(state, unit)

def SoMultiTextureImageElement_getModel(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Model":
    r"""SoMultiTextureImageElement_getModel(SoState state, int const unit=0) -> SoMultiTextureImageElement::Model"""
    return _coin.SoMultiTextureImageElement_getModel(state, unit)

def SoMultiTextureImageElement_getWrapS(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Wrap":
    r"""SoMultiTextureImageElement_getWrapS(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"""
    return _coin.SoMultiTextureImageElement_getWrapS(state, unit)

def SoMultiTextureImageElement_getWrapT(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Wrap":
    r"""SoMultiTextureImageElement_getWrapT(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"""
    return _coin.SoMultiTextureImageElement_getWrapT(state, unit)

def SoMultiTextureImageElement_getWrapR(state: "SoState", unit: "int const"=0) -> "SoMultiTextureImageElement::Wrap":
    r"""SoMultiTextureImageElement_getWrapR(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"""
    return _coin.SoMultiTextureImageElement_getWrapR(state, unit)

def SoMultiTextureImageElement_containsTransparency(state: "SoState") -> "SbBool":
    r"""SoMultiTextureImageElement_containsTransparency(SoState state) -> SbBool"""
    return _coin.SoMultiTextureImageElement_containsTransparency(state)

def SoMultiTextureImageElement_getDefault(*args) -> "unsigned char const *":
    r"""
    SoMultiTextureImageElement_getDefault(SbVec2s size, int & numComponents) -> unsigned char const
    SoMultiTextureImageElement_getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
    """
    return _coin.SoMultiTextureImageElement_getDefault(*args)

def SoMultiTextureImageElement_set(*args) -> "void":
    r"""
    SoMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
    SoMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
    SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const model, SbColor blendColor)
    SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
    SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const wrapR, int const model, SbColor blendColor)
    SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
    """
    return _coin.SoMultiTextureImageElement_set(*args)

def SoMultiTextureImageElement_get(*args) -> "unsigned char const *":
    r"""
    SoMultiTextureImageElement_get(SoState state, int const unit, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
    SoMultiTextureImageElement_get(SoState state, int const unit, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
    SoMultiTextureImageElement_get(SoState state, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
    SoMultiTextureImageElement_get(SoState state, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
    SoMultiTextureImageElement_get(SoState state, SbVec2s size, int & numComponents, int & wrapS, int & wrapT, int & model, SbColor blendColor) -> unsigned char const
    SoMultiTextureImageElement_get(SoState state, SbVec3s size, int & numComponents, int & wrapS, int & wrapT, int & wrapR, int & model, SbColor blendColor) -> unsigned char const *
    """
    return _coin.SoMultiTextureImageElement_get(*args)

def SoMultiTextureImageElement_getImage(*args) -> "unsigned char const *":
    r"""
    SoMultiTextureImageElement_getImage(SoState state, int const unit, SbVec2s size, int & numComponents) -> unsigned char const
    SoMultiTextureImageElement_getImage(SoState state, int const unit, SbVec3s size, int & numComponents) -> unsigned char const
    SoMultiTextureImageElement_getImage(SoState state, SbVec2s size, int & numComponents) -> unsigned char const
    SoMultiTextureImageElement_getImage(SoState state, SbVec3s size, int & numComponents) -> unsigned char const *
    """
    return _coin.SoMultiTextureImageElement_getImage(*args)

class SoTexture2(SoTexture):
    r"""Proxy of C++ SoTexture2 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture2_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTexture2 self) -> SoType"""
        return _coin.SoTexture2_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTexture2_initClass()

    def __init__(self):
        r"""__init__(SoTexture2 self) -> SoTexture2"""
        _coin.SoTexture2_swiginit(self, _coin.new_SoTexture2())
    MODULATE = _coin.SoTexture2_MODULATE
    
    DECAL = _coin.SoTexture2_DECAL
    
    BLEND = _coin.SoTexture2_BLEND
    
    REPLACE = _coin.SoTexture2_REPLACE
    
    REPEAT = _coin.SoTexture2_REPEAT
    
    CLAMP = _coin.SoTexture2_CLAMP
    
    filename = property(_coin.SoTexture2_filename_get, _coin.SoTexture2_filename_set, doc=r"""filename : SoSFString""")
    image = property(_coin.SoTexture2_image_get, _coin.SoTexture2_image_set, doc=r"""image : SoSFImage""")
    wrapS = property(_coin.SoTexture2_wrapS_get, _coin.SoTexture2_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoTexture2_wrapT_get, _coin.SoTexture2_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoTexture2_model_get, _coin.SoTexture2_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoTexture2_blendColor_get, _coin.SoTexture2_blendColor_set, doc=r"""blendColor : SoSFColor""")
    enableCompressedTexture = property(_coin.SoTexture2_enableCompressedTexture_get, _coin.SoTexture2_enableCompressedTexture_set, doc=r"""enableCompressedTexture : SoSFBool""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTexture2 self, SoAction action)"""
        return _coin.SoTexture2_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTexture2 self, SoGLRenderAction action)"""
        return _coin.SoTexture2_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTexture2 self, SoCallbackAction action)"""
        return _coin.SoTexture2_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoTexture2 self, SoRayPickAction action)"""
        return _coin.SoTexture2_rayPick(self, action)

    @staticmethod
    def readImage(fname: "SbString", w: "int &", h: "int &", nc: "int &", bytes: "unsigned char *&") -> "SbBool":
        r"""readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
        return _coin.SoTexture2_readImage(fname, w, h, nc, bytes)

# Register SoTexture2 in _coin:
_coin.SoTexture2_swigregister(SoTexture2)

def SoTexture2_getClassTypeId() -> "SoType":
    r"""SoTexture2_getClassTypeId() -> SoType"""
    return _coin.SoTexture2_getClassTypeId()

def SoTexture2_initClass() -> "void":
    r"""SoTexture2_initClass()"""
    return _coin.SoTexture2_initClass()

def SoTexture2_readImage(fname: "SbString", w: "int &", h: "int &", nc: "int &", bytes: "unsigned char *&") -> "SbBool":
    r"""SoTexture2_readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
    return _coin.SoTexture2_readImage(fname, w, h, nc, bytes)

class SoTextureCoordinateBindingElement(SoInt32Element):
    r"""Proxy of C++ SoTextureCoordinateBindingElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureCoordinateBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTextureCoordinateBindingElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateBindingElement_initClass()
    PER_VERTEX = _coin.SoTextureCoordinateBindingElement_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBindingElement_PER_VERTEX_INDEXED
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoTextureCoordinateBindingElement self, SoState state)"""
        return _coin.SoTextureCoordinateBindingElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoTextureCoordinateBindingElement::Binding const binding)
        set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)
        """
        return _coin.SoTextureCoordinateBindingElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoTextureCoordinateBindingElement::Binding":
        r"""get(SoState state) -> SoTextureCoordinateBindingElement::Binding"""
        return _coin.SoTextureCoordinateBindingElement_get(state)

    @staticmethod
    def getDefault() -> "SoTextureCoordinateBindingElement::Binding":
        r"""getDefault() -> SoTextureCoordinateBindingElement::Binding"""
        return _coin.SoTextureCoordinateBindingElement_getDefault()

# Register SoTextureCoordinateBindingElement in _coin:
_coin.SoTextureCoordinateBindingElement_swigregister(SoTextureCoordinateBindingElement)

def SoTextureCoordinateBindingElement_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateBindingElement_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateBindingElement_getClassTypeId()

def SoTextureCoordinateBindingElement_getClassStackIndex() -> "int":
    r"""SoTextureCoordinateBindingElement_getClassStackIndex() -> int"""
    return _coin.SoTextureCoordinateBindingElement_getClassStackIndex()

def SoTextureCoordinateBindingElement_createInstance() -> "void *":
    r"""SoTextureCoordinateBindingElement_createInstance() -> void *"""
    return _coin.SoTextureCoordinateBindingElement_createInstance()

def SoTextureCoordinateBindingElement_initClass() -> "void":
    r"""SoTextureCoordinateBindingElement_initClass()"""
    return _coin.SoTextureCoordinateBindingElement_initClass()

def SoTextureCoordinateBindingElement_set(*args) -> "void":
    r"""
    SoTextureCoordinateBindingElement_set(SoState state, SoNode node, SoTextureCoordinateBindingElement::Binding const binding)
    SoTextureCoordinateBindingElement_set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)
    """
    return _coin.SoTextureCoordinateBindingElement_set(*args)

def SoTextureCoordinateBindingElement_get(state: "SoState") -> "SoTextureCoordinateBindingElement::Binding":
    r"""SoTextureCoordinateBindingElement_get(SoState state) -> SoTextureCoordinateBindingElement::Binding"""
    return _coin.SoTextureCoordinateBindingElement_get(state)

def SoTextureCoordinateBindingElement_getDefault() -> "SoTextureCoordinateBindingElement::Binding":
    r"""SoTextureCoordinateBindingElement_getDefault() -> SoTextureCoordinateBindingElement::Binding"""
    return _coin.SoTextureCoordinateBindingElement_getDefault()

class SoTextureCoordinateBinding(SoNode):
    r"""Proxy of C++ SoTextureCoordinateBinding class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateBinding_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateBinding self) -> SoType"""
        return _coin.SoTextureCoordinateBinding_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateBinding_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateBinding self) -> SoTextureCoordinateBinding"""
        _coin.SoTextureCoordinateBinding_swiginit(self, _coin.new_SoTextureCoordinateBinding())
    PER_VERTEX = _coin.SoTextureCoordinateBinding_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBinding_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoTextureCoordinateBinding_DEFAULT
    
    value = property(_coin.SoTextureCoordinateBinding_value_get, _coin.SoTextureCoordinateBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateBinding self, SoAction action)"""
        return _coin.SoTextureCoordinateBinding_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateBinding self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateBinding_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateBinding self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateBinding_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateBinding self, SoPickAction action)"""
        return _coin.SoTextureCoordinateBinding_pick(self, action)

# Register SoTextureCoordinateBinding in _coin:
_coin.SoTextureCoordinateBinding_swigregister(SoTextureCoordinateBinding)

def SoTextureCoordinateBinding_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateBinding_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateBinding_getClassTypeId()

def SoTextureCoordinateBinding_initClass() -> "void":
    r"""SoTextureCoordinateBinding_initClass()"""
    return _coin.SoTextureCoordinateBinding_initClass()

class SoTransformation(SoNode):
    r"""Proxy of C++ SoTransformation class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformation self) -> SoType"""
        return _coin.SoTransformation_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformation_initClass()

# Register SoTransformation in _coin:
_coin.SoTransformation_swigregister(SoTransformation)

def SoTransformation_getClassTypeId() -> "SoType":
    r"""SoTransformation_getClassTypeId() -> SoType"""
    return _coin.SoTransformation_getClassTypeId()

def SoTransformation_initClass() -> "void":
    r"""SoTransformation_initClass()"""
    return _coin.SoTransformation_initClass()

class SoUnits(SoTransformation):
    r"""Proxy of C++ SoUnits class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoUnits_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoUnits self) -> SoType"""
        return _coin.SoUnits_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoUnits_initClass()

    def __init__(self):
        r"""__init__(SoUnits self) -> SoUnits"""
        _coin.SoUnits_swiginit(self, _coin.new_SoUnits())
    METERS = _coin.SoUnits_METERS
    
    CENTIMETERS = _coin.SoUnits_CENTIMETERS
    
    MILLIMETERS = _coin.SoUnits_MILLIMETERS
    
    MICROMETERS = _coin.SoUnits_MICROMETERS
    
    MICRONS = _coin.SoUnits_MICRONS
    
    NANOMETERS = _coin.SoUnits_NANOMETERS
    
    ANGSTROMS = _coin.SoUnits_ANGSTROMS
    
    KILOMETERS = _coin.SoUnits_KILOMETERS
    
    FEET = _coin.SoUnits_FEET
    
    INCHES = _coin.SoUnits_INCHES
    
    POINTS = _coin.SoUnits_POINTS
    
    YARDS = _coin.SoUnits_YARDS
    
    MILES = _coin.SoUnits_MILES
    
    NAUTICAL_MILES = _coin.SoUnits_NAUTICAL_MILES
    
    units = property(_coin.SoUnits_units_get, _coin.SoUnits_units_set, doc=r"""units : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoUnits self, SoAction action)"""
        return _coin.SoUnits_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoUnits self, SoCallbackAction action)"""
        return _coin.SoUnits_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoUnits self, SoGetBoundingBoxAction action)"""
        return _coin.SoUnits_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoUnits self, SoGetMatrixAction action)"""
        return _coin.SoUnits_getMatrix(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoUnits self, SoGLRenderAction action)"""
        return _coin.SoUnits_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoUnits self, SoPickAction action)"""
        return _coin.SoUnits_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoUnits self, SoGetPrimitiveCountAction action)"""
        return _coin.SoUnits_getPrimitiveCount(self, action)

# Register SoUnits in _coin:
_coin.SoUnits_swigregister(SoUnits)

def SoUnits_getClassTypeId() -> "SoType":
    r"""SoUnits_getClassTypeId() -> SoType"""
    return _coin.SoUnits_getClassTypeId()

def SoUnits_initClass() -> "void":
    r"""SoUnits_initClass()"""
    return _coin.SoUnits_initClass()

class SoCallbackAction(SoAction):
    r"""Proxy of C++ SoCallbackAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCallbackAction self) -> SoType"""
        return _coin.SoCallbackAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCallbackAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoCallbackAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoCallbackAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCallbackAction_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoCallbackAction self) -> SoCallbackAction
        __init__(SoCallbackAction self, SbViewportRegion vp) -> SoCallbackAction
        """
        _coin.SoCallbackAction_swiginit(self, _coin.new_SoCallbackAction(*args))
    __swig_destroy__ = _coin.delete_SoCallbackAction

    def setViewportRegion(self, vp: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoCallbackAction self, SbViewportRegion vp)"""
        return _coin.SoCallbackAction_setViewportRegion(self, vp)
    CONTINUE = _coin.SoCallbackAction_CONTINUE
    
    ABORT = _coin.SoCallbackAction_ABORT
    
    PRUNE = _coin.SoCallbackAction_PRUNE
    

    def getDecimationType(self) -> "SoDecimationTypeElement::Type":
        r"""getDecimationType(SoCallbackAction self) -> SoDecimationTypeElement::Type"""
        return _coin.SoCallbackAction_getDecimationType(self)

    def getDecimationPercentage(self) -> "float":
        r"""getDecimationPercentage(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getDecimationPercentage(self)

    def getComplexity(self) -> "float":
        r"""getComplexity(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getComplexity(self)

    def getComplexityType(self) -> "SoComplexity::Type":
        r"""getComplexityType(SoCallbackAction self) -> SoComplexity::Type"""
        return _coin.SoCallbackAction_getComplexityType(self)

    def getNumCoordinates(self) -> "int32_t":
        r"""getNumCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumCoordinates(self)

    def getCoordinate3(self, index: "int const") -> "SbVec3f const &":
        r"""getCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getCoordinate3(self, index)

    def getCoordinate4(self, index: "int const") -> "SbVec4f const &":
        r"""getCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
        return _coin.SoCallbackAction_getCoordinate4(self, index)

    def getDrawStyle(self) -> "SoDrawStyle::Style":
        r"""getDrawStyle(SoCallbackAction self) -> SoDrawStyle::Style"""
        return _coin.SoCallbackAction_getDrawStyle(self)

    def getLinePattern(self) -> "unsigned short":
        r"""getLinePattern(SoCallbackAction self) -> unsigned short"""
        return _coin.SoCallbackAction_getLinePattern(self)

    def getLineWidth(self) -> "float":
        r"""getLineWidth(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getLineWidth(self)

    def getPointSize(self) -> "float":
        r"""getPointSize(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getPointSize(self)

    def getFontName(self) -> "SbName const &":
        r"""getFontName(SoCallbackAction self) -> SbName"""
        return _coin.SoCallbackAction_getFontName(self)

    def getFontSize(self) -> "float":
        r"""getFontSize(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getFontSize(self)

    def getLightModel(self) -> "SoLightModel::Model":
        r"""getLightModel(SoCallbackAction self) -> SoLightModel::Model"""
        return _coin.SoCallbackAction_getLightModel(self)

    def getLightAttenuation(self) -> "SbVec3f const &":
        r"""getLightAttenuation(SoCallbackAction self) -> SbVec3f"""
        return _coin.SoCallbackAction_getLightAttenuation(self)

    def getMaterialBinding(self) -> "SoMaterialBinding::Binding":
        r"""getMaterialBinding(SoCallbackAction self) -> SoMaterialBinding::Binding"""
        return _coin.SoCallbackAction_getMaterialBinding(self)

    def getNumNormals(self) -> "uint32_t":
        r"""getNumNormals(SoCallbackAction self) -> uint32_t"""
        return _coin.SoCallbackAction_getNumNormals(self)

    def getNormal(self, index: "int const") -> "SbVec3f const &":
        r"""getNormal(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getNormal(self, index)

    def getNormalBinding(self) -> "SoNormalBinding::Binding":
        r"""getNormalBinding(SoCallbackAction self) -> SoNormalBinding::Binding"""
        return _coin.SoCallbackAction_getNormalBinding(self)

    def getNumProfileCoordinates(self) -> "int32_t":
        r"""getNumProfileCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumProfileCoordinates(self)

    def getProfileCoordinate2(self, index: "int const") -> "SbVec2f const &":
        r"""getProfileCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
        return _coin.SoCallbackAction_getProfileCoordinate2(self, index)

    def getProfileCoordinate3(self, index: "int const") -> "SbVec3f const &":
        r"""getProfileCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getProfileCoordinate3(self, index)

    def getProfile(self) -> "SoNodeList const &":
        r"""getProfile(SoCallbackAction self) -> SoNodeList"""
        return _coin.SoCallbackAction_getProfile(self)

    def getVertexOrdering(self) -> "SoShapeHints::VertexOrdering":
        r"""getVertexOrdering(SoCallbackAction self) -> SoShapeHints::VertexOrdering"""
        return _coin.SoCallbackAction_getVertexOrdering(self)

    def getShapeType(self) -> "SoShapeHints::ShapeType":
        r"""getShapeType(SoCallbackAction self) -> SoShapeHints::ShapeType"""
        return _coin.SoCallbackAction_getShapeType(self)

    def getFaceType(self) -> "SoShapeHints::FaceType":
        r"""getFaceType(SoCallbackAction self) -> SoShapeHints::FaceType"""
        return _coin.SoCallbackAction_getFaceType(self)

    def getCreaseAngle(self) -> "float":
        r"""getCreaseAngle(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getCreaseAngle(self)

    def getNumTextureCoordinates(self) -> "int32_t":
        r"""getNumTextureCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumTextureCoordinates(self)

    def getTextureCoordinate2(self, index: "int const") -> "SbVec2f const &":
        r"""getTextureCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
        return _coin.SoCallbackAction_getTextureCoordinate2(self, index)

    def getTextureCoordinate3(self, index: "int const") -> "SbVec3f const &":
        r"""getTextureCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getTextureCoordinate3(self, index)

    def getTextureCoordinate4(self, index: "int const") -> "SbVec4f const &":
        r"""getTextureCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
        return _coin.SoCallbackAction_getTextureCoordinate4(self, index)

    def getTextureCoordinateBinding(self) -> "SoTextureCoordinateBinding::Binding":
        r"""getTextureCoordinateBinding(SoCallbackAction self) -> SoTextureCoordinateBinding::Binding"""
        return _coin.SoCallbackAction_getTextureCoordinateBinding(self)

    def getTextureBlendColor(self) -> "SbColor const &":
        r"""getTextureBlendColor(SoCallbackAction self) -> SbColor"""
        return _coin.SoCallbackAction_getTextureBlendColor(self)

    def getTextureImage(self, *args) -> "unsigned char const *":
        r"""
        getTextureImage(SoCallbackAction self, SbVec2s size, int & numcomps) -> unsigned char const
        getTextureImage(SoCallbackAction self, SbVec3s size, int & numcomps) -> unsigned char const *
        """
        return _coin.SoCallbackAction_getTextureImage(self, *args)

    def getTextureMatrix(self) -> "SbMatrix const &":
        r"""getTextureMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getTextureMatrix(self)

    def getTextureModel(self) -> "SoTexture2::Model":
        r"""getTextureModel(SoCallbackAction self) -> SoTexture2::Model"""
        return _coin.SoCallbackAction_getTextureModel(self)

    def getTextureWrapS(self) -> "SoTexture2::Wrap":
        r"""getTextureWrapS(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapS(self)

    def getTextureWrapT(self) -> "SoTexture2::Wrap":
        r"""getTextureWrapT(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapT(self)

    def getTextureWrapR(self) -> "SoTexture2::Wrap":
        r"""getTextureWrapR(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapR(self)

    def getModelMatrix(self) -> "SbMatrix const &":
        r"""getModelMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getModelMatrix(self)

    def getUnits(self) -> "SoUnits::Units":
        r"""getUnits(SoCallbackAction self) -> SoUnits::Units"""
        return _coin.SoCallbackAction_getUnits(self)

    def getFocalDistance(self) -> "float":
        r"""getFocalDistance(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getFocalDistance(self)

    def getProjectionMatrix(self) -> "SbMatrix const &":
        r"""getProjectionMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getProjectionMatrix(self)

    def getViewingMatrix(self) -> "SbMatrix const &":
        r"""getViewingMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getViewingMatrix(self)

    def getViewVolume(self) -> "SbViewVolume const &":
        r"""getViewVolume(SoCallbackAction self) -> SbViewVolume"""
        return _coin.SoCallbackAction_getViewVolume(self)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoCallbackAction self) -> SbViewportRegion"""
        return _coin.SoCallbackAction_getViewportRegion(self)

    def getPickStyle(self) -> "SoPickStyle::Style":
        r"""getPickStyle(SoCallbackAction self) -> SoPickStyle::Style"""
        return _coin.SoCallbackAction_getPickStyle(self)

    def getSwitch(self) -> "int32_t":
        r"""getSwitch(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getSwitch(self)

    def getCurrentResponse(self) -> "SoCallbackAction::Response":
        r"""getCurrentResponse(SoCallbackAction self) -> SoCallbackAction::Response"""
        return _coin.SoCallbackAction_getCurrentResponse(self)

    def invokePreCallbacks(self, node: "SoNode") -> "void":
        r"""invokePreCallbacks(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_invokePreCallbacks(self, node)

    def invokePostCallbacks(self, node: "SoNode") -> "void":
        r"""invokePostCallbacks(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_invokePostCallbacks(self, node)

    def invokeTriangleCallbacks(self, shape: "SoShape", v1: "SoPrimitiveVertex", v2: "SoPrimitiveVertex", v3: "SoPrimitiveVertex") -> "void":
        r"""invokeTriangleCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2, SoPrimitiveVertex v3)"""
        return _coin.SoCallbackAction_invokeTriangleCallbacks(self, shape, v1, v2, v3)

    def invokeLineSegmentCallbacks(self, shape: "SoShape", v1: "SoPrimitiveVertex", v2: "SoPrimitiveVertex") -> "void":
        r"""invokeLineSegmentCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2)"""
        return _coin.SoCallbackAction_invokeLineSegmentCallbacks(self, shape, v1, v2)

    def invokePointCallbacks(self, shape: "SoShape", v: "SoPrimitiveVertex") -> "void":
        r"""invokePointCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v)"""
        return _coin.SoCallbackAction_invokePointCallbacks(self, shape, v)

    def shouldGeneratePrimitives(self, shape: "SoShape") -> "SbBool":
        r"""shouldGeneratePrimitives(SoCallbackAction self, SoShape shape) -> SbBool"""
        return _coin.SoCallbackAction_shouldGeneratePrimitives(self, shape)

    def getCurPathTail(self) -> "SoNode *":
        r"""getCurPathTail(SoCallbackAction self) -> SoNode"""
        return _coin.SoCallbackAction_getCurPathTail(self)

    def setCurrentNode(self, node: "SoNode") -> "void":
        r"""setCurrentNode(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_setCurrentNode(self, node)

    def setCallbackAll(self, callbackall: "SbBool") -> "void":
        r"""setCallbackAll(SoCallbackAction self, SbBool callbackall)"""
        return _coin.SoCallbackAction_setCallbackAll(self, callbackall)

    def isCallbackAll(self) -> "SbBool":
        r"""isCallbackAll(SoCallbackAction self) -> SbBool"""
        return _coin.SoCallbackAction_isCallbackAll(self)

    def getMaterial(self, index: "int const"=0) -> "PyObject *":
        r"""getMaterial(SoCallbackAction self, int const index=0) -> PyObject"""
        return _coin.SoCallbackAction_getMaterial(self, index)

    def addPreCallback(self, *args) -> "void":
        r"""
        addPreCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPreCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPreCallback(self, *args)

    def addPostCallback(self, *args) -> "void":
        r"""
        addPostCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPostCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPostCallback(self, *args)

    def addPreTailCallback(self, *args) -> "void":
        r"""
        addPreTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPreTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPreTailCallback(self, *args)

    def addPostTailCallback(self, *args) -> "void":
        r"""
        addPostTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPostTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPostTailCallback(self, *args)

    def addTriangleCallback(self, *args) -> "void":
        r"""
        addTriangleCallback(SoCallbackAction self, SoType type, SoTriangleCB * cb, void * userdata)
        addTriangleCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addTriangleCallback(self, *args)

    def addLineSegmentCallback(self, *args) -> "void":
        r"""
        addLineSegmentCallback(SoCallbackAction self, SoType type, SoLineSegmentCB * cb, void * userdata)
        addLineSegmentCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addLineSegmentCallback(self, *args)

    def addPointCallback(self, *args) -> "void":
        r"""
        addPointCallback(SoCallbackAction self, SoType type, SoPointCB * cb, void * userdata)
        addPointCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPointCallback(self, *args)

# Register SoCallbackAction in _coin:
_coin.SoCallbackAction_swigregister(SoCallbackAction)

def SoCallbackAction_getClassTypeId() -> "SoType":
    r"""SoCallbackAction_getClassTypeId() -> SoType"""
    return _coin.SoCallbackAction_getClassTypeId()

def SoCallbackAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoCallbackAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoCallbackAction_addMethod(type, method)

def SoCallbackAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoCallbackAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoCallbackAction_enableElement(type, stackindex)

def SoCallbackAction_initClass() -> "void":
    r"""SoCallbackAction_initClass()"""
    return _coin.SoCallbackAction_initClass()

class SbViewportRegion(object):
    r"""Proxy of C++ SbViewportRegion class."""

    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):
        r"""
        __init__(SbViewportRegion self) -> SbViewportRegion
        __init__(SbViewportRegion self, short width, short height) -> SbViewportRegion
        __init__(SbViewportRegion self, SbVec2s winSize) -> SbViewportRegion
        __init__(SbViewportRegion self, SbViewportRegion vpReg) -> SbViewportRegion
        """
        _coin.SbViewportRegion_swiginit(self, _coin.new_SbViewportRegion(*args))

    def setWindowSize(self, *args) -> "void":
        r"""
        setWindowSize(SbViewportRegion self, short width, short height)
        setWindowSize(SbViewportRegion self, SbVec2s winSize)
        """
        return _coin.SbViewportRegion_setWindowSize(self, *args)

    def setViewport(self, *args) -> "void":
        r"""
        setViewport(SbViewportRegion self, float left, float bottom, float width, float height)
        setViewport(SbViewportRegion self, SbVec2f origin, SbVec2f size)
        """
        return _coin.SbViewportRegion_setViewport(self, *args)

    def setViewportPixels(self, *args) -> "void":
        r"""
        setViewportPixels(SbViewportRegion self, short left, short bottom, short width, short height)
        setViewportPixels(SbViewportRegion self, SbVec2s origin, SbVec2s size)
        """
        return _coin.SbViewportRegion_setViewportPixels(self, *args)

    def getWindowSize(self) -> "SbVec2s const &":
        r"""getWindowSize(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getWindowSize(self)

    def getViewportOrigin(self) -> "SbVec2f const &":
        r"""getViewportOrigin(SbViewportRegion self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportOrigin(self)

    def getViewportOriginPixels(self) -> "SbVec2s const &":
        r"""getViewportOriginPixels(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportOriginPixels(self)

    def getViewportSize(self) -> "SbVec2f const &":
        r"""getViewportSize(SbViewportRegion self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportSize(self)

    def getViewportSizePixels(self) -> "SbVec2s const &":
        r"""getViewportSizePixels(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportSizePixels(self)

    def getViewportAspectRatio(self) -> "float":
        r"""getViewportAspectRatio(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getViewportAspectRatio(self)

    def scaleWidth(self, ratio: "float") -> "void":
        r"""scaleWidth(SbViewportRegion self, float ratio)"""
        return _coin.SbViewportRegion_scaleWidth(self, ratio)

    def scaleHeight(self, ratio: "float") -> "void":
        r"""scaleHeight(SbViewportRegion self, float ratio)"""
        return _coin.SbViewportRegion_scaleHeight(self, ratio)

    def setPixelsPerInch(self, ppi: "float") -> "void":
        r"""setPixelsPerInch(SbViewportRegion self, float ppi)"""
        return _coin.SbViewportRegion_setPixelsPerInch(self, ppi)

    def getPixelsPerInch(self) -> "float":
        r"""getPixelsPerInch(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerInch(self)

    def getPixelsPerPoint(self) -> "float":
        r"""getPixelsPerPoint(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerPoint(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbViewportRegion self, FILE * file)"""
        return _coin.SbViewportRegion_output(self, file)

    def __eq__(self, u: "SbViewportRegion") -> "int":
        r"""__eq__(SbViewportRegion self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___eq__(self, u)

    def __ne__(self, u: "SbViewportRegion") -> "int":
        r"""__ne__(SbViewportRegion self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbViewportRegion

# Register SbViewportRegion in _coin:
_coin.SbViewportRegion_swigregister(SbViewportRegion)

class SoGLRenderAction(SoAction):
    r"""Proxy of C++ SoGLRenderAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGLRenderAction self) -> SoType"""
        return _coin.SoGLRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGLRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGLRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLRenderAction_initClass()

    def __init__(self, viewportregion: "SbViewportRegion"):
        r"""__init__(SoGLRenderAction self, SbViewportRegion viewportregion) -> SoGLRenderAction"""
        _coin.SoGLRenderAction_swiginit(self, _coin.new_SoGLRenderAction(viewportregion))
    __swig_destroy__ = _coin.delete_SoGLRenderAction
    SCREEN_DOOR = _coin.SoGLRenderAction_SCREEN_DOOR
    
    ADD = _coin.SoGLRenderAction_ADD
    
    DELAYED_ADD = _coin.SoGLRenderAction_DELAYED_ADD
    
    SORTED_OBJECT_ADD = _coin.SoGLRenderAction_SORTED_OBJECT_ADD
    
    BLEND = _coin.SoGLRenderAction_BLEND
    
    DELAYED_BLEND = _coin.SoGLRenderAction_DELAYED_BLEND
    
    SORTED_OBJECT_BLEND = _coin.SoGLRenderAction_SORTED_OBJECT_BLEND
    
    SORTED_OBJECT_SORTED_TRIANGLE_ADD = _coin.SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_ADD
    
    SORTED_OBJECT_SORTED_TRIANGLE_BLEND = _coin.SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_BLEND
    
    NONE = _coin.SoGLRenderAction_NONE
    
    SORTED_LAYERS_BLEND = _coin.SoGLRenderAction_SORTED_LAYERS_BLEND
    
    ONE_PASS = _coin.SoGLRenderAction_ONE_PASS
    
    NONSOLID_SEPARATE_BACKFACE_PASS = _coin.SoGLRenderAction_NONSOLID_SEPARATE_BACKFACE_PASS
    
    CONTINUE = _coin.SoGLRenderAction_CONTINUE
    
    ABORT = _coin.SoGLRenderAction_ABORT
    
    PRUNE = _coin.SoGLRenderAction_PRUNE
    
    DELAY = _coin.SoGLRenderAction_DELAY
    
    BBOX_CENTER = _coin.SoGLRenderAction_BBOX_CENTER
    
    BBOX_CLOSEST_CORNER = _coin.SoGLRenderAction_BBOX_CLOSEST_CORNER
    
    BBOX_FARTHEST_CORNER = _coin.SoGLRenderAction_BBOX_FARTHEST_CORNER
    
    CUSTOM_CALLBACK = _coin.SoGLRenderAction_CUSTOM_CALLBACK
    

    def setViewportRegion(self, newregion: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoGLRenderAction self, SbViewportRegion newregion)"""
        return _coin.SoGLRenderAction_setViewportRegion(self, newregion)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoGLRenderAction self) -> SbViewportRegion"""
        return _coin.SoGLRenderAction_getViewportRegion(self)

    def setUpdateArea(self, origin: "SbVec2f", size: "SbVec2f") -> "void":
        r"""setUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_setUpdateArea(self, origin, size)

    def getUpdateArea(self, origin: "SbVec2f", size: "SbVec2f") -> "void":
        r"""getUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_getUpdateArea(self, origin, size)

    def getAbortCallback(self, func_out: "SoGLRenderAction::SoGLRenderAbortCB *&", userdata_out: "void *&") -> "void":
        r"""getAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *& func_out, void *& userdata_out)"""
        return _coin.SoGLRenderAction_getAbortCallback(self, func_out, userdata_out)

    def setTransparencyType(self, type: "SoGLRenderAction::TransparencyType const") -> "void":
        r"""setTransparencyType(SoGLRenderAction self, SoGLRenderAction::TransparencyType const type)"""
        return _coin.SoGLRenderAction_setTransparencyType(self, type)

    def getTransparencyType(self) -> "SoGLRenderAction::TransparencyType":
        r"""getTransparencyType(SoGLRenderAction self) -> SoGLRenderAction::TransparencyType"""
        return _coin.SoGLRenderAction_getTransparencyType(self)

    def setTransparentDelayedObjectRenderType(self, type: "SoGLRenderAction::TransparentDelayedObjectRenderType") -> "void":
        r"""setTransparentDelayedObjectRenderType(SoGLRenderAction self, SoGLRenderAction::TransparentDelayedObjectRenderType type)"""
        return _coin.SoGLRenderAction_setTransparentDelayedObjectRenderType(self, type)

    def getTransparentDelayedObjectRenderType(self) -> "SoGLRenderAction::TransparentDelayedObjectRenderType":
        r"""getTransparentDelayedObjectRenderType(SoGLRenderAction self) -> SoGLRenderAction::TransparentDelayedObjectRenderType"""
        return _coin.SoGLRenderAction_getTransparentDelayedObjectRenderType(self)

    def setSmoothing(self, smooth: "SbBool const") -> "void":
        r"""setSmoothing(SoGLRenderAction self, SbBool const smooth)"""
        return _coin.SoGLRenderAction_setSmoothing(self, smooth)

    def isSmoothing(self) -> "SbBool":
        r"""isSmoothing(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isSmoothing(self)

    def setNumPasses(self, num: "int const") -> "void":
        r"""setNumPasses(SoGLRenderAction self, int const num)"""
        return _coin.SoGLRenderAction_setNumPasses(self, num)

    def getNumPasses(self) -> "int":
        r"""getNumPasses(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getNumPasses(self)

    def setPassUpdate(self, flag: "SbBool const") -> "void":
        r"""setPassUpdate(SoGLRenderAction self, SbBool const flag)"""
        return _coin.SoGLRenderAction_setPassUpdate(self, flag)

    def isPassUpdate(self) -> "SbBool":
        r"""isPassUpdate(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isPassUpdate(self)

    def setCacheContext(self, context: "uint32_t const") -> "void":
        r"""setCacheContext(SoGLRenderAction self, uint32_t const context)"""
        return _coin.SoGLRenderAction_setCacheContext(self, context)

    def getCacheContext(self) -> "uint32_t":
        r"""getCacheContext(SoGLRenderAction self) -> uint32_t"""
        return _coin.SoGLRenderAction_getCacheContext(self)

    def addDelayedPath(self, path: "SoPath") -> "void":
        r"""addDelayedPath(SoGLRenderAction self, SoPath path)"""
        return _coin.SoGLRenderAction_addDelayedPath(self, path)

    def isRenderingDelayedPaths(self) -> "SbBool":
        r"""isRenderingDelayedPaths(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingDelayedPaths(self)

    def handleTransparency(self, istransparent: "SbBool"=0) -> "SbBool":
        r"""handleTransparency(SoGLRenderAction self, SbBool istransparent=0) -> SbBool"""
        return _coin.SoGLRenderAction_handleTransparency(self, istransparent)

    def setCurPass(self, passnum: "int const", numpasses: "int const") -> "void":
        r"""setCurPass(SoGLRenderAction self, int const passnum, int const numpasses)"""
        return _coin.SoGLRenderAction_setCurPass(self, passnum, numpasses)

    def getCurPass(self) -> "int":
        r"""getCurPass(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getCurPass(self)

    def abortNow(self) -> "SbBool":
        r"""abortNow(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_abortNow(self)

    def setRenderingIsRemote(self, isremote: "SbBool") -> "void":
        r"""setRenderingIsRemote(SoGLRenderAction self, SbBool isremote)"""
        return _coin.SoGLRenderAction_setRenderingIsRemote(self, isremote)

    def getRenderingIsRemote(self) -> "SbBool":
        r"""getRenderingIsRemote(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_getRenderingIsRemote(self)

    def invalidateState(self) -> "void":
        r"""invalidateState(SoGLRenderAction self)"""
        return _coin.SoGLRenderAction_invalidateState(self)

    def setSortedLayersNumPasses(self, num: "int") -> "void":
        r"""setSortedLayersNumPasses(SoGLRenderAction self, int num)"""
        return _coin.SoGLRenderAction_setSortedLayersNumPasses(self, num)

    def getSortedLayersNumPasses(self) -> "int":
        r"""getSortedLayersNumPasses(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getSortedLayersNumPasses(self)

    def setSortedObjectOrderStrategy(self, strategy: "SoGLRenderAction::SortedObjectOrderStrategy const", cb: "SoGLSortedObjectOrderCB *"=None, closure: "void *"=None) -> "void":
        r"""setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy, SoGLSortedObjectOrderCB * cb=None, void * closure=None)"""
        return _coin.SoGLRenderAction_setSortedObjectOrderStrategy(self, strategy, cb, closure)

    def setDelayedObjDepthWrite(self, write: "SbBool") -> "void":
        r"""setDelayedObjDepthWrite(SoGLRenderAction self, SbBool write)"""
        return _coin.SoGLRenderAction_setDelayedObjDepthWrite(self, write)

    def getDelayedObjDepthWrite(self) -> "SbBool":
        r"""getDelayedObjDepthWrite(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_getDelayedObjDepthWrite(self)

    def isRenderingTranspPaths(self) -> "SbBool":
        r"""isRenderingTranspPaths(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspPaths(self)

    def isRenderingTranspBackfaces(self) -> "SbBool":
        r"""isRenderingTranspBackfaces(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspBackfaces(self)

    def setPassCallback(self, *args) -> "void":
        r"""
        setPassCallback(SoGLRenderAction self, SoGLRenderPassCB *const func, void *const userdata)
        setPassCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_setPassCallback(self, *args)

    def setAbortCallback(self, *args) -> "void":
        r"""
        setAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *const func, void *const userdata)
        setAbortCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_setAbortCallback(self, *args)

    def addPreRenderCallback(self, *args) -> "void":
        r"""
        addPreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
        addPreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_addPreRenderCallback(self, *args)

    def removePreRenderCallback(self, *args) -> "void":
        r"""
        removePreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
        removePreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_removePreRenderCallback(self, *args)

    @staticmethod
    def constructFromAction(action: "SoAction") -> "SoGLRenderAction *":
        r"""constructFromAction(SoAction action) -> SoGLRenderAction"""
        return _coin.SoGLRenderAction_constructFromAction(action)

# Register SoGLRenderAction in _coin:
_coin.SoGLRenderAction_swigregister(SoGLRenderAction)

def SoGLRenderAction_getClassTypeId() -> "SoType":
    r"""SoGLRenderAction_getClassTypeId() -> SoType"""
    return _coin.SoGLRenderAction_getClassTypeId()

def SoGLRenderAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoGLRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGLRenderAction_addMethod(type, method)

def SoGLRenderAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoGLRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGLRenderAction_enableElement(type, stackindex)

def SoGLRenderAction_initClass() -> "void":
    r"""SoGLRenderAction_initClass()"""
    return _coin.SoGLRenderAction_initClass()

def SoGLRenderAction_constructFromAction(action: "SoAction") -> "SoGLRenderAction *":
    r"""SoGLRenderAction_constructFromAction(SoAction action) -> SoGLRenderAction"""
    return _coin.SoGLRenderAction_constructFromAction(action)

class SoBoxHighlightRenderAction(SoGLRenderAction):
    r"""Proxy of C++ SoBoxHighlightRenderAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBoxHighlightRenderAction self) -> SoType"""
        return _coin.SoBoxHighlightRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBoxHighlightRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoBoxHighlightRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoBoxHighlightRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBoxHighlightRenderAction_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoBoxHighlightRenderAction self) -> SoBoxHighlightRenderAction
        __init__(SoBoxHighlightRenderAction self, SbViewportRegion viewportregion) -> SoBoxHighlightRenderAction
        """
        _coin.SoBoxHighlightRenderAction_swiginit(self, _coin.new_SoBoxHighlightRenderAction(*args))
    __swig_destroy__ = _coin.delete_SoBoxHighlightRenderAction

    def apply(self, *args) -> "void":
        r"""
        apply(SoBoxHighlightRenderAction self, SoNode node)
        apply(SoBoxHighlightRenderAction self, SoPath path)
        apply(SoBoxHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoBoxHighlightRenderAction_apply(self, *args)

    def setVisible(self, visible: "SbBool const") -> "void":
        r"""setVisible(SoBoxHighlightRenderAction self, SbBool const visible)"""
        return _coin.SoBoxHighlightRenderAction_setVisible(self, visible)

    def isVisible(self) -> "SbBool":
        r"""isVisible(SoBoxHighlightRenderAction self) -> SbBool"""
        return _coin.SoBoxHighlightRenderAction_isVisible(self)

    def setColor(self, color: "SbColor") -> "void":
        r"""setColor(SoBoxHighlightRenderAction self, SbColor color)"""
        return _coin.SoBoxHighlightRenderAction_setColor(self, color)

    def getColor(self) -> "SbColor const &":
        r"""getColor(SoBoxHighlightRenderAction self) -> SbColor"""
        return _coin.SoBoxHighlightRenderAction_getColor(self)

    def setLinePattern(self, pattern: "unsigned short") -> "void":
        r"""setLinePattern(SoBoxHighlightRenderAction self, unsigned short pattern)"""
        return _coin.SoBoxHighlightRenderAction_setLinePattern(self, pattern)

    def getLinePattern(self) -> "unsigned short":
        r"""getLinePattern(SoBoxHighlightRenderAction self) -> unsigned short"""
        return _coin.SoBoxHighlightRenderAction_getLinePattern(self)

    def setLineWidth(self, width: "float const") -> "void":
        r"""setLineWidth(SoBoxHighlightRenderAction self, float const width)"""
        return _coin.SoBoxHighlightRenderAction_setLineWidth(self, width)

    def getLineWidth(self) -> "float":
        r"""getLineWidth(SoBoxHighlightRenderAction self) -> float"""
        return _coin.SoBoxHighlightRenderAction_getLineWidth(self)

# Register SoBoxHighlightRenderAction in _coin:
_coin.SoBoxHighlightRenderAction_swigregister(SoBoxHighlightRenderAction)

def SoBoxHighlightRenderAction_getClassTypeId() -> "SoType":
    r"""SoBoxHighlightRenderAction_getClassTypeId() -> SoType"""
    return _coin.SoBoxHighlightRenderAction_getClassTypeId()

def SoBoxHighlightRenderAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoBoxHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoBoxHighlightRenderAction_addMethod(type, method)

def SoBoxHighlightRenderAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoBoxHighlightRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoBoxHighlightRenderAction_enableElement(type, stackindex)

def SoBoxHighlightRenderAction_initClass() -> "void":
    r"""SoBoxHighlightRenderAction_initClass()"""
    return _coin.SoBoxHighlightRenderAction_initClass()

class SoLineHighlightRenderAction(SoGLRenderAction):
    r"""Proxy of C++ SoLineHighlightRenderAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLineHighlightRenderAction self) -> SoType"""
        return _coin.SoLineHighlightRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineHighlightRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoLineHighlightRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoLineHighlightRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLineHighlightRenderAction_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoLineHighlightRenderAction self) -> SoLineHighlightRenderAction
        __init__(SoLineHighlightRenderAction self, SbViewportRegion viewportregion) -> SoLineHighlightRenderAction
        """
        _coin.SoLineHighlightRenderAction_swiginit(self, _coin.new_SoLineHighlightRenderAction(*args))
    __swig_destroy__ = _coin.delete_SoLineHighlightRenderAction

    def apply(self, *args) -> "void":
        r"""
        apply(SoLineHighlightRenderAction self, SoNode node)
        apply(SoLineHighlightRenderAction self, SoPath path)
        apply(SoLineHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoLineHighlightRenderAction_apply(self, *args)

    def setVisible(self, visible: "SbBool const") -> "void":
        r"""setVisible(SoLineHighlightRenderAction self, SbBool const visible)"""
        return _coin.SoLineHighlightRenderAction_setVisible(self, visible)

    def isVisible(self) -> "SbBool":
        r"""isVisible(SoLineHighlightRenderAction self) -> SbBool"""
        return _coin.SoLineHighlightRenderAction_isVisible(self)

    def setColor(self, color: "SbColor") -> "void":
        r"""setColor(SoLineHighlightRenderAction self, SbColor color)"""
        return _coin.SoLineHighlightRenderAction_setColor(self, color)

    def getColor(self) -> "SbColor const &":
        r"""getColor(SoLineHighlightRenderAction self) -> SbColor"""
        return _coin.SoLineHighlightRenderAction_getColor(self)

    def setLinePattern(self, pattern: "uint16_t") -> "void":
        r"""setLinePattern(SoLineHighlightRenderAction self, uint16_t pattern)"""
        return _coin.SoLineHighlightRenderAction_setLinePattern(self, pattern)

    def getLinePattern(self) -> "uint16_t":
        r"""getLinePattern(SoLineHighlightRenderAction self) -> uint16_t"""
        return _coin.SoLineHighlightRenderAction_getLinePattern(self)

    def setLineWidth(self, width: "float const") -> "void":
        r"""setLineWidth(SoLineHighlightRenderAction self, float const width)"""
        return _coin.SoLineHighlightRenderAction_setLineWidth(self, width)

    def getLineWidth(self) -> "float":
        r"""getLineWidth(SoLineHighlightRenderAction self) -> float"""
        return _coin.SoLineHighlightRenderAction_getLineWidth(self)

# Register SoLineHighlightRenderAction in _coin:
_coin.SoLineHighlightRenderAction_swigregister(SoLineHighlightRenderAction)

def SoLineHighlightRenderAction_getClassTypeId() -> "SoType":
    r"""SoLineHighlightRenderAction_getClassTypeId() -> SoType"""
    return _coin.SoLineHighlightRenderAction_getClassTypeId()

def SoLineHighlightRenderAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoLineHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoLineHighlightRenderAction_addMethod(type, method)

def SoLineHighlightRenderAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoLineHighlightRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoLineHighlightRenderAction_enableElement(type, stackindex)

def SoLineHighlightRenderAction_initClass() -> "void":
    r"""SoLineHighlightRenderAction_initClass()"""
    return _coin.SoLineHighlightRenderAction_initClass()

class SbBox3f(object):
    r"""Proxy of C++ SbBox3f class."""

    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):
        r"""
        __init__(SbBox3f self) -> SbBox3f
        __init__(SbBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax) -> SbBox3f
        __init__(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
        __init__(SbBox3f self, SbBox3d box) -> SbBox3f
        __init__(SbBox3f self, SbBox3s box) -> SbBox3f
        __init__(SbBox3f self, SbBox3i32 box) -> SbBox3f
        """
        _coin.SbBox3f_swiginit(self, _coin.new_SbBox3f(*args))

    def setBounds(self, *args) -> "SbBox3f &":
        r"""
        setBounds(SbBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax) -> SbBox3f
        setBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
        setBounds(SbBox3f self, SbBox3d box) -> SbBox3f
        setBounds(SbBox3f self, SbBox3s box) -> SbBox3f
        setBounds(SbBox3f self, SbBox3i32 box) -> SbBox3f
        """
        return _coin.SbBox3f_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox3f self, float & xmin, float & ymin, float & zmin, float & xmax, float & ymax, float & zmax)
        getBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint)
        """
        return _coin.SbBox3f_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec3f &":
        r"""
        getMin(SbBox3f self) -> SbVec3f
        getMin(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getMin(self, *args)

    def getMax(self, *args) -> "SbVec3f &":
        r"""
        getMax(SbBox3f self) -> SbVec3f
        getMax(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox3f self, SbVec3f pt)
        extendBy(SbBox3f self, SbBox3f box)
        """
        return _coin.SbBox3f_extendBy(self, *args)

    def transform(self, matrix: "SbMatrix") -> "void":
        r"""transform(SbBox3f self, SbMatrix matrix)"""
        return _coin.SbBox3f_transform(self, matrix)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox3f self)"""
        return _coin.SbBox3f_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox3f self) -> SbBool"""
        return _coin.SbBox3f_isEmpty(self)

    def hasVolume(self) -> "SbBool":
        r"""hasVolume(SbBox3f self) -> SbBool"""
        return _coin.SbBox3f_hasVolume(self)

    def getVolume(self) -> "float":
        r"""getVolume(SbBox3f self) -> float"""
        return _coin.SbBox3f_getVolume(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox3f self, SbVec3f pt) -> SbBool
        intersect(SbBox3f self, SbBox3f box) -> SbBool
        """
        return _coin.SbBox3f_intersect(self, *args)

    def getClosestPoint(self, point: "SbVec3f") -> "SbVec3f":
        r"""getClosestPoint(SbBox3f self, SbVec3f point) -> SbVec3f"""
        return _coin.SbBox3f_getClosestPoint(self, point)

    def outside(self, mvp: "SbMatrix", cullbits: "int &") -> "SbBool":
        r"""outside(SbBox3f self, SbMatrix mvp, int & cullbits) -> SbBool"""
        return _coin.SbBox3f_outside(self, mvp, cullbits)

    def getCenter(self) -> "SbVec3f":
        r"""getCenter(SbBox3f self) -> SbVec3f"""
        return _coin.SbBox3f_getCenter(self)

    def getOrigin(self, originX: "float &", originY: "float &", originZ: "float &") -> "void":
        r"""getOrigin(SbBox3f self, float & originX, float & originY, float & originZ)"""
        return _coin.SbBox3f_getOrigin(self, originX, originY, originZ)

    def getSize(self, *args) -> "SbVec3f":
        r"""
        getSize(SbBox3f self, float & sizeX, float & sizeY, float & sizeZ)
        getSize(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getSize(self, *args)

    def getSpan(self, dir: "SbVec3f", dmin: "float &", dmax: "float &") -> "void":
        r"""getSpan(SbBox3f self, SbVec3f dir, float & dmin, float & dmax)"""
        return _coin.SbBox3f_getSpan(self, dir, dmin, dmax)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbBox3f self, FILE * file)"""
        return _coin.SbBox3f_output(self, file)

    def __eq__(self, u: "SbBox3f") -> "int":
        r"""__eq__(SbBox3f self, SbBox3f u) -> int"""
        return _coin.SbBox3f___eq__(self, u)

    def __ne__(self, u: "SbBox3f") -> "int":
        r"""__ne__(SbBox3f self, SbBox3f u) -> int"""
        return _coin.SbBox3f___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox3f

# Register SbBox3f in _coin:
_coin.SbBox3f_swigregister(SbBox3f)

class SbMatrix(object):
    r"""Proxy of C++ SbMatrix class."""

    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):
        r"""
        __init__(SbMatrix self) -> SbMatrix
        __init__(SbMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44) -> SbMatrix
        __init__(SbMatrix self, SbMat const & matrix) -> SbMatrix
        __init__(SbMatrix self, SbMat const * matrix) -> SbMatrix
        __init__(SbMatrix self, SbDPMatrix matrix) -> SbMatrix
        """
        _coin.SbMatrix_swiginit(self, _coin.new_SbMatrix(*args))
    __swig_destroy__ = _coin.delete_SbMatrix

    def setValue(self, *args) -> "void":
        r"""
        setValue(SbMatrix self, SbMat const & m)
        setValue(SbMatrix self, SbDPMatrix m)
        setValue(SbMatrix self, float const * pMat)
        """
        return _coin.SbMatrix_setValue(self, *args)

    def makeIdentity(self) -> "void":
        r"""makeIdentity(SbMatrix self)"""
        return _coin.SbMatrix_makeIdentity(self)

    def setRotate(self, q: "SbRotation") -> "void":
        r"""setRotate(SbMatrix self, SbRotation q)"""
        return _coin.SbMatrix_setRotate(self, q)

    def inverse(self) -> "SbMatrix":
        r"""inverse(SbMatrix self) -> SbMatrix"""
        return _coin.SbMatrix_inverse(self)

    def det3(self, *args) -> "float":
        r"""
        det3(SbMatrix self, int r1, int r2, int r3, int c1, int c2, int c3) -> float
        det3(SbMatrix self) -> float
        """
        return _coin.SbMatrix_det3(self, *args)

    def det4(self) -> "float":
        r"""det4(SbMatrix self) -> float"""
        return _coin.SbMatrix_det4(self)

    def equals(self, m: "SbMatrix", tolerance: "float") -> "SbBool":
        r"""equals(SbMatrix self, SbMatrix m, float tolerance) -> SbBool"""
        return _coin.SbMatrix_equals(self, m, tolerance)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbMatrix self) -> SbMat const
        getValue(SbMatrix self, SbMat & m)
        """
        return _coin.SbMatrix_getValue(self, *args)

    @staticmethod
    def identity() -> "SbMatrix":
        r"""identity() -> SbMatrix"""
        return _coin.SbMatrix_identity()

    def setScale(self, *args) -> "void":
        r"""
        setScale(SbMatrix self, float const s)
        setScale(SbMatrix self, SbVec3f s)
        """
        return _coin.SbMatrix_setScale(self, *args)

    def setTranslate(self, t: "SbVec3f") -> "void":
        r"""setTranslate(SbMatrix self, SbVec3f t)"""
        return _coin.SbMatrix_setTranslate(self, t)

    def setTransform(self, *args) -> "void":
        r"""
        setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s)
        setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
        setTransform(SbMatrix self, SbVec3f translation, SbRotation rotation, SbVec3f scaleFactor, SbRotation scaleOrientation, SbVec3f center)
        """
        return _coin.SbMatrix_setTransform(self, *args)

    def factor(self, r: "SbMatrix", s: "SbVec3f", u: "SbMatrix", t: "SbVec3f", proj: "SbMatrix") -> "SbBool":
        r"""factor(SbMatrix self, SbMatrix r, SbVec3f s, SbMatrix u, SbVec3f t, SbMatrix proj) -> SbBool"""
        return _coin.SbMatrix_factor(self, r, s, u, t, proj)

    def LUDecomposition(self, index: "int [4]", d: "float &") -> "SbBool":
        r"""LUDecomposition(SbMatrix self, int [4] index, float & d) -> SbBool"""
        return _coin.SbMatrix_LUDecomposition(self, index, d)

    def LUBackSubstitution(self, index: "int [4]", b: "float [4]") -> "void":
        r"""LUBackSubstitution(SbMatrix self, int [4] index, float [4] b)"""
        return _coin.SbMatrix_LUBackSubstitution(self, index, b)

    def transpose(self) -> "SbMatrix":
        r"""transpose(SbMatrix self) -> SbMatrix"""
        return _coin.SbMatrix_transpose(self)

    def multRight(self, m: "SbMatrix") -> "SbMatrix &":
        r"""multRight(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multRight(self, m)

    def multLeft(self, m: "SbMatrix") -> "SbMatrix &":
        r"""multLeft(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multLeft(self, m)

    def multMatrixVec(self, src: "SbVec3f") -> "void":
        r"""multMatrixVec(SbMatrix self, SbVec3f src)"""
        return _coin.SbMatrix_multMatrixVec(self, src)

    def multDirMatrix(self, src: "SbVec3f") -> "void":
        r"""multDirMatrix(SbMatrix self, SbVec3f src)"""
        return _coin.SbMatrix_multDirMatrix(self, src)

    def multLineMatrix(self, src: "SbLine", dst: "SbLine") -> "void":
        r"""multLineMatrix(SbMatrix self, SbLine src, SbLine dst)"""
        return _coin.SbMatrix_multLineMatrix(self, src, dst)

    def multVecMatrix(self, *args) -> "void":
        r"""
        multVecMatrix(SbMatrix self, SbVec3f src)
        multVecMatrix(SbMatrix self, SbVec4f src)
        """
        return _coin.SbMatrix_multVecMatrix(self, *args)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbMatrix self, FILE * fp)"""
        return _coin.SbMatrix_output(self, fp)

    def __imul__(self, m: "SbMatrix") -> "SbMatrix &":
        r"""__imul__(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix___imul__(self, m)

    def getTransform(self, *args) -> "PyObject *":
        r"""
        getTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
        getTransform(SbMatrix self) -> PyObject
        getTransform(SbMatrix self, SbVec3f center) -> PyObject *
        """
        return _coin.SbMatrix_getTransform(self, *args)

    def __mul__(self, *args) -> "SbVec3f":
        r"""
        __mul__(SbMatrix self, SbMatrix u) -> SbMatrix
        __mul__(SbMatrix self, SbVec3f u) -> SbVec3f
        """
        return _coin.SbMatrix___mul__(self, *args)

    def __rmul__(self, u: "SbVec3f") -> "SbVec3f":
        r"""__rmul__(SbMatrix self, SbVec3f u) -> SbVec3f"""
        return _coin.SbMatrix___rmul__(self, u)

    def __eq__(self, u: "SbMatrix") -> "int":
        r"""__eq__(SbMatrix self, SbMatrix u) -> int"""
        return _coin.SbMatrix___eq__(self, u)

    def __ne__(self, u: "SbMatrix") -> "int":
        r"""__ne__(SbMatrix self, SbMatrix u) -> int"""
        return _coin.SbMatrix___ne__(self, u)

    def __getitem__(self, i: "int") -> "float const *":
        r"""__getitem__(SbMatrix self, int i) -> float const *"""
        return _coin.SbMatrix___getitem__(self, i)

# Register SbMatrix in _coin:
_coin.SbMatrix_swigregister(SbMatrix)

def SbMatrix_identity() -> "SbMatrix":
    r"""SbMatrix_identity() -> SbMatrix"""
    return _coin.SbMatrix_identity()

class SbXfBox3f(SbBox3f):
    r"""Proxy of C++ SbXfBox3f class."""

    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):
        r"""
        __init__(SbXfBox3f self) -> SbXfBox3f
        __init__(SbXfBox3f self, SbVec3f boxmin, SbVec3f boxmax) -> SbXfBox3f
        __init__(SbXfBox3f self, SbBox3f box) -> SbXfBox3f
        """
        _coin.SbXfBox3f_swiginit(self, _coin.new_SbXfBox3f(*args))
    __swig_destroy__ = _coin.delete_SbXfBox3f

    def setTransform(self, m: "SbMatrix") -> "void":
        r"""setTransform(SbXfBox3f self, SbMatrix m)"""
        return _coin.SbXfBox3f_setTransform(self, m)

    def getTransform(self) -> "SbMatrix const &":
        r"""getTransform(SbXfBox3f self) -> SbMatrix"""
        return _coin.SbXfBox3f_getTransform(self)

    def getInverse(self) -> "SbMatrix const &":
        r"""getInverse(SbXfBox3f self) -> SbMatrix"""
        return _coin.SbXfBox3f_getInverse(self)

    def getCenter(self) -> "SbVec3f":
        r"""getCenter(SbXfBox3f self) -> SbVec3f"""
        return _coin.SbXfBox3f_getCenter(self)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbXfBox3f self, SbVec3f pt)
        extendBy(SbXfBox3f self, SbBox3f bb)
        extendBy(SbXfBox3f self, SbXfBox3f bb)
        """
        return _coin.SbXfBox3f_extendBy(self, *args)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbXfBox3f self, SbVec3f pt) -> SbBool
        intersect(SbXfBox3f self, SbBox3f bb) -> SbBool
        intersect(SbXfBox3f self, SbXfBox3f bb) -> SbBool
        """
        return _coin.SbXfBox3f_intersect(self, *args)

    def getSpan(self, direction: "SbVec3f", dMin: "float &", dMax: "float &") -> "void":
        r"""getSpan(SbXfBox3f self, SbVec3f direction, float & dMin, float & dMax)"""
        return _coin.SbXfBox3f_getSpan(self, direction, dMin, dMax)

    def project(self) -> "SbBox3f":
        r"""project(SbXfBox3f self) -> SbBox3f"""
        return _coin.SbXfBox3f_project(self)

    def transform(self, m: "SbMatrix") -> "void":
        r"""transform(SbXfBox3f self, SbMatrix m)"""
        return _coin.SbXfBox3f_transform(self, m)

    def getVolume(self) -> "float":
        r"""getVolume(SbXfBox3f self) -> float"""
        return _coin.SbXfBox3f_getVolume(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbXfBox3f self, FILE * file)"""
        return _coin.SbXfBox3f_output(self, file)

    def __eq__(self, u: "SbXfBox3f") -> "int":
        r"""__eq__(SbXfBox3f self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___eq__(self, u)

    def __ne__(self, u: "SbXfBox3f") -> "int":
        r"""__ne__(SbXfBox3f self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___ne__(self, u)

# Register SbXfBox3f in _coin:
_coin.SbXfBox3f_swigregister(SbXfBox3f)

class SoGetBoundingBoxAction(SoAction):
    r"""Proxy of C++ SoGetBoundingBoxAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGetBoundingBoxAction self) -> SoType"""
        return _coin.SoGetBoundingBoxAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGetBoundingBoxAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetBoundingBoxAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetBoundingBoxAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGetBoundingBoxAction_initClass()

    def __init__(self, vp: "SbViewportRegion"):
        r"""__init__(SoGetBoundingBoxAction self, SbViewportRegion vp) -> SoGetBoundingBoxAction"""
        _coin.SoGetBoundingBoxAction_swiginit(self, _coin.new_SoGetBoundingBoxAction(vp))
    __swig_destroy__ = _coin.delete_SoGetBoundingBoxAction
    TRANSFORM = _coin.SoGetBoundingBoxAction_TRANSFORM
    
    BBOX = _coin.SoGetBoundingBoxAction_BBOX
    
    ALL = _coin.SoGetBoundingBoxAction_ALL
    

    def setViewportRegion(self, newregion: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoGetBoundingBoxAction self, SbViewportRegion newregion)"""
        return _coin.SoGetBoundingBoxAction_setViewportRegion(self, newregion)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoGetBoundingBoxAction self) -> SbViewportRegion"""
        return _coin.SoGetBoundingBoxAction_getViewportRegion(self)

    def getBoundingBox(self) -> "SbBox3f":
        r"""getBoundingBox(SoGetBoundingBoxAction self) -> SbBox3f"""
        return _coin.SoGetBoundingBoxAction_getBoundingBox(self)

    def getXfBoundingBox(self) -> "SbXfBox3f &":
        r"""getXfBoundingBox(SoGetBoundingBoxAction self) -> SbXfBox3f"""
        return _coin.SoGetBoundingBoxAction_getXfBoundingBox(self)

    def getCenter(self) -> "SbVec3f const &":
        r"""getCenter(SoGetBoundingBoxAction self) -> SbVec3f"""
        return _coin.SoGetBoundingBoxAction_getCenter(self)

    def setInCameraSpace(self, flag: "SbBool const") -> "void":
        r"""setInCameraSpace(SoGetBoundingBoxAction self, SbBool const flag)"""
        return _coin.SoGetBoundingBoxAction_setInCameraSpace(self, flag)

    def isInCameraSpace(self) -> "SbBool":
        r"""isInCameraSpace(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isInCameraSpace(self)

    def setResetPath(self, *args) -> "void":
        r"""setResetPath(SoGetBoundingBoxAction self, SoPath path, SbBool const resetbefore=1, SoGetBoundingBoxAction::ResetType const what=ALL)"""
        return _coin.SoGetBoundingBoxAction_setResetPath(self, *args)

    def getResetPath(self) -> "SoPath const *":
        r"""getResetPath(SoGetBoundingBoxAction self) -> SoPath"""
        return _coin.SoGetBoundingBoxAction_getResetPath(self)

    def isResetPath(self) -> "SbBool":
        r"""isResetPath(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetPath(self)

    def isResetBefore(self) -> "SbBool":
        r"""isResetBefore(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetBefore(self)

    def getWhatReset(self) -> "SoGetBoundingBoxAction::ResetType":
        r"""getWhatReset(SoGetBoundingBoxAction self) -> SoGetBoundingBoxAction::ResetType"""
        return _coin.SoGetBoundingBoxAction_getWhatReset(self)

    def checkResetBefore(self) -> "void":
        r"""checkResetBefore(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_checkResetBefore(self)

    def checkResetAfter(self) -> "void":
        r"""checkResetAfter(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_checkResetAfter(self)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SoGetBoundingBoxAction self, SbBox3f box)
        extendBy(SoGetBoundingBoxAction self, SbXfBox3f box)
        """
        return _coin.SoGetBoundingBoxAction_extendBy(self, *args)

    def setCenter(self, center: "SbVec3f", transformcenter: "SbBool const") -> "void":
        r"""setCenter(SoGetBoundingBoxAction self, SbVec3f center, SbBool const transformcenter)"""
        return _coin.SoGetBoundingBoxAction_setCenter(self, center, transformcenter)

    def isCenterSet(self) -> "SbBool":
        r"""isCenterSet(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isCenterSet(self)

    def resetCenter(self) -> "void":
        r"""resetCenter(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_resetCenter(self)

# Register SoGetBoundingBoxAction in _coin:
_coin.SoGetBoundingBoxAction_swigregister(SoGetBoundingBoxAction)

def SoGetBoundingBoxAction_getClassTypeId() -> "SoType":
    r"""SoGetBoundingBoxAction_getClassTypeId() -> SoType"""
    return _coin.SoGetBoundingBoxAction_getClassTypeId()

def SoGetBoundingBoxAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoGetBoundingBoxAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGetBoundingBoxAction_addMethod(type, method)

def SoGetBoundingBoxAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoGetBoundingBoxAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGetBoundingBoxAction_enableElement(type, stackindex)

def SoGetBoundingBoxAction_initClass() -> "void":
    r"""SoGetBoundingBoxAction_initClass()"""
    return _coin.SoGetBoundingBoxAction_initClass()

class SbVec4f(object):
    r"""Proxy of C++ SbVec4f class."""

    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):
        r"""
        __init__(SbVec4f self) -> SbVec4f
        __init__(SbVec4f self, float const [4] v) -> SbVec4f
        __init__(SbVec4f self, float x, float y, float z, float w) -> SbVec4f
        __init__(SbVec4f self, SbVec4d v) -> SbVec4f
        __init__(SbVec4f self, SbVec4b v) -> SbVec4f
        __init__(SbVec4f self, SbVec4s v) -> SbVec4f
        __init__(SbVec4f self, SbVec4i32 v) -> SbVec4f
        """
        _coin.SbVec4f_swiginit(self, _coin.new_SbVec4f(*args))

    def setValue(self, *args) -> "SbVec4f &":
        r"""
        setValue(SbVec4f self, float const [4] v) -> SbVec4f
        setValue(SbVec4f self, float x, float y, float z, float w) -> SbVec4f
        setValue(SbVec4f self, SbVec4d v) -> SbVec4f
        setValue(SbVec4f self, SbVec4b v) -> SbVec4f
        setValue(SbVec4f self, SbVec4s v) -> SbVec4f
        setValue(SbVec4f self, SbVec4i32 v) -> SbVec4f
        """
        return _coin.SbVec4f_setValue(self, *args)

    def getValue(self) -> "float const *":
        r"""getValue(SbVec4f self) -> float const *"""
        return _coin.SbVec4f_getValue(self)

    def equals(self, v: "SbVec4f", tolerance: "float") -> "SbBool":
        r"""equals(SbVec4f self, SbVec4f v, float tolerance) -> SbBool"""
        return _coin.SbVec4f_equals(self, v, tolerance)

    def dot(self, v: "SbVec4f") -> "float":
        r"""dot(SbVec4f self, SbVec4f v) -> float"""
        return _coin.SbVec4f_dot(self, v)

    def getReal(self, v: "SbVec3f") -> "void":
        r"""getReal(SbVec4f self, SbVec3f v)"""
        return _coin.SbVec4f_getReal(self, v)

    def length(self) -> "float":
        r"""length(SbVec4f self) -> float"""
        return _coin.SbVec4f_length(self)

    def sqrLength(self) -> "float":
        r"""sqrLength(SbVec4f self) -> float"""
        return _coin.SbVec4f_sqrLength(self)

    def negate(self) -> "void":
        r"""negate(SbVec4f self)"""
        return _coin.SbVec4f_negate(self)

    def normalize(self) -> "float":
        r"""normalize(SbVec4f self) -> float"""
        return _coin.SbVec4f_normalize(self)

    def __imul__(self, d: "float") -> "SbVec4f &":
        r"""__imul__(SbVec4f self, float d) -> SbVec4f"""
        return _coin.SbVec4f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec4f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4f") -> "SbVec4f &":
        r"""__iadd__(SbVec4f self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___iadd__(self, v)

    def __isub__(self, v: "SbVec4f") -> "SbVec4f &":
        r"""__isub__(SbVec4f self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___isub__(self, v)

    def __neg__(self) -> "SbVec4f":
        r"""__neg__(SbVec4f self) -> SbVec4f"""
        return _coin.SbVec4f___neg__(self)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec4f self, FILE * fp)"""
        return _coin.SbVec4f_output(self, fp)

    def __add__(self, u: "SbVec4f") -> "SbVec4f":
        r"""__add__(SbVec4f self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___add__(self, u)

    def __sub__(self, u: "SbVec4f") -> "SbVec4f":
        r"""__sub__(SbVec4f self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___sub__(self, u)

    def __mul__(self, *args) -> "SbVec4f":
        r"""
        __mul__(SbVec4f self, float const d) -> SbVec4f
        __mul__(SbVec4f self, SbMatrix m) -> SbVec4f
        """
        return _coin.SbVec4f___mul__(self, *args)

    def __rmul__(self, d: "float const") -> "SbVec4f":
        r"""__rmul__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___rmul__(self, d)

    def __div__(self, d: "float const") -> "SbVec4f":
        r"""__div__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___div__(self, d)

    def __truediv__(self, d: "float const") -> "SbVec4f":
        r"""__truediv__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___truediv__(self, d)

    def __eq__(self, u: "SbVec4f") -> "int":
        r"""__eq__(SbVec4f self, SbVec4f u) -> int"""
        return _coin.SbVec4f___eq__(self, u)

    def __nq__(self, u: "SbVec4f") -> "int":
        r"""__nq__(SbVec4f self, SbVec4f u) -> int"""
        return _coin.SbVec4f___nq__(self, u)

    def __getitem__(self, i: "int") -> "float":
        r"""__getitem__(SbVec4f self, int i) -> float"""
        return _coin.SbVec4f___getitem__(self, i)

    def __setitem__(self, i: "int", value: "float") -> "void":
        r"""__setitem__(SbVec4f self, int i, float value)"""
        return _coin.SbVec4f___setitem__(self, i, value)

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

    def __len__(self):
          return 4

    __swig_destroy__ = _coin.delete_SbVec4f

# Register SbVec4f in _coin:
_coin.SbVec4f_swigregister(SbVec4f)

class SbRotation(object):
    r"""Proxy of C++ SbRotation class."""

    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):
        r"""
        __init__(SbRotation self) -> SbRotation
        __init__(SbRotation self, SbVec3f axis, float const radians) -> SbRotation
        __init__(SbRotation self, float const [4] q) -> SbRotation
        __init__(SbRotation self, float const q0, float const q1, float const q2, float const q3) -> SbRotation
        __init__(SbRotation self, SbMatrix m) -> SbRotation
        __init__(SbRotation self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
        """
        _coin.SbRotation_swiginit(self, _coin.new_SbRotation(*args))

    def getValue(self) -> "float const *":
        r"""getValue(SbRotation self) -> float const *"""
        return _coin.SbRotation_getValue(self)

    def getAxisAngle(self) -> "void":
        r"""getAxisAngle(SbRotation self)"""
        return _coin.SbRotation_getAxisAngle(self)

    def getMatrix(self) -> "void":
        r"""getMatrix(SbRotation self)"""
        return _coin.SbRotation_getMatrix(self)

    def invert(self) -> "SbRotation &":
        r"""invert(SbRotation self) -> SbRotation"""
        return _coin.SbRotation_invert(self)

    def inverse(self) -> "SbRotation":
        r"""inverse(SbRotation self) -> SbRotation"""
        return _coin.SbRotation_inverse(self)

    def setValue(self, *args) -> "SbRotation &":
        r"""
        setValue(SbRotation self, float const q0, float const q1, float const q2, float const q3) -> SbRotation
        setValue(SbRotation self, float const [4] q) -> SbRotation
        setValue(SbRotation self, SbMatrix m) -> SbRotation
        setValue(SbRotation self, SbVec3f axis, float const radians) -> SbRotation
        setValue(SbRotation self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
        """
        return _coin.SbRotation_setValue(self, *args)

    def __imul__(self, *args) -> "SbRotation &":
        r"""
        __imul__(SbRotation self, SbRotation q) -> SbRotation
        __imul__(SbRotation self, float const s) -> SbRotation
        """
        return _coin.SbRotation___imul__(self, *args)

    def equals(self, r: "SbRotation", tolerance: "float") -> "SbBool":
        r"""equals(SbRotation self, SbRotation r, float tolerance) -> SbBool"""
        return _coin.SbRotation_equals(self, r, tolerance)

    def multVec(self, src: "SbVec3f") -> "void":
        r"""multVec(SbRotation self, SbVec3f src)"""
        return _coin.SbRotation_multVec(self, src)

    def scaleAngle(self, scaleFactor: "float const") -> "void":
        r"""scaleAngle(SbRotation self, float const scaleFactor)"""
        return _coin.SbRotation_scaleAngle(self, scaleFactor)

    @staticmethod
    def slerp(rot0: "SbRotation", rot1: "SbRotation", t: "float") -> "SbRotation":
        r"""slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
        return _coin.SbRotation_slerp(rot0, rot1, t)

    @staticmethod
    def identity() -> "SbRotation":
        r"""identity() -> SbRotation"""
        return _coin.SbRotation_identity()

    def toString(self) -> "SbString":
        r"""toString(SbRotation self) -> SbString"""
        return _coin.SbRotation_toString(self)

    def fromString(self, str: "SbString") -> "SbBool":
        r"""fromString(SbRotation self, SbString str) -> SbBool"""
        return _coin.SbRotation_fromString(self, str)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbRotation self, FILE * fp)"""
        return _coin.SbRotation_output(self, fp)

    def __mul__(self, *args) -> "SbVec3f":
        r"""
        __mul__(SbRotation self, SbRotation u) -> SbRotation
        __mul__(SbRotation self, double const d) -> SbRotation
        __mul__(SbRotation self, SbVec3f v) -> SbVec3f
        """
        return _coin.SbRotation___mul__(self, *args)

    def __eq__(self, u: "SbRotation") -> "int":
        r"""__eq__(SbRotation self, SbRotation u) -> int"""
        return _coin.SbRotation___eq__(self, u)

    def __nq__(self, u: "SbRotation") -> "int":
        r"""__nq__(SbRotation self, SbRotation u) -> int"""
        return _coin.SbRotation___nq__(self, u)

    def __imul__(self, other):
        return self * other

    __swig_destroy__ = _coin.delete_SbRotation

# Register SbRotation in _coin:
_coin.SbRotation_swigregister(SbRotation)

def SbRotation_slerp(rot0: "SbRotation", rot1: "SbRotation", t: "float") -> "SbRotation":
    r"""SbRotation_slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
    return _coin.SbRotation_slerp(rot0, rot1, t)

def SbRotation_identity() -> "SbRotation":
    r"""SbRotation_identity() -> SbRotation"""
    return _coin.SbRotation_identity()

class SoGetMatrixAction(SoAction):
    r"""Proxy of C++ SoGetMatrixAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGetMatrixAction self) -> SoType"""
        return _coin.SoGetMatrixAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGetMatrixAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetMatrixAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetMatrixAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGetMatrixAction_initClass()

    def __init__(self, region: "SbViewportRegion"):
        r"""__init__(SoGetMatrixAction self, SbViewportRegion region) -> SoGetMatrixAction"""
        _coin.SoGetMatrixAction_swiginit(self, _coin.new_SoGetMatrixAction(region))
    __swig_destroy__ = _coin.delete_SoGetMatrixAction

    def setViewportRegion(self, region: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoGetMatrixAction self, SbViewportRegion region)"""
        return _coin.SoGetMatrixAction_setViewportRegion(self, region)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoGetMatrixAction self) -> SbViewportRegion"""
        return _coin.SoGetMatrixAction_getViewportRegion(self)

    def getMatrix(self) -> "SbMatrix &":
        r"""getMatrix(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getMatrix(self)

    def getInverse(self) -> "SbMatrix &":
        r"""getInverse(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getInverse(self)

    def getTextureMatrix(self) -> "SbMatrix &":
        r"""getTextureMatrix(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getTextureMatrix(self)

    def getTextureInverse(self) -> "SbMatrix &":
        r"""getTextureInverse(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getTextureInverse(self)

# Register SoGetMatrixAction in _coin:
_coin.SoGetMatrixAction_swigregister(SoGetMatrixAction)

def SoGetMatrixAction_getClassTypeId() -> "SoType":
    r"""SoGetMatrixAction_getClassTypeId() -> SoType"""
    return _coin.SoGetMatrixAction_getClassTypeId()

def SoGetMatrixAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoGetMatrixAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGetMatrixAction_addMethod(type, method)

def SoGetMatrixAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoGetMatrixAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGetMatrixAction_enableElement(type, stackindex)

def SoGetMatrixAction_initClass() -> "void":
    r"""SoGetMatrixAction_initClass()"""
    return _coin.SoGetMatrixAction_initClass()

class SoGetPrimitiveCountAction(SoAction):
    r"""Proxy of C++ SoGetPrimitiveCountAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGetPrimitiveCountAction self) -> SoType"""
        return _coin.SoGetPrimitiveCountAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGetPrimitiveCountAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetPrimitiveCountAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetPrimitiveCountAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGetPrimitiveCountAction_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoGetPrimitiveCountAction self) -> SoGetPrimitiveCountAction
        __init__(SoGetPrimitiveCountAction self, SbViewportRegion vp) -> SoGetPrimitiveCountAction
        """
        _coin.SoGetPrimitiveCountAction_swiginit(self, _coin.new_SoGetPrimitiveCountAction(*args))
    __swig_destroy__ = _coin.delete_SoGetPrimitiveCountAction

    def getTriangleCount(self) -> "int":
        r"""getTriangleCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTriangleCount(self)

    def getLineCount(self) -> "int":
        r"""getLineCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getLineCount(self)

    def getPointCount(self) -> "int":
        r"""getPointCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getPointCount(self)

    def getTextCount(self) -> "int":
        r"""getTextCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTextCount(self)

    def getImageCount(self) -> "int":
        r"""getImageCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getImageCount(self)

    def containsNoPrimitives(self) -> "SbBool":
        r"""containsNoPrimitives(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNoPrimitives(self)

    def containsNonTriangleShapes(self) -> "SbBool":
        r"""containsNonTriangleShapes(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNonTriangleShapes(self)

    def is3DTextCountedAsTriangles(self) -> "SbBool":
        r"""is3DTextCountedAsTriangles(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_is3DTextCountedAsTriangles(self)

    def setCount3DTextAsTriangles(self, flag: "SbBool const") -> "void":
        r"""setCount3DTextAsTriangles(SoGetPrimitiveCountAction self, SbBool const flag)"""
        return _coin.SoGetPrimitiveCountAction_setCount3DTextAsTriangles(self, flag)

    def canApproximateCount(self) -> "SbBool":
        r"""canApproximateCount(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_canApproximateCount(self)

    def setCanApproximate(self, flag: "SbBool const") -> "void":
        r"""setCanApproximate(SoGetPrimitiveCountAction self, SbBool const flag)"""
        return _coin.SoGetPrimitiveCountAction_setCanApproximate(self, flag)

    def setDecimationValue(self, type: "SoDecimationTypeElement::Type", percentage: "float"=1.0) -> "void":
        r"""setDecimationValue(SoGetPrimitiveCountAction self, SoDecimationTypeElement::Type type, float percentage=1.0)"""
        return _coin.SoGetPrimitiveCountAction_setDecimationValue(self, type, percentage)

    def getDecimationType(self) -> "SoDecimationTypeElement::Type":
        r"""getDecimationType(SoGetPrimitiveCountAction self) -> SoDecimationTypeElement::Type"""
        return _coin.SoGetPrimitiveCountAction_getDecimationType(self)

    def getDecimationPercentage(self) -> "float":
        r"""getDecimationPercentage(SoGetPrimitiveCountAction self) -> float"""
        return _coin.SoGetPrimitiveCountAction_getDecimationPercentage(self)

    def addNumTriangles(self, num: "int const") -> "void":
        r"""addNumTriangles(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumTriangles(self, num)

    def addNumLines(self, num: "int const") -> "void":
        r"""addNumLines(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumLines(self, num)

    def addNumPoints(self, num: "int const") -> "void":
        r"""addNumPoints(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumPoints(self, num)

    def addNumText(self, num: "int const") -> "void":
        r"""addNumText(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumText(self, num)

    def addNumImage(self, num: "int const") -> "void":
        r"""addNumImage(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumImage(self, num)

    def incNumTriangles(self) -> "void":
        r"""incNumTriangles(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumTriangles(self)

    def incNumLines(self) -> "void":
        r"""incNumLines(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumLines(self)

    def incNumPoints(self) -> "void":
        r"""incNumPoints(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumPoints(self)

    def incNumText(self) -> "void":
        r"""incNumText(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumText(self)

    def incNumImage(self) -> "void":
        r"""incNumImage(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumImage(self)

# Register SoGetPrimitiveCountAction in _coin:
_coin.SoGetPrimitiveCountAction_swigregister(SoGetPrimitiveCountAction)

def SoGetPrimitiveCountAction_getClassTypeId() -> "SoType":
    r"""SoGetPrimitiveCountAction_getClassTypeId() -> SoType"""
    return _coin.SoGetPrimitiveCountAction_getClassTypeId()

def SoGetPrimitiveCountAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoGetPrimitiveCountAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGetPrimitiveCountAction_addMethod(type, method)

def SoGetPrimitiveCountAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoGetPrimitiveCountAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGetPrimitiveCountAction_enableElement(type, stackindex)

def SoGetPrimitiveCountAction_initClass() -> "void":
    r"""SoGetPrimitiveCountAction_initClass()"""
    return _coin.SoGetPrimitiveCountAction_initClass()

class SoHandleEventAction(SoAction):
    r"""Proxy of C++ SoHandleEventAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoHandleEventAction self) -> SoType"""
        return _coin.SoHandleEventAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHandleEventAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoHandleEventAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoHandleEventAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoHandleEventAction_initClass()

    def __init__(self, viewportregion: "SbViewportRegion"):
        r"""__init__(SoHandleEventAction self, SbViewportRegion viewportregion) -> SoHandleEventAction"""
        _coin.SoHandleEventAction_swiginit(self, _coin.new_SoHandleEventAction(viewportregion))
    __swig_destroy__ = _coin.delete_SoHandleEventAction

    def setViewportRegion(self, newregion: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoHandleEventAction self, SbViewportRegion newregion)"""
        return _coin.SoHandleEventAction_setViewportRegion(self, newregion)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoHandleEventAction self) -> SbViewportRegion"""
        return _coin.SoHandleEventAction_getViewportRegion(self)

    def setEvent(self, ev: "SoEvent") -> "void":
        r"""setEvent(SoHandleEventAction self, SoEvent ev)"""
        return _coin.SoHandleEventAction_setEvent(self, ev)

    def getEvent(self) -> "SoEvent const *":
        r"""getEvent(SoHandleEventAction self) -> SoEvent"""
        return _coin.SoHandleEventAction_getEvent(self)

    def setHandled(self) -> "void":
        r"""setHandled(SoHandleEventAction self)"""
        return _coin.SoHandleEventAction_setHandled(self)

    def isHandled(self) -> "SbBool":
        r"""isHandled(SoHandleEventAction self) -> SbBool"""
        return _coin.SoHandleEventAction_isHandled(self)

    def setGrabber(self, node: "SoNode") -> "void":
        r"""setGrabber(SoHandleEventAction self, SoNode node)"""
        return _coin.SoHandleEventAction_setGrabber(self, node)

    def releaseGrabber(self) -> "void":
        r"""releaseGrabber(SoHandleEventAction self)"""
        return _coin.SoHandleEventAction_releaseGrabber(self)

    def getGrabber(self) -> "SoNode *":
        r"""getGrabber(SoHandleEventAction self) -> SoNode"""
        return _coin.SoHandleEventAction_getGrabber(self)

    def setPickRoot(self, node: "SoNode") -> "void":
        r"""setPickRoot(SoHandleEventAction self, SoNode node)"""
        return _coin.SoHandleEventAction_setPickRoot(self, node)

    def getPickRoot(self) -> "SoNode *":
        r"""getPickRoot(SoHandleEventAction self) -> SoNode"""
        return _coin.SoHandleEventAction_getPickRoot(self)

    def setPickRadius(self, radiusinpixels: "float const") -> "void":
        r"""setPickRadius(SoHandleEventAction self, float const radiusinpixels)"""
        return _coin.SoHandleEventAction_setPickRadius(self, radiusinpixels)

    def getPickRadius(self) -> "float":
        r"""getPickRadius(SoHandleEventAction self) -> float"""
        return _coin.SoHandleEventAction_getPickRadius(self)

    def getPickedPoint(self) -> "SoPickedPoint const *":
        r"""getPickedPoint(SoHandleEventAction self) -> SoPickedPoint"""
        return _coin.SoHandleEventAction_getPickedPoint(self)

    def getPickedPointList(self) -> "SoPickedPointList const &":
        r"""getPickedPointList(SoHandleEventAction self) -> SoPickedPointList"""
        return _coin.SoHandleEventAction_getPickedPointList(self)

# Register SoHandleEventAction in _coin:
_coin.SoHandleEventAction_swigregister(SoHandleEventAction)

def SoHandleEventAction_getClassTypeId() -> "SoType":
    r"""SoHandleEventAction_getClassTypeId() -> SoType"""
    return _coin.SoHandleEventAction_getClassTypeId()

def SoHandleEventAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoHandleEventAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoHandleEventAction_addMethod(type, method)

def SoHandleEventAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoHandleEventAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoHandleEventAction_enableElement(type, stackindex)

def SoHandleEventAction_initClass() -> "void":
    r"""SoHandleEventAction_initClass()"""
    return _coin.SoHandleEventAction_initClass()

class SoPickAction(SoAction):
    r"""Proxy of C++ SoPickAction class."""

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

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPickAction self) -> SoType"""
        return _coin.SoPickAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoPickAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoPickAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPickAction_initClass()

    def setViewportRegion(self, newregion: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoPickAction self, SbViewportRegion newregion)"""
        return _coin.SoPickAction_setViewportRegion(self, newregion)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoPickAction self) -> SbViewportRegion"""
        return _coin.SoPickAction_getViewportRegion(self)

    def enableCulling(self, flag: "SbBool const") -> "void":
        r"""enableCulling(SoPickAction self, SbBool const flag)"""
        return _coin.SoPickAction_enableCulling(self, flag)

    def isCullingEnabled(self) -> "SbBool":
        r"""isCullingEnabled(SoPickAction self) -> SbBool"""
        return _coin.SoPickAction_isCullingEnabled(self)

# Register SoPickAction in _coin:
_coin.SoPickAction_swigregister(SoPickAction)

def SoPickAction_getClassTypeId() -> "SoType":
    r"""SoPickAction_getClassTypeId() -> SoType"""
    return _coin.SoPickAction_getClassTypeId()

def SoPickAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoPickAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoPickAction_addMethod(type, method)

def SoPickAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoPickAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoPickAction_enableElement(type, stackindex)

def SoPickAction_initClass() -> "void":
    r"""SoPickAction_initClass()"""
    return _coin.SoPickAction_initClass()

class SoRayPickAction(SoPickAction):
    r"""Proxy of C++ SoRayPickAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoRayPickAction self) -> SoType"""
        return _coin.SoRayPickAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRayPickAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoRayPickAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoRayPickAction_enableElement(type, stackindex)

    def __init__(self, viewportregion: "SbViewportRegion"):
        r"""__init__(SoRayPickAction self, SbViewportRegion viewportregion) -> SoRayPickAction"""
        _coin.SoRayPickAction_swiginit(self, _coin.new_SoRayPickAction(viewportregion))
    __swig_destroy__ = _coin.delete_SoRayPickAction

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoRayPickAction_initClass()

    def setPoint(self, viewportPoint: "SbVec2s") -> "void":
        r"""setPoint(SoRayPickAction self, SbVec2s viewportPoint)"""
        return _coin.SoRayPickAction_setPoint(self, viewportPoint)

    def setNormalizedPoint(self, normpoint: "SbVec2f") -> "void":
        r"""setNormalizedPoint(SoRayPickAction self, SbVec2f normpoint)"""
        return _coin.SoRayPickAction_setNormalizedPoint(self, normpoint)

    def setRadius(self, radiusinpixels: "float const") -> "void":
        r"""setRadius(SoRayPickAction self, float const radiusinpixels)"""
        return _coin.SoRayPickAction_setRadius(self, radiusinpixels)

    def getRadius(self) -> "float":
        r"""getRadius(SoRayPickAction self) -> float"""
        return _coin.SoRayPickAction_getRadius(self)

    def setRay(self, start: "SbVec3f", direction: "SbVec3f", neardistance: "float"=-1.0, fardistance: "float"=-1.0) -> "void":
        r"""setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction, float neardistance=-1.0, float fardistance=-1.0)"""
        return _coin.SoRayPickAction_setRay(self, start, direction, neardistance, fardistance)

    def setPickAll(self, flag: "SbBool const") -> "void":
        r"""setPickAll(SoRayPickAction self, SbBool const flag)"""
        return _coin.SoRayPickAction_setPickAll(self, flag)

    def isPickAll(self) -> "SbBool":
        r"""isPickAll(SoRayPickAction self) -> SbBool"""
        return _coin.SoRayPickAction_isPickAll(self)

    def getPickedPointList(self) -> "SoPickedPointList const &":
        r"""getPickedPointList(SoRayPickAction self) -> SoPickedPointList"""
        return _coin.SoRayPickAction_getPickedPointList(self)

    def getPickedPoint(self, index: "int const"=0) -> "SoPickedPoint *":
        r"""getPickedPoint(SoRayPickAction self, int const index=0) -> SoPickedPoint"""
        return _coin.SoRayPickAction_getPickedPoint(self, index)

    def computeWorldSpaceRay(self) -> "void":
        r"""computeWorldSpaceRay(SoRayPickAction self)"""
        return _coin.SoRayPickAction_computeWorldSpaceRay(self)

    def hasWorldSpaceRay(self) -> "SbBool":
        r"""hasWorldSpaceRay(SoRayPickAction self) -> SbBool"""
        return _coin.SoRayPickAction_hasWorldSpaceRay(self)

    def setObjectSpace(self, *args) -> "void":
        r"""
        setObjectSpace(SoRayPickAction self)
        setObjectSpace(SoRayPickAction self)
        """
        return _coin.SoRayPickAction_setObjectSpace(self, *args)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f intersection, SbVec3f barycentric, SbBool & front) -> SbBool
        intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f intersection) -> SbBool
        intersect(SoRayPickAction self, SbVec3f point) -> SbBool
        intersect(SoRayPickAction self, SbBox3f box, SbBool const usefullviewvolume=1) -> SbBool
        intersect(SoRayPickAction self, SbBox3f box, SbVec3f intersection, SbBool const usefullviewvolume=1) -> SbBool
        """
        return _coin.SoRayPickAction_intersect(self, *args)

    def getViewVolume(self) -> "SbViewVolume const &":
        r"""getViewVolume(SoRayPickAction self) -> SbViewVolume"""
        return _coin.SoRayPickAction_getViewVolume(self)

    def getLine(self) -> "SbLine const &":
        r"""getLine(SoRayPickAction self) -> SbLine"""
        return _coin.SoRayPickAction_getLine(self)

    def isBetweenPlanes(self, intersection: "SbVec3f") -> "SbBool":
        r"""isBetweenPlanes(SoRayPickAction self, SbVec3f intersection) -> SbBool"""
        return _coin.SoRayPickAction_isBetweenPlanes(self, intersection)

    def addIntersection(self, objectspacepoint: "SbVec3f", frontpick: "SbBool"=1) -> "SoPickedPoint *":
        r"""addIntersection(SoRayPickAction self, SbVec3f objectspacepoint, SbBool frontpick=1) -> SoPickedPoint"""
        return _coin.SoRayPickAction_addIntersection(self, objectspacepoint, frontpick)

    def reset(self) -> "void":
        r"""reset(SoRayPickAction self)"""
        return _coin.SoRayPickAction_reset(self)

# Register SoRayPickAction in _coin:
_coin.SoRayPickAction_swigregister(SoRayPickAction)

def SoRayPickAction_getClassTypeId() -> "SoType":
    r"""SoRayPickAction_getClassTypeId() -> SoType"""
    return _coin.SoRayPickAction_getClassTypeId()

def SoRayPickAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoRayPickAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoRayPickAction_addMethod(type, method)

def SoRayPickAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoRayPickAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoRayPickAction_enableElement(type, stackindex)

def SoRayPickAction_initClass() -> "void":
    r"""SoRayPickAction_initClass()"""
    return _coin.SoRayPickAction_initClass()

class SoSearchAction(SoAction):
    r"""Proxy of C++ SoSearchAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSearchAction self) -> SoType"""
        return _coin.SoSearchAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSearchAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSearchAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoSearchAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSearchAction_initClass()

    def __init__(self):
        r"""__init__(SoSearchAction self) -> SoSearchAction"""
        _coin.SoSearchAction_swiginit(self, _coin.new_SoSearchAction())
    __swig_destroy__ = _coin.delete_SoSearchAction
    NODE = _coin.SoSearchAction_NODE
    
    TYPE = _coin.SoSearchAction_TYPE
    
    NAME = _coin.SoSearchAction_NAME
    
    FIRST = _coin.SoSearchAction_FIRST
    
    LAST = _coin.SoSearchAction_LAST
    
    ALL = _coin.SoSearchAction_ALL
    

    def setNode(self, node: "SoNode") -> "void":
        r"""setNode(SoSearchAction self, SoNode node)"""
        return _coin.SoSearchAction_setNode(self, node)

    def getNode(self) -> "SoNode *":
        r"""getNode(SoSearchAction self) -> SoNode"""
        return _coin.SoSearchAction_getNode(self)

    def setType(self, type: "SoType", chkderived: "SbBool const"=1) -> "void":
        r"""setType(SoSearchAction self, SoType type, SbBool const chkderived=1)"""
        return _coin.SoSearchAction_setType(self, type, chkderived)

    def getType(self, chkderived: "SbBool &") -> "SoType":
        r"""getType(SoSearchAction self, SbBool & chkderived) -> SoType"""
        return _coin.SoSearchAction_getType(self, chkderived)

    def setName(self, name: "SbName") -> "void":
        r"""setName(SoSearchAction self, SbName name)"""
        return _coin.SoSearchAction_setName(self, name)

    def getName(self) -> "SbName":
        r"""getName(SoSearchAction self) -> SbName"""
        return _coin.SoSearchAction_getName(self)

    def setFind(self, what: "int const") -> "void":
        r"""setFind(SoSearchAction self, int const what)"""
        return _coin.SoSearchAction_setFind(self, what)

    def getFind(self) -> "int":
        r"""getFind(SoSearchAction self) -> int"""
        return _coin.SoSearchAction_getFind(self)

    def setInterest(self, interest: "SoSearchAction::Interest const") -> "void":
        r"""setInterest(SoSearchAction self, SoSearchAction::Interest const interest)"""
        return _coin.SoSearchAction_setInterest(self, interest)

    def getInterest(self) -> "SoSearchAction::Interest":
        r"""getInterest(SoSearchAction self) -> SoSearchAction::Interest"""
        return _coin.SoSearchAction_getInterest(self)

    def setSearchingAll(self, searchall: "SbBool const") -> "void":
        r"""setSearchingAll(SoSearchAction self, SbBool const searchall)"""
        return _coin.SoSearchAction_setSearchingAll(self, searchall)

    def isSearchingAll(self) -> "SbBool":
        r"""isSearchingAll(SoSearchAction self) -> SbBool"""
        return _coin.SoSearchAction_isSearchingAll(self)

    def getPath(self) -> "SoPath *":
        r"""getPath(SoSearchAction self) -> SoPath"""
        return _coin.SoSearchAction_getPath(self)

    def getPaths(self) -> "SoPathList &":
        r"""getPaths(SoSearchAction self) -> SoPathList"""
        return _coin.SoSearchAction_getPaths(self)

    def reset(self) -> "void":
        r"""reset(SoSearchAction self)"""
        return _coin.SoSearchAction_reset(self)

    def setFound(self) -> "void":
        r"""setFound(SoSearchAction self)"""
        return _coin.SoSearchAction_setFound(self)

    def isFound(self) -> "SbBool":
        r"""isFound(SoSearchAction self) -> SbBool"""
        return _coin.SoSearchAction_isFound(self)

    def addPath(self, path: "SoPath") -> "void":
        r"""addPath(SoSearchAction self, SoPath path)"""
        return _coin.SoSearchAction_addPath(self, path)
    duringSearchAll = property(_coin.SoSearchAction_duringSearchAll_get, _coin.SoSearchAction_duringSearchAll_set, doc=r"""duringSearchAll : SbBool""")

# Register SoSearchAction in _coin:
_coin.SoSearchAction_swigregister(SoSearchAction)

def SoSearchAction_getClassTypeId() -> "SoType":
    r"""SoSearchAction_getClassTypeId() -> SoType"""
    return _coin.SoSearchAction_getClassTypeId()

def SoSearchAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoSearchAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoSearchAction_addMethod(type, method)

def SoSearchAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoSearchAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoSearchAction_enableElement(type, stackindex)

def SoSearchAction_initClass() -> "void":
    r"""SoSearchAction_initClass()"""
    return _coin.SoSearchAction_initClass()
cvar = _coin.cvar

class SoSimplifyAction(SoAction):
    r"""Proxy of C++ SoSimplifyAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSimplifyAction self) -> SoType"""
        return _coin.SoSimplifyAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSimplifyAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSimplifyAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoSimplifyAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSimplifyAction_initClass()

    def __init__(self):
        r"""__init__(SoSimplifyAction self) -> SoSimplifyAction"""
        _coin.SoSimplifyAction_swiginit(self, _coin.new_SoSimplifyAction())
    __swig_destroy__ = _coin.delete_SoSimplifyAction

    def apply(self, *args) -> "void":
        r"""
        apply(SoSimplifyAction self, SoNode root)
        apply(SoSimplifyAction self, SoPath path)
        apply(SoSimplifyAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoSimplifyAction_apply(self, *args)

# Register SoSimplifyAction in _coin:
_coin.SoSimplifyAction_swigregister(SoSimplifyAction)

def SoSimplifyAction_getClassTypeId() -> "SoType":
    r"""SoSimplifyAction_getClassTypeId() -> SoType"""
    return _coin.SoSimplifyAction_getClassTypeId()

def SoSimplifyAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoSimplifyAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoSimplifyAction_addMethod(type, method)

def SoSimplifyAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoSimplifyAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoSimplifyAction_enableElement(type, stackindex)

def SoSimplifyAction_initClass() -> "void":
    r"""SoSimplifyAction_initClass()"""
    return _coin.SoSimplifyAction_initClass()

class SoReorganizeAction(SoSimplifyAction):
    r"""Proxy of C++ SoReorganizeAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoReorganizeAction self) -> SoType"""
        return _coin.SoReorganizeAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoReorganizeAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoReorganizeAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoReorganizeAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoReorganizeAction_initClass()

    def __init__(self, simplifier: "SoSimplifier *"=None):
        r"""__init__(SoReorganizeAction self, SoSimplifier * simplifier=None) -> SoReorganizeAction"""
        _coin.SoReorganizeAction_swiginit(self, _coin.new_SoReorganizeAction(simplifier))
    __swig_destroy__ = _coin.delete_SoReorganizeAction

    def getSimplifiedSceneGraph(self) -> "SoSeparator *":
        r"""getSimplifiedSceneGraph(SoReorganizeAction self) -> SoSeparator"""
        return _coin.SoReorganizeAction_getSimplifiedSceneGraph(self)

    def generateNormals(self, onoff: "SbBool") -> "void":
        r"""generateNormals(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateNormals(self, onoff)

    def areNormalGenerated(self) -> "SbBool":
        r"""areNormalGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areNormalGenerated(self)

    def generateTriangleStrips(self, onoff: "SbBool") -> "void":
        r"""generateTriangleStrips(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTriangleStrips(self, onoff)

    def areTriangleStripGenerated(self) -> "SbBool":
        r"""areTriangleStripGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areTriangleStripGenerated(self)

    def generateTexCoords(self, onoff: "SbBool") -> "void":
        r"""generateTexCoords(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTexCoords(self, onoff)

    def areTexCoordsGenerated(self) -> "SbBool":
        r"""areTexCoordsGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areTexCoordsGenerated(self)

    def generateVPNodes(self, onoff: "SbBool") -> "void":
        r"""generateVPNodes(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateVPNodes(self, onoff)

    def areVPNodesGenerated(self) -> "SbBool":
        r"""areVPNodesGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areVPNodesGenerated(self)

    def matchIndexArrays(self, onoff: "SbBool") -> "void":
        r"""matchIndexArrays(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_matchIndexArrays(self, onoff)

    def areIndexArraysMatched(self) -> "SbBool":
        r"""areIndexArraysMatched(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areIndexArraysMatched(self)

    def getSimplifier(self) -> "SoSimplifier *":
        r"""getSimplifier(SoReorganizeAction self) -> SoSimplifier *"""
        return _coin.SoReorganizeAction_getSimplifier(self)

    def apply(self, *args) -> "void":
        r"""
        apply(SoReorganizeAction self, SoNode root)
        apply(SoReorganizeAction self, SoPath path)
        apply(SoReorganizeAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoReorganizeAction_apply(self, *args)

    @staticmethod
    def startReport(msg: "char const *") -> "void":
        r"""startReport(char const * msg)"""
        return _coin.SoReorganizeAction_startReport(msg)

    @staticmethod
    def finishReport() -> "void":
        r"""finishReport()"""
        return _coin.SoReorganizeAction_finishReport()

# Register SoReorganizeAction in _coin:
_coin.SoReorganizeAction_swigregister(SoReorganizeAction)

def SoReorganizeAction_getClassTypeId() -> "SoType":
    r"""SoReorganizeAction_getClassTypeId() -> SoType"""
    return _coin.SoReorganizeAction_getClassTypeId()

def SoReorganizeAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoReorganizeAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoReorganizeAction_addMethod(type, method)

def SoReorganizeAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoReorganizeAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoReorganizeAction_enableElement(type, stackindex)

def SoReorganizeAction_initClass() -> "void":
    r"""SoReorganizeAction_initClass()"""
    return _coin.SoReorganizeAction_initClass()

def SoReorganizeAction_startReport(msg: "char const *") -> "void":
    r"""SoReorganizeAction_startReport(char const * msg)"""
    return _coin.SoReorganizeAction_startReport(msg)

def SoReorganizeAction_finishReport() -> "void":
    r"""SoReorganizeAction_finishReport()"""
    return _coin.SoReorganizeAction_finishReport()

class SoWriteAction(SoAction):
    r"""Proxy of C++ SoWriteAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoWriteAction self) -> SoType"""
        return _coin.SoWriteAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWriteAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoWriteAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoWriteAction_enableElement(type, stackindex)

    def __init__(self, *args):
        r"""
        __init__(SoWriteAction self) -> SoWriteAction
        __init__(SoWriteAction self, SoOutput out) -> SoWriteAction
        """
        _coin.SoWriteAction_swiginit(self, _coin.new_SoWriteAction(*args))
    __swig_destroy__ = _coin.delete_SoWriteAction

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoWriteAction_initClass()

    def getOutput(self) -> "SoOutput *":
        r"""getOutput(SoWriteAction self) -> SoOutput"""
        return _coin.SoWriteAction_getOutput(self)

    def continueToApply(self, *args) -> "void":
        r"""
        continueToApply(SoWriteAction self, SoNode node)
        continueToApply(SoWriteAction self, SoPath path)
        """
        return _coin.SoWriteAction_continueToApply(self, *args)

# Register SoWriteAction in _coin:
_coin.SoWriteAction_swigregister(SoWriteAction)

def SoWriteAction_getClassTypeId() -> "SoType":
    r"""SoWriteAction_getClassTypeId() -> SoType"""
    return _coin.SoWriteAction_getClassTypeId()

def SoWriteAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoWriteAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoWriteAction_addMethod(type, method)

def SoWriteAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoWriteAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoWriteAction_enableElement(type, stackindex)

def SoWriteAction_initClass() -> "void":
    r"""SoWriteAction_initClass()"""
    return _coin.SoWriteAction_initClass()

class SoAudioRenderAction(SoAction):
    r"""Proxy of C++ SoAudioRenderAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoAudioRenderAction self) -> SoType"""
        return _coin.SoAudioRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAudioRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoAudioRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoAudioRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAudioRenderAction_initClass()

    def __init__(self):
        r"""__init__(SoAudioRenderAction self) -> SoAudioRenderAction"""
        _coin.SoAudioRenderAction_swiginit(self, _coin.new_SoAudioRenderAction())
    __swig_destroy__ = _coin.delete_SoAudioRenderAction

    @staticmethod
    def callDoAction(action: "SoAction", node: "SoNode") -> "void":
        r"""callDoAction(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callDoAction(action, node)

    @staticmethod
    def callAudioRender(action: "SoAction", node: "SoNode") -> "void":
        r"""callAudioRender(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callAudioRender(action, node)

# Register SoAudioRenderAction in _coin:
_coin.SoAudioRenderAction_swigregister(SoAudioRenderAction)

def SoAudioRenderAction_getClassTypeId() -> "SoType":
    r"""SoAudioRenderAction_getClassTypeId() -> SoType"""
    return _coin.SoAudioRenderAction_getClassTypeId()

def SoAudioRenderAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoAudioRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoAudioRenderAction_addMethod(type, method)

def SoAudioRenderAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoAudioRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoAudioRenderAction_enableElement(type, stackindex)

def SoAudioRenderAction_initClass() -> "void":
    r"""SoAudioRenderAction_initClass()"""
    return _coin.SoAudioRenderAction_initClass()

def SoAudioRenderAction_callDoAction(action: "SoAction", node: "SoNode") -> "void":
    r"""SoAudioRenderAction_callDoAction(SoAction action, SoNode node)"""
    return _coin.SoAudioRenderAction_callDoAction(action, node)

def SoAudioRenderAction_callAudioRender(action: "SoAction", node: "SoNode") -> "void":
    r"""SoAudioRenderAction_callAudioRender(SoAction action, SoNode node)"""
    return _coin.SoAudioRenderAction_callAudioRender(action, node)

class SoIntersectingPrimitive(object):
    r"""Proxy of C++ SoIntersectingPrimitive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    path = property(_coin.SoIntersectingPrimitive_path_get, _coin.SoIntersectingPrimitive_path_set, doc=r"""path : p.SoPath""")
    SEGMENT = _coin.SoIntersectingPrimitive_SEGMENT
    
    LINE_SEGMENT = _coin.SoIntersectingPrimitive_LINE_SEGMENT
    
    TRIANGLE = _coin.SoIntersectingPrimitive_TRIANGLE
    
    type = property(_coin.SoIntersectingPrimitive_type_get, _coin.SoIntersectingPrimitive_type_set, doc=r"""type : enum SoIntersectingPrimitive::PrimitiveType""")
    vertex = property(_coin.SoIntersectingPrimitive_vertex_get, _coin.SoIntersectingPrimitive_vertex_set, doc=r"""vertex : a(3).SbVec3f""")
    xf_vertex = property(_coin.SoIntersectingPrimitive_xf_vertex_get, _coin.SoIntersectingPrimitive_xf_vertex_set, doc=r"""xf_vertex : a(3).SbVec3f""")

    def __init__(self):
        r"""__init__(SoIntersectingPrimitive self) -> SoIntersectingPrimitive"""
        _coin.SoIntersectingPrimitive_swiginit(self, _coin.new_SoIntersectingPrimitive())
    __swig_destroy__ = _coin.delete_SoIntersectingPrimitive

# Register SoIntersectingPrimitive in _coin:
_coin.SoIntersectingPrimitive_swigregister(SoIntersectingPrimitive)

class SoIntersectionDetectionAction(SoAction):
    r"""Proxy of C++ SoIntersectionDetectionAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIntersectionDetectionAction self) -> SoType"""
        return _coin.SoIntersectionDetectionAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIntersectionDetectionAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoIntersectionDetectionAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoIntersectionDetectionAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIntersectionDetectionAction_initClass()

    def __init__(self):
        r"""__init__(SoIntersectionDetectionAction self) -> SoIntersectionDetectionAction"""
        _coin.SoIntersectionDetectionAction_swiginit(self, _coin.new_SoIntersectionDetectionAction())
    __swig_destroy__ = _coin.delete_SoIntersectionDetectionAction
    NEXT_PRIMITIVE = _coin.SoIntersectionDetectionAction_NEXT_PRIMITIVE
    
    NEXT_SHAPE = _coin.SoIntersectionDetectionAction_NEXT_SHAPE
    
    ABORT = _coin.SoIntersectionDetectionAction_ABORT
    

    def setIntersectionDetectionEpsilon(self, epsilon: "float") -> "void":
        r"""setIntersectionDetectionEpsilon(SoIntersectionDetectionAction self, float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionDetectionEpsilon(self, epsilon)

    def getIntersectionDetectionEpsilon(self) -> "float":
        r"""getIntersectionDetectionEpsilon(SoIntersectionDetectionAction self) -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionDetectionEpsilon(self)

    @staticmethod
    def setIntersectionEpsilon(epsilon: "float") -> "void":
        r"""setIntersectionEpsilon(float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon)

    @staticmethod
    def getIntersectionEpsilon() -> "float":
        r"""getIntersectionEpsilon() -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()

    def setTypeEnabled(self, type: "SoType", enable: "SbBool") -> "void":
        r"""setTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setTypeEnabled(self, type, enable)

    def isTypeEnabled(self, type: "SoType", checkgroups: "SbBool"=0) -> "SbBool":
        r"""isTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool checkgroups=0) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isTypeEnabled(self, type, checkgroups)

    def setManipsEnabled(self, enable: "SbBool") -> "void":
        r"""setManipsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setManipsEnabled(self, enable)

    def isManipsEnabled(self) -> "SbBool":
        r"""isManipsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isManipsEnabled(self)

    def setDraggersEnabled(self, enable: "SbBool") -> "void":
        r"""setDraggersEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setDraggersEnabled(self, enable)

    def isDraggersEnabled(self) -> "SbBool":
        r"""isDraggersEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isDraggersEnabled(self)

    def setShapeInternalsEnabled(self, enable: "SbBool") -> "void":
        r"""setShapeInternalsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setShapeInternalsEnabled(self, enable)

    def isShapeInternalsEnabled(self) -> "SbBool":
        r"""isShapeInternalsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isShapeInternalsEnabled(self)

    def apply(self, *args) -> "void":
        r"""
        apply(SoIntersectionDetectionAction self, SoNode node)
        apply(SoIntersectionDetectionAction self, SoPath path)
        apply(SoIntersectionDetectionAction self, SoPathList paths, SbBool obeysRules=0)
        """
        return _coin.SoIntersectionDetectionAction_apply(self, *args)

    def addVisitationCallback(self, *args) -> "void":
        r"""
        addVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)
        addVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)
        """
        return _coin.SoIntersectionDetectionAction_addVisitationCallback(self, *args)

    def removeVisitationCallback(self, *args) -> "void":
        r"""
        removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)
        removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)
        """
        return _coin.SoIntersectionDetectionAction_removeVisitationCallback(self, *args)

    def setFilterCallback(self, *args) -> "void":
        r"""
        setFilterCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionFilterCB * cb, void * closure=None)
        setFilterCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        """
        return _coin.SoIntersectionDetectionAction_setFilterCallback(self, *args)

    def addIntersectionCallback(self, *args) -> "void":
        r"""
        addIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
        addIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        """
        return _coin.SoIntersectionDetectionAction_addIntersectionCallback(self, *args)

    def removeIntersectionCallback(self, *args) -> "void":
        r"""
        removeIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
        removeIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        """
        return _coin.SoIntersectionDetectionAction_removeIntersectionCallback(self, *args)

# Register SoIntersectionDetectionAction in _coin:
_coin.SoIntersectionDetectionAction_swigregister(SoIntersectionDetectionAction)

def SoIntersectionDetectionAction_getClassTypeId() -> "SoType":
    r"""SoIntersectionDetectionAction_getClassTypeId() -> SoType"""
    return _coin.SoIntersectionDetectionAction_getClassTypeId()

def SoIntersectionDetectionAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoIntersectionDetectionAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoIntersectionDetectionAction_addMethod(type, method)

def SoIntersectionDetectionAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoIntersectionDetectionAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoIntersectionDetectionAction_enableElement(type, stackindex)

def SoIntersectionDetectionAction_initClass() -> "void":
    r"""SoIntersectionDetectionAction_initClass()"""
    return _coin.SoIntersectionDetectionAction_initClass()

def SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon: "float") -> "void":
    r"""SoIntersectionDetectionAction_setIntersectionEpsilon(float epsilon)"""
    return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon)

def SoIntersectionDetectionAction_getIntersectionEpsilon() -> "float":
    r"""SoIntersectionDetectionAction_getIntersectionEpsilon() -> float"""
    return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()

class SoToVRMLAction(SoAction):
    r"""Proxy of C++ SoToVRMLAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoToVRMLAction self) -> SoType"""
        return _coin.SoToVRMLAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoToVRMLAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRMLAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoToVRMLAction_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoToVRMLAction_initClass()

    def __init__(self):
        r"""__init__(SoToVRMLAction self) -> SoToVRMLAction"""
        _coin.SoToVRMLAction_swiginit(self, _coin.new_SoToVRMLAction())
    __swig_destroy__ = _coin.delete_SoToVRMLAction

    def apply(self, *args) -> "void":
        r"""
        apply(SoToVRMLAction self, SoNode node)
        apply(SoToVRMLAction self, SoPath path)
        apply(SoToVRMLAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoToVRMLAction_apply(self, *args)

    def getVRMLSceneGraph(self) -> "SoNode *":
        r"""getVRMLSceneGraph(SoToVRMLAction self) -> SoNode"""
        return _coin.SoToVRMLAction_getVRMLSceneGraph(self)

    def expandSoFile(self, flag: "SbBool") -> "void":
        r"""expandSoFile(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandSoFile(self, flag)

    def areSoFileExpanded(self) -> "SbBool":
        r"""areSoFileExpanded(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areSoFileExpanded(self)

    def setUrlName(self, name: "SbString") -> "void":
        r"""setUrlName(SoToVRMLAction self, SbString name)"""
        return _coin.SoToVRMLAction_setUrlName(self, name)

    def getUrlName(self) -> "SbString":
        r"""getUrlName(SoToVRMLAction self) -> SbString"""
        return _coin.SoToVRMLAction_getUrlName(self)

    def writeTexCoords(self, flag: "SbBool") -> "void":
        r"""writeTexCoords(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_writeTexCoords(self, flag)

    def areTexCoordWritten(self) -> "SbBool":
        r"""areTexCoordWritten(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexCoordWritten(self)

    def expandTexture2Node(self, flag: "SbBool") -> "void":
        r"""expandTexture2Node(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandTexture2Node(self, flag)

    def areTexture2NodeExpanded(self) -> "SbBool":
        r"""areTexture2NodeExpanded(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexture2NodeExpanded(self)

    def keepUnknownNodes(self, flag: "SbBool") -> "void":
        r"""keepUnknownNodes(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_keepUnknownNodes(self, flag)

    def areUnknownNodeKept(self) -> "SbBool":
        r"""areUnknownNodeKept(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areUnknownNodeKept(self)

    def convertInlineNodes(self, flag: "SbBool") -> "void":
        r"""convertInlineNodes(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_convertInlineNodes(self, flag)

    def doConvertInlineNodes(self) -> "SbBool":
        r"""doConvertInlineNodes(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_doConvertInlineNodes(self)

    def conditionalConversion(self, flag: "SbBool") -> "void":
        r"""conditionalConversion(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_conditionalConversion(self, flag)

    def doConditionalConversion(self) -> "SbBool":
        r"""doConditionalConversion(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_doConditionalConversion(self)

    def setVerbosity(self, flag: "SbBool") -> "void":
        r"""setVerbosity(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_setVerbosity(self, flag)

    def isVerbose(self) -> "SbBool":
        r"""isVerbose(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_isVerbose(self)

# Register SoToVRMLAction in _coin:
_coin.SoToVRMLAction_swigregister(SoToVRMLAction)

def SoToVRMLAction_getClassTypeId() -> "SoType":
    r"""SoToVRMLAction_getClassTypeId() -> SoType"""
    return _coin.SoToVRMLAction_getClassTypeId()

def SoToVRMLAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoToVRMLAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoToVRMLAction_addMethod(type, method)

def SoToVRMLAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoToVRMLAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoToVRMLAction_enableElement(type, stackindex)

def SoToVRMLAction_initClass() -> "void":
    r"""SoToVRMLAction_initClass()"""
    return _coin.SoToVRMLAction_initClass()

class SoToVRML2Action(SoToVRMLAction):
    r"""Proxy of C++ SoToVRML2Action class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoToVRML2Action self) -> SoType"""
        return _coin.SoToVRML2Action_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoToVRML2Action_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRML2Action_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoToVRML2Action_enableElement(type, stackindex)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoToVRML2Action_initClass()

    def __init__(self):
        r"""__init__(SoToVRML2Action self) -> SoToVRML2Action"""
        _coin.SoToVRML2Action_swiginit(self, _coin.new_SoToVRML2Action())
    __swig_destroy__ = _coin.delete_SoToVRML2Action

    def apply(self, *args) -> "void":
        r"""
        apply(SoToVRML2Action self, SoNode node)
        apply(SoToVRML2Action self, SoPath path)
        apply(SoToVRML2Action self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoToVRML2Action_apply(self, *args)

    def getVRML2SceneGraph(self) -> "SoVRMLGroup *":
        r"""getVRML2SceneGraph(SoToVRML2Action self) -> SoVRMLGroup"""
        return _coin.SoToVRML2Action_getVRML2SceneGraph(self)

    def reuseAppearanceNodes(self, appearance: "SbBool") -> "void":
        r"""reuseAppearanceNodes(SoToVRML2Action self, SbBool appearance)"""
        return _coin.SoToVRML2Action_reuseAppearanceNodes(self, appearance)

    def doReuseAppearanceNodes(self) -> "SbBool":
        r"""doReuseAppearanceNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReuseAppearanceNodes(self)

    def reusePropertyNodes(self, property: "SbBool") -> "void":
        r"""reusePropertyNodes(SoToVRML2Action self, SbBool property)"""
        return _coin.SoToVRML2Action_reusePropertyNodes(self, property)

    def doReusePropertyNodes(self) -> "SbBool":
        r"""doReusePropertyNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReusePropertyNodes(self)

    def reuseGeometryNodes(self, geometry: "SbBool") -> "void":
        r"""reuseGeometryNodes(SoToVRML2Action self, SbBool geometry)"""
        return _coin.SoToVRML2Action_reuseGeometryNodes(self, geometry)

    def doReuseGeometryNodes(self) -> "SbBool":
        r"""doReuseGeometryNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReuseGeometryNodes(self)

# Register SoToVRML2Action in _coin:
_coin.SoToVRML2Action_swigregister(SoToVRML2Action)

def SoToVRML2Action_getClassTypeId() -> "SoType":
    r"""SoToVRML2Action_getClassTypeId() -> SoType"""
    return _coin.SoToVRML2Action_getClassTypeId()

def SoToVRML2Action_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoToVRML2Action_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoToVRML2Action_addMethod(type, method)

def SoToVRML2Action_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoToVRML2Action_enableElement(SoType type, int const stackindex)"""
    return _coin.SoToVRML2Action_enableElement(type, stackindex)

def SoToVRML2Action_initClass() -> "void":
    r"""SoToVRML2Action_initClass()"""
    return _coin.SoToVRML2Action_initClass()

class SoHardCopy(object):
    r"""Proxy of C++ SoHardCopy class."""

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

    @staticmethod
    def init() -> "void":
        r"""init()"""
        return _coin.SoHardCopy_init()

    @staticmethod
    def getProductName() -> "char const *":
        r"""getProductName() -> char const *"""
        return _coin.SoHardCopy_getProductName()

    @staticmethod
    def getVersion() -> "char const *":
        r"""getVersion() -> char const *"""
        return _coin.SoHardCopy_getVersion()

    def __init__(self):
        r"""__init__(SoHardCopy self) -> SoHardCopy"""
        _coin.SoHardCopy_swiginit(self, _coin.new_SoHardCopy())
    __swig_destroy__ = _coin.delete_SoHardCopy

# Register SoHardCopy in _coin:
_coin.SoHardCopy_swigregister(SoHardCopy)

def SoHardCopy_init() -> "void":
    r"""SoHardCopy_init()"""
    return _coin.SoHardCopy_init()

def SoHardCopy_getProductName() -> "char const *":
    r"""SoHardCopy_getProductName() -> char const *"""
    return _coin.SoHardCopy_getProductName()

def SoHardCopy_getVersion() -> "char const *":
    r"""SoHardCopy_getVersion() -> char const *"""
    return _coin.SoHardCopy_getVersion()

class SoVectorOutput(object):
    r"""Proxy of C++ SoVectorOutput class."""

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

    def __init__(self):
        r"""__init__(SoVectorOutput self) -> SoVectorOutput"""
        _coin.SoVectorOutput_swiginit(self, _coin.new_SoVectorOutput())
    __swig_destroy__ = _coin.delete_SoVectorOutput

    def openFile(self, filename: "char const *") -> "SbBool":
        r"""openFile(SoVectorOutput self, char const * filename) -> SbBool"""
        return _coin.SoVectorOutput_openFile(self, filename)

    def closeFile(self) -> "void":
        r"""closeFile(SoVectorOutput self)"""
        return _coin.SoVectorOutput_closeFile(self)

    def getFilePointer(self) -> "FILE *":
        r"""getFilePointer(SoVectorOutput self) -> FILE *"""
        return _coin.SoVectorOutput_getFilePointer(self)

# Register SoVectorOutput in _coin:
_coin.SoVectorOutput_swigregister(SoVectorOutput)

class SoPSVectorOutput(SoVectorOutput):
    r"""Proxy of C++ SoPSVectorOutput class."""

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

    def __init__(self):
        r"""__init__(SoPSVectorOutput self) -> SoPSVectorOutput"""
        _coin.SoPSVectorOutput_swiginit(self, _coin.new_SoPSVectorOutput())
    __swig_destroy__ = _coin.delete_SoPSVectorOutput

    def setColored(self, flag: "SbBool"=1) -> "void":
        r"""setColored(SoPSVectorOutput self, SbBool flag=1)"""
        return _coin.SoPSVectorOutput_setColored(self, flag)

    def getColored(self) -> "SbBool":
        r"""getColored(SoPSVectorOutput self) -> SbBool"""
        return _coin.SoPSVectorOutput_getColored(self)

# Register SoPSVectorOutput in _coin:
_coin.SoPSVectorOutput_swigregister(SoPSVectorOutput)

class SoVectorizeAction(SoCallbackAction):
    r"""Proxy of C++ SoVectorizeAction class."""

    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 getTypeId(self) -> "SoType":
        r"""getTypeId(SoVectorizeAction self) -> SoType"""
        return _coin.SoVectorizeAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVectorizeAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizeAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoVectorizeAction_enableElement(type, stackindex)
    __swig_destroy__ = _coin.delete_SoVectorizeAction

    def getOutput(self) -> "SoVectorOutput *":
        r"""getOutput(SoVectorizeAction self) -> SoVectorOutput"""
        return _coin.SoVectorizeAction_getOutput(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVectorizeAction_initClass()
    INCH = _coin.SoVectorizeAction_INCH
    
    MM = _coin.SoVectorizeAction_MM
    
    METER = _coin.SoVectorizeAction_METER
    
    PORTRAIT = _coin.SoVectorizeAction_PORTRAIT
    
    LANDSCAPE = _coin.SoVectorizeAction_LANDSCAPE
    
    A0 = _coin.SoVectorizeAction_A0
    
    A1 = _coin.SoVectorizeAction_A1
    
    A2 = _coin.SoVectorizeAction_A2
    
    A3 = _coin.SoVectorizeAction_A3
    
    A4 = _coin.SoVectorizeAction_A4
    
    A5 = _coin.SoVectorizeAction_A5
    
    A6 = _coin.SoVectorizeAction_A6
    
    A7 = _coin.SoVectorizeAction_A7
    
    A8 = _coin.SoVectorizeAction_A8
    
    A9 = _coin.SoVectorizeAction_A9
    
    A10 = _coin.SoVectorizeAction_A10
    

    def apply(self, *args) -> "void":
        r"""
        apply(SoVectorizeAction self, SoNode node)
        apply(SoVectorizeAction self, SoPath path)
        apply(SoVectorizeAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoVectorizeAction_apply(self, *args)

    def beginStandardPage(self, pagesize: "SoVectorizeAction::PageSize const &", border: "float const"=10.0) -> "void":
        r"""beginStandardPage(SoVectorizeAction self, SoVectorizeAction::PageSize const & pagesize, float const border=10.0)"""
        return _coin.SoVectorizeAction_beginStandardPage(self, pagesize, border)

    def beginPage(self, *args) -> "void":
        r"""beginPage(SoVectorizeAction self, SbVec2f startpagepos, SbVec2f pagesize, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_beginPage(self, *args)

    def endPage(self) -> "void":
        r"""endPage(SoVectorizeAction self)"""
        return _coin.SoVectorizeAction_endPage(self)

    def calibrate(self, vp: "SbViewportRegion") -> "void":
        r"""calibrate(SoVectorizeAction self, SbViewportRegion vp)"""
        return _coin.SoVectorizeAction_calibrate(self, vp)

    def beginViewport(self, *args) -> "void":
        r"""beginViewport(SoVectorizeAction self, SbVec2f startpos=SbVec2f(-1.0f, 1.0f), SbVec2f size=SbVec2f(-1.0f, -1.0f), SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_beginViewport(self, *args)

    def endViewport(self) -> "void":
        r"""endViewport(SoVectorizeAction self)"""
        return _coin.SoVectorizeAction_endViewport(self)

    def setOrientation(self, o: "SoVectorizeAction::Orientation") -> "void":
        r"""setOrientation(SoVectorizeAction self, SoVectorizeAction::Orientation o)"""
        return _coin.SoVectorizeAction_setOrientation(self, o)

    def getOrientation(self) -> "SoVectorizeAction::Orientation":
        r"""getOrientation(SoVectorizeAction self) -> SoVectorizeAction::Orientation"""
        return _coin.SoVectorizeAction_getOrientation(self)

    def setBackgroundColor(self, *args) -> "void":
        r"""setBackgroundColor(SoVectorizeAction self, SbBool bg, SbColor col=SbColor(0.0f, 0.0f, 0.0f))"""
        return _coin.SoVectorizeAction_setBackgroundColor(self, *args)

    def getBackgroundColor(self, col: "SbColor") -> "SbBool":
        r"""getBackgroundColor(SoVectorizeAction self, SbColor col) -> SbBool"""
        return _coin.SoVectorizeAction_getBackgroundColor(self, col)

    def setNominalWidth(self, *args) -> "void":
        r"""setNominalWidth(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_setNominalWidth(self, *args)

    def getNominalWidth(self, *args) -> "float":
        r"""getNominalWidth(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> float"""
        return _coin.SoVectorizeAction_getNominalWidth(self, *args)

    def setPixelImageSize(self, *args) -> "void":
        r"""setPixelImageSize(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_setPixelImageSize(self, *args)

    def getPixelImageSize(self, *args) -> "float":
        r"""getPixelImageSize(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> float"""
        return _coin.SoVectorizeAction_getPixelImageSize(self, *args)
    CIRCLE = _coin.SoVectorizeAction_CIRCLE
    
    SQUARE = _coin.SoVectorizeAction_SQUARE
    

    def setPointStyle(self, style: "SoVectorizeAction::PointStyle const &") -> "void":
        r"""setPointStyle(SoVectorizeAction self, SoVectorizeAction::PointStyle const & style)"""
        return _coin.SoVectorizeAction_setPointStyle(self, style)

    def getPointStyle(self) -> "SoVectorizeAction::PointStyle":
        r"""getPointStyle(SoVectorizeAction self) -> SoVectorizeAction::PointStyle"""
        return _coin.SoVectorizeAction_getPointStyle(self)

    def getPageStartpos(self) -> "SbVec2f const &":
        r"""getPageStartpos(SoVectorizeAction self) -> SbVec2f"""
        return _coin.SoVectorizeAction_getPageStartpos(self)

    def getPageSize(self) -> "SbVec2f const &":
        r"""getPageSize(SoVectorizeAction self) -> SbVec2f"""
        return _coin.SoVectorizeAction_getPageSize(self)
    REVERSE_ONLY_BLACK_AND_WHITE = _coin.SoVectorizeAction_REVERSE_ONLY_BLACK_AND_WHITE
    
    AS_IS = _coin.SoVectorizeAction_AS_IS
    
    REVERSE = _coin.SoVectorizeAction_REVERSE
    
    NO_JOIN = _coin.SoVectorizeAction_NO_JOIN
    
    MITERED_JOIN = _coin.SoVectorizeAction_MITERED_JOIN
    
    MITERED_BEVELED_JOIN = _coin.SoVectorizeAction_MITERED_BEVELED_JOIN
    
    BEVELED_JOIN = _coin.SoVectorizeAction_BEVELED_JOIN
    
    TRIANGULAR_JOIN = _coin.SoVectorizeAction_TRIANGULAR_JOIN
    
    ROUNDED_JOIN = _coin.SoVectorizeAction_ROUNDED_JOIN
    
    BUTT_END = _coin.SoVectorizeAction_BUTT_END
    
    SQUARE_END = _coin.SoVectorizeAction_SQUARE_END
    
    TRIANGULAR_END = _coin.SoVectorizeAction_TRIANGULAR_END
    
    ROUND_END = _coin.SoVectorizeAction_ROUND_END
    
    NO_HLHSR = _coin.SoVectorizeAction_NO_HLHSR
    
    HLHSR_SIMPLE_PAINTER = _coin.SoVectorizeAction_HLHSR_SIMPLE_PAINTER
    
    HLHSR_PAINTER = _coin.SoVectorizeAction_HLHSR_PAINTER
    
    HLHSR_PAINTER_SURFACE_REMOVAL = _coin.SoVectorizeAction_HLHSR_PAINTER_SURFACE_REMOVAL
    
    HIDDEN_LINES_REMOVAL = _coin.SoVectorizeAction_HIDDEN_LINES_REMOVAL
    

    def setDrawingDimensions(self, *args) -> "void":
        r"""
        setDrawingDimensions(SoVectorizeAction self, SbVec2f d, SoVectorizeAction::DimensionUnit u=MM)
        setDrawingDimensions(SoVectorizeAction self, float w, float h, SoVectorizeAction::DimensionUnit u=MM)
        """
        return _coin.SoVectorizeAction_setDrawingDimensions(self, *args)

    def getDrawingDimensions(self, *args) -> "SbVec2f":
        r"""getDrawingDimensions(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> SbVec2f"""
        return _coin.SoVectorizeAction_getDrawingDimensions(self, *args)

    def setStartPosition(self, *args) -> "void":
        r"""
        setStartPosition(SoVectorizeAction self, SbVec2f p, SoVectorizeAction::DimensionUnit u=MM)
        setStartPosition(SoVectorizeAction self, float x, float y, SoVectorizeAction::DimensionUnit u=MM)
        """
        return _coin.SoVectorizeAction_setStartPosition(self, *args)

    def getStartPosition(self, *args) -> "SbVec2f":
        r"""getStartPosition(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> SbVec2f"""
        return _coin.SoVectorizeAction_getStartPosition(self, *args)

    def setColorTranslationMethod(self, method: "SoVectorizeAction::ColorTranslationMethod") -> "void":
        r"""setColorTranslationMethod(SoVectorizeAction self, SoVectorizeAction::ColorTranslationMethod method)"""
        return _coin.SoVectorizeAction_setColorTranslationMethod(self, method)

    def getColorTranslationMethod(self) -> "SoVectorizeAction::ColorTranslationMethod":
        r"""getColorTranslationMethod(SoVectorizeAction self) -> SoVectorizeAction::ColorTranslationMethod"""
        return _coin.SoVectorizeAction_getColorTranslationMethod(self)

    def setLineEndStyle(self, style: "SoVectorizeAction::EndLineStyle") -> "void":
        r"""setLineEndStyle(SoVectorizeAction self, SoVectorizeAction::EndLineStyle style)"""
        return _coin.SoVectorizeAction_setLineEndStyle(self, style)

    def getLineEndStyle(self) -> "SoVectorizeAction::EndLineStyle":
        r"""getLineEndStyle(SoVectorizeAction self) -> SoVectorizeAction::EndLineStyle"""
        return _coin.SoVectorizeAction_getLineEndStyle(self)

    def setLineJoinsStyle(self, style: "SoVectorizeAction::JoinLineStyle") -> "void":
        r"""setLineJoinsStyle(SoVectorizeAction self, SoVectorizeAction::JoinLineStyle style)"""
        return _coin.SoVectorizeAction_setLineJoinsStyle(self, style)

    def getLineJoinsStyle(self) -> "SoVectorizeAction::JoinLineStyle":
        r"""getLineJoinsStyle(SoVectorizeAction self) -> SoVectorizeAction::JoinLineStyle"""
        return _coin.SoVectorizeAction_getLineJoinsStyle(self)

    def setHLHSRMode(self, mode: "SoVectorizeAction::HLHSRMode") -> "void":
        r"""setHLHSRMode(SoVectorizeAction self, SoVectorizeAction::HLHSRMode mode)"""
        return _coin.SoVectorizeAction_setHLHSRMode(self, mode)

    def getHLHSRMode(self) -> "SoVectorizeAction::HLHSRMode":
        r"""getHLHSRMode(SoVectorizeAction self) -> SoVectorizeAction::HLHSRMode"""
        return _coin.SoVectorizeAction_getHLHSRMode(self)

    def setBorder(self, *args) -> "void":
        r"""
        setBorder(SoVectorizeAction self, float width)
        setBorder(SoVectorizeAction self, float width, SbColor color)
        """
        return _coin.SoVectorizeAction_setBorder(self, *args)

    def setMiterLimit(self, limit: "float") -> "void":
        r"""setMiterLimit(SoVectorizeAction self, float limit)"""
        return _coin.SoVectorizeAction_setMiterLimit(self, limit)

    def getMiterLimit(self) -> "float":
        r"""getMiterLimit(SoVectorizeAction self) -> float"""
        return _coin.SoVectorizeAction_getMiterLimit(self)

    def setPenDescription(self, *args) -> "void":
        r"""setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None, float const * widths=None, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_setPenDescription(self, *args)

    def getPenDescription(self, *args) -> "void":
        r"""getPenDescription(SoVectorizeAction self, SbColor colors, float * widths, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_getPenDescription(self, *args)

    def getPenNum(self) -> "int":
        r"""getPenNum(SoVectorizeAction self) -> int"""
        return _coin.SoVectorizeAction_getPenNum(self)

    def setColorPriority(self, priority: "SbBool") -> "void":
        r"""setColorPriority(SoVectorizeAction self, SbBool priority)"""
        return _coin.SoVectorizeAction_setColorPriority(self, priority)

    def getColorPriority(self) -> "SbBool":
        r"""getColorPriority(SoVectorizeAction self) -> SbBool"""
        return _coin.SoVectorizeAction_getColorPriority(self)

    def enableLighting(self, flag: "SbBool") -> "void":
        r"""enableLighting(SoVectorizeAction self, SbBool flag)"""
        return _coin.SoVectorizeAction_enableLighting(self, flag)

    def isLightingEnabled(self) -> "SbBool":
        r"""isLightingEnabled(SoVectorizeAction self) -> SbBool"""
        return _coin.SoVectorizeAction_isLightingEnabled(self)

# Register SoVectorizeAction in _coin:
_coin.SoVectorizeAction_swigregister(SoVectorizeAction)

def SoVectorizeAction_getClassTypeId() -> "SoType":
    r"""SoVectorizeAction_getClassTypeId() -> SoType"""
    return _coin.SoVectorizeAction_getClassTypeId()

def SoVectorizeAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoVectorizeAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoVectorizeAction_addMethod(type, method)

def SoVectorizeAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoVectorizeAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoVectorizeAction_enableElement(type, stackindex)

def SoVectorizeAction_initClass() -> "void":
    r"""SoVectorizeAction_initClass()"""
    return _coin.SoVectorizeAction_initClass()

class SoMultiTextureCoordinateElement(SoElement):
    r"""Proxy of C++ SoMultiTextureCoordinateElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureCoordinateElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMultiTextureCoordinateElement_initClass()
    NONE = _coin.SoMultiTextureCoordinateElement_NONE
    
    TEXGEN = _coin.SoMultiTextureCoordinateElement_TEXGEN
    
    EXPLICIT = _coin.SoMultiTextureCoordinateElement_EXPLICIT
    
    FUNCTION = _coin.SoMultiTextureCoordinateElement_FUNCTION
    
    DEFAULT = _coin.SoMultiTextureCoordinateElement_DEFAULT
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_init(self, state)

    @staticmethod
    def setDefault(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
        r"""setDefault(SoState state, SoNode node, int const unit=0)"""
        return _coin.SoMultiTextureCoordinateElement_setDefault(state, node, unit)

    def getType(self, *args) -> "SoMultiTextureCoordinateElement::CoordType":
        r"""
        getType(SoMultiTextureCoordinateElement self, SoState state, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType
        getType(SoMultiTextureCoordinateElement self, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType
        """
        return _coin.SoMultiTextureCoordinateElement_getType(self, *args)

    @staticmethod
    def getInstance(state: "SoState") -> "SoMultiTextureCoordinateElement const *":
        r"""getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
        return _coin.SoMultiTextureCoordinateElement_getInstance(state)

    def getNum(self, unit: "int const"=0) -> "int32_t":
        r"""getNum(SoMultiTextureCoordinateElement self, int const unit=0) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getNum(self, unit)

    def is2D(self, unit: "int const"=0) -> "SbBool":
        r"""is2D(SoMultiTextureCoordinateElement self, int const unit=0) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_is2D(self, unit)

    def getDimension(self, unit: "int const"=0) -> "int32_t":
        r"""getDimension(SoMultiTextureCoordinateElement self, int const unit=0) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getDimension(self, unit)

    def getArrayPtr2(self, unit: "int const"=0) -> "SbVec2f const *":
        r"""getArrayPtr2(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec2f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr2(self, unit)

    def getArrayPtr3(self, unit: "int const"=0) -> "SbVec3f const *":
        r"""getArrayPtr3(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec3f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr3(self, unit)

    def getArrayPtr4(self, unit: "int const"=0) -> "SbVec4f const *":
        r"""getArrayPtr4(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr4(self, unit)

    def push(self, state: "SoState") -> "void":
        r"""push(SoMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_push(self, state)

    def matches(self, elem: "SoElement") -> "SbBool":
        r"""matches(SoMultiTextureCoordinateElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_matches(self, elem)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoMultiTextureCoordinateElement self) -> SoElement"""
        return _coin.SoMultiTextureCoordinateElement_copyMatchInfo(self)

    def get(self, *args) -> "SbVec4f const &":
        r"""
        get(SoMultiTextureCoordinateElement self, int const unit, SbVec3f point, SbVec3f normal) -> SbVec4f
        get(SoMultiTextureCoordinateElement self, SbVec3f point, SbVec3f normal) -> SbVec4f
        """
        return _coin.SoMultiTextureCoordinateElement_get(self, *args)

    @staticmethod
    def set2(*args) -> "void":
        r"""
        set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)
        set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)
        """
        return _coin.SoMultiTextureCoordinateElement_set2(*args)

    @staticmethod
    def set3(*args) -> "void":
        r"""
        set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)
        set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)
        """
        return _coin.SoMultiTextureCoordinateElement_set3(*args)

    @staticmethod
    def set4(*args) -> "void":
        r"""
        set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)
        set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)
        """
        return _coin.SoMultiTextureCoordinateElement_set4(*args)

    def get2(self, *args) -> "SbVec2f const &":
        r"""
        get2(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec2f
        get2(SoMultiTextureCoordinateElement self, int const index) -> SbVec2f
        """
        return _coin.SoMultiTextureCoordinateElement_get2(self, *args)

    def get3(self, *args) -> "SbVec3f const &":
        r"""
        get3(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec3f
        get3(SoMultiTextureCoordinateElement self, int const index) -> SbVec3f
        """
        return _coin.SoMultiTextureCoordinateElement_get3(self, *args)

    def get4(self, *args) -> "SbVec4f const &":
        r"""
        get4(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec4f
        get4(SoMultiTextureCoordinateElement self, int const index) -> SbVec4f
        """
        return _coin.SoMultiTextureCoordinateElement_get4(self, *args)

# Register SoMultiTextureCoordinateElement in _coin:
_coin.SoMultiTextureCoordinateElement_swigregister(SoMultiTextureCoordinateElement)

def SoMultiTextureCoordinateElement_getClassTypeId() -> "SoType":
    r"""SoMultiTextureCoordinateElement_getClassTypeId() -> SoType"""
    return _coin.SoMultiTextureCoordinateElement_getClassTypeId()

def SoMultiTextureCoordinateElement_getClassStackIndex() -> "int":
    r"""SoMultiTextureCoordinateElement_getClassStackIndex() -> int"""
    return _coin.SoMultiTextureCoordinateElement_getClassStackIndex()

def SoMultiTextureCoordinateElement_createInstance() -> "void *":
    r"""SoMultiTextureCoordinateElement_createInstance() -> void *"""
    return _coin.SoMultiTextureCoordinateElement_createInstance()

def SoMultiTextureCoordinateElement_initClass() -> "void":
    r"""SoMultiTextureCoordinateElement_initClass()"""
    return _coin.SoMultiTextureCoordinateElement_initClass()

def SoMultiTextureCoordinateElement_setDefault(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
    r"""SoMultiTextureCoordinateElement_setDefault(SoState state, SoNode node, int const unit=0)"""
    return _coin.SoMultiTextureCoordinateElement_setDefault(state, node, unit)

def SoMultiTextureCoordinateElement_getInstance(state: "SoState") -> "SoMultiTextureCoordinateElement const *":
    r"""SoMultiTextureCoordinateElement_getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
    return _coin.SoMultiTextureCoordinateElement_getInstance(state)

def SoMultiTextureCoordinateElement_set2(*args) -> "void":
    r"""
    SoMultiTextureCoordinateElement_set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)
    SoMultiTextureCoordinateElement_set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)
    """
    return _coin.SoMultiTextureCoordinateElement_set2(*args)

def SoMultiTextureCoordinateElement_set3(*args) -> "void":
    r"""
    SoMultiTextureCoordinateElement_set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)
    SoMultiTextureCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)
    """
    return _coin.SoMultiTextureCoordinateElement_set3(*args)

def SoMultiTextureCoordinateElement_set4(*args) -> "void":
    r"""
    SoMultiTextureCoordinateElement_set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)
    SoMultiTextureCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)
    """
    return _coin.SoMultiTextureCoordinateElement_set4(*args)

class SoShape(SoNode):
    r"""Proxy of C++ SoShape class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShape_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShape self) -> SoType"""
        return _coin.SoShape_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShape_initClass()
    TRIANGLE_STRIP = _coin.SoShape_TRIANGLE_STRIP
    
    TRIANGLE_FAN = _coin.SoShape_TRIANGLE_FAN
    
    TRIANGLES = _coin.SoShape_TRIANGLES
    
    POLYGON = _coin.SoShape_POLYGON
    
    QUADS = _coin.SoShape_QUADS
    
    QUAD_STRIP = _coin.SoShape_QUAD_STRIP
    
    POINTS = _coin.SoShape_POINTS
    
    LINES = _coin.SoShape_LINES
    
    LINE_STRIP = _coin.SoShape_LINE_STRIP
    

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoShape self) -> SbBool"""
        return _coin.SoShape_affectsState(self)

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoShape self, SoNotList nl)"""
        return _coin.SoShape_notify(self, nl)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoShape_getBoundingBox(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoShape self, SoGLRenderAction action)"""
        return _coin.SoShape_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoShape self, SoRayPickAction action)"""
        return _coin.SoShape_rayPick(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoShape self, SoCallbackAction action)"""
        return _coin.SoShape_callback(self, action)

    def computeBBox(self, action: "SoAction", box: "SbBox3f", center: "SbVec3f") -> "void":
        r"""computeBBox(SoShape self, SoAction action, SbBox3f box, SbVec3f center)"""
        return _coin.SoShape_computeBBox(self, action, box, center)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoShape self, SoGetPrimitiveCountAction action)"""
        return _coin.SoShape_getPrimitiveCount(self, action)

    @staticmethod
    def getScreenSize(state: "SoState", boundingbox: "SbBox3f", rectsize: "SbVec2s") -> "void":
        r"""getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
        return _coin.SoShape_getScreenSize(state, boundingbox, rectsize)

    @staticmethod
    def getDecimatedComplexity(state: "SoState", complexity: "float") -> "float":
        r"""getDecimatedComplexity(SoState state, float complexity) -> float"""
        return _coin.SoShape_getDecimatedComplexity(state, complexity)

    def getBoundingBoxCache(self) -> "SoBoundingBoxCache const *":
        r"""getBoundingBoxCache(SoShape self) -> SoBoundingBoxCache"""
        return _coin.SoShape_getBoundingBoxCache(self)

# Register SoShape in _coin:
_coin.SoShape_swigregister(SoShape)

def SoShape_getClassTypeId() -> "SoType":
    r"""SoShape_getClassTypeId() -> SoType"""
    return _coin.SoShape_getClassTypeId()

def SoShape_initClass() -> "void":
    r"""SoShape_initClass()"""
    return _coin.SoShape_initClass()

def SoShape_getScreenSize(state: "SoState", boundingbox: "SbBox3f", rectsize: "SbVec2s") -> "void":
    r"""SoShape_getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
    return _coin.SoShape_getScreenSize(state, boundingbox, rectsize)

def SoShape_getDecimatedComplexity(state: "SoState", complexity: "float") -> "float":
    r"""SoShape_getDecimatedComplexity(SoState state, float complexity) -> float"""
    return _coin.SoShape_getDecimatedComplexity(state, complexity)

class SoImage(SoShape):
    r"""Proxy of C++ SoImage class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoImage_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoImage self) -> SoType"""
        return _coin.SoImage_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoImage_initClass()

    def __init__(self):
        r"""__init__(SoImage self) -> SoImage"""
        _coin.SoImage_swiginit(self, _coin.new_SoImage())
    BOTTOM = _coin.SoImage_BOTTOM
    
    HALF = _coin.SoImage_HALF
    
    TOP = _coin.SoImage_TOP
    
    LEFT = _coin.SoImage_LEFT
    
    CENTER = _coin.SoImage_CENTER
    
    RIGHT = _coin.SoImage_RIGHT
    
    width = property(_coin.SoImage_width_get, _coin.SoImage_width_set, doc=r"""width : SoSFInt32""")
    height = property(_coin.SoImage_height_get, _coin.SoImage_height_set, doc=r"""height : SoSFInt32""")
    vertAlignment = property(_coin.SoImage_vertAlignment_get, _coin.SoImage_vertAlignment_set, doc=r"""vertAlignment : SoSFEnum""")
    horAlignment = property(_coin.SoImage_horAlignment_get, _coin.SoImage_horAlignment_set, doc=r"""horAlignment : SoSFEnum""")
    image = property(_coin.SoImage_image_get, _coin.SoImage_image_set, doc=r"""image : SoSFImage""")
    filename = property(_coin.SoImage_filename_get, _coin.SoImage_filename_set, doc=r"""filename : SoSFString""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoImage self, SoGLRenderAction action)"""
        return _coin.SoImage_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoImage self, SoRayPickAction action)"""
        return _coin.SoImage_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoImage self, SoGetPrimitiveCountAction action)"""
        return _coin.SoImage_getPrimitiveCount(self, action)

# Register SoImage in _coin:
_coin.SoImage_swigregister(SoImage)

def SoImage_getClassTypeId() -> "SoType":
    r"""SoImage_getClassTypeId() -> SoType"""
    return _coin.SoImage_getClassTypeId()

def SoImage_initClass() -> "void":
    r"""SoImage_initClass()"""
    return _coin.SoImage_initClass()

class SoVectorizePSAction(SoVectorizeAction):
    r"""Proxy of C++ SoVectorizePSAction class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVectorizePSAction self) -> SoType"""
        return _coin.SoVectorizePSAction_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVectorizePSAction_getClassTypeId()

    @staticmethod
    def addMethod(type: "SoType", method: "SoActionMethod") -> "void":
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizePSAction_addMethod(type, method)

    @staticmethod
    def enableElement(type: "SoType", stackindex: "int const") -> "void":
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoVectorizePSAction_enableElement(type, stackindex)

    def __init__(self):
        r"""__init__(SoVectorizePSAction self) -> SoVectorizePSAction"""
        _coin.SoVectorizePSAction_swiginit(self, _coin.new_SoVectorizePSAction())
    __swig_destroy__ = _coin.delete_SoVectorizePSAction

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVectorizePSAction_initClass()

    def setDefault2DFont(self, fontname: "SbString") -> "void":
        r"""setDefault2DFont(SoVectorizePSAction self, SbString fontname)"""
        return _coin.SoVectorizePSAction_setDefault2DFont(self, fontname)

    def getDefault2DFont(self) -> "SbString const &":
        r"""getDefault2DFont(SoVectorizePSAction self) -> SbString"""
        return _coin.SoVectorizePSAction_getDefault2DFont(self)

    def setGouraudThreshold(self, eps: "double const") -> "void":
        r"""setGouraudThreshold(SoVectorizePSAction self, double const eps)"""
        return _coin.SoVectorizePSAction_setGouraudThreshold(self, eps)

    def getOutput(self) -> "SoPSVectorOutput *":
        r"""getOutput(SoVectorizePSAction self) -> SoPSVectorOutput"""
        return _coin.SoVectorizePSAction_getOutput(self)

    def getPSOutput(self) -> "SoPSVectorOutput *":
        r"""getPSOutput(SoVectorizePSAction self) -> SoPSVectorOutput"""
        return _coin.SoVectorizePSAction_getPSOutput(self)

# Register SoVectorizePSAction in _coin:
_coin.SoVectorizePSAction_swigregister(SoVectorizePSAction)

def SoVectorizePSAction_getClassTypeId() -> "SoType":
    r"""SoVectorizePSAction_getClassTypeId() -> SoType"""
    return _coin.SoVectorizePSAction_getClassTypeId()

def SoVectorizePSAction_addMethod(type: "SoType", method: "SoActionMethod") -> "void":
    r"""SoVectorizePSAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoVectorizePSAction_addMethod(type, method)

def SoVectorizePSAction_enableElement(type: "SoType", stackindex: "int const") -> "void":
    r"""SoVectorizePSAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoVectorizePSAction_enableElement(type, stackindex)

def SoVectorizePSAction_initClass() -> "void":
    r"""SoVectorizePSAction_initClass()"""
    return _coin.SoVectorizePSAction_initClass()

class SoBundle(object):
    r"""Proxy of C++ SoBundle class."""

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

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

# Register SoBundle in _coin:
_coin.SoBundle_swigregister(SoBundle)

class SoMaterialBundle(SoBundle):
    r"""Proxy of C++ SoMaterialBundle class."""

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

    def __init__(self, action: "SoAction"):
        r"""__init__(SoMaterialBundle self, SoAction action) -> SoMaterialBundle"""
        _coin.SoMaterialBundle_swiginit(self, _coin.new_SoMaterialBundle(action))
    __swig_destroy__ = _coin.delete_SoMaterialBundle

    def setUpMultiple(self) -> "void":
        r"""setUpMultiple(SoMaterialBundle self)"""
        return _coin.SoMaterialBundle_setUpMultiple(self)

    def sendFirst(self) -> "void":
        r"""sendFirst(SoMaterialBundle self)"""
        return _coin.SoMaterialBundle_sendFirst(self)

    def forceSend(self, index: "int const") -> "void":
        r"""forceSend(SoMaterialBundle self, int const index)"""
        return _coin.SoMaterialBundle_forceSend(self, index)

    def isColorOnly(self) -> "SbBool":
        r"""isColorOnly(SoMaterialBundle self) -> SbBool"""
        return _coin.SoMaterialBundle_isColorOnly(self)

    def send(self, index: "int const", betweenbeginend: "SbBool const") -> "void":
        r"""send(SoMaterialBundle self, int const index, SbBool const betweenbeginend)"""
        return _coin.SoMaterialBundle_send(self, index, betweenbeginend)

# Register SoMaterialBundle in _coin:
_coin.SoMaterialBundle_swigregister(SoMaterialBundle)

class SbBSPTree(object):
    r"""Proxy of C++ SbBSPTree class."""

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

    def __init__(self, maxnodepts: "int const"=64, initsize: "int const"=4):
        r"""__init__(SbBSPTree self, int const maxnodepts=64, int const initsize=4) -> SbBSPTree"""
        _coin.SbBSPTree_swiginit(self, _coin.new_SbBSPTree(maxnodepts, initsize))
    __swig_destroy__ = _coin.delete_SbBSPTree

    def numPoints(self) -> "int":
        r"""numPoints(SbBSPTree self) -> int"""
        return _coin.SbBSPTree_numPoints(self)

    def getPoint(self, *args) -> "void":
        r"""
        getPoint(SbBSPTree self, int const idx) -> SbVec3f
        getPoint(SbBSPTree self, int const idx, SbVec3f pt)
        """
        return _coin.SbBSPTree_getPoint(self, *args)

    def getUserData(self, idx: "int const") -> "void *":
        r"""getUserData(SbBSPTree self, int const idx) -> void *"""
        return _coin.SbBSPTree_getUserData(self, idx)

    def setUserData(self, idx: "int const", data: "void *const") -> "void":
        r"""setUserData(SbBSPTree self, int const idx, void *const data)"""
        return _coin.SbBSPTree_setUserData(self, idx, data)

    def addPoint(self, pt: "SbVec3f", userdata: "void *const"=None) -> "int":
        r"""addPoint(SbBSPTree self, SbVec3f pt, void *const userdata=None) -> int"""
        return _coin.SbBSPTree_addPoint(self, pt, userdata)

    def removePoint(self, *args) -> "void":
        r"""
        removePoint(SbBSPTree self, SbVec3f pt) -> int
        removePoint(SbBSPTree self, int const idx)
        """
        return _coin.SbBSPTree_removePoint(self, *args)

    def findPoint(self, pos: "SbVec3f") -> "int":
        r"""findPoint(SbBSPTree self, SbVec3f pos) -> int"""
        return _coin.SbBSPTree_findPoint(self, pos)

    def clear(self, initsize: "int const"=4) -> "void":
        r"""clear(SbBSPTree self, int const initsize=4)"""
        return _coin.SbBSPTree_clear(self, initsize)

    def getBBox(self) -> "SbBox3f const &":
        r"""getBBox(SbBSPTree self) -> SbBox3f"""
        return _coin.SbBSPTree_getBBox(self)

    def getPointsArrayPtr(self) -> "SbVec3f const *":
        r"""getPointsArrayPtr(SbBSPTree self) -> SbVec3f"""
        return _coin.SbBSPTree_getPointsArrayPtr(self)

    def findPoints(self, *args) -> "void":
        r"""
        findPoints(SbBSPTree self, SbSphere sphere, SbIntList array)
        findPoints(SbBSPTree self, SbSphere sphere, SbList< int > & array)
        """
        return _coin.SbBSPTree_findPoints(self, *args)

    def findClosest(self, *args) -> "int":
        r"""
        findClosest(SbBSPTree self, SbVec3f pos) -> int
        findClosest(SbBSPTree self, SbSphere sphere, SbIntList array) -> int
        findClosest(SbBSPTree self, SbSphere sphere, SbList< int > & array) -> int
        """
        return _coin.SbBSPTree_findClosest(self, *args)

# Register SbBSPTree in _coin:
_coin.SbBSPTree_swigregister(SbBSPTree)

class SoNormalGenerator(object):
    r"""Proxy of C++ SoNormalGenerator class."""

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

    def __init__(self, ccw: "SbBool const", approxVertices: "int const"=64):
        r"""__init__(SoNormalGenerator self, SbBool const ccw, int const approxVertices=64) -> SoNormalGenerator"""
        _coin.SoNormalGenerator_swiginit(self, _coin.new_SoNormalGenerator(ccw, approxVertices))
    __swig_destroy__ = _coin.delete_SoNormalGenerator

    def reset(self, ccw: "SbBool const") -> "void":
        r"""reset(SoNormalGenerator self, SbBool const ccw)"""
        return _coin.SoNormalGenerator_reset(self, ccw)

    def beginPolygon(self) -> "void":
        r"""beginPolygon(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_beginPolygon(self)

    def polygonVertex(self, v: "SbVec3f") -> "void":
        r"""polygonVertex(SoNormalGenerator self, SbVec3f v)"""
        return _coin.SoNormalGenerator_polygonVertex(self, v)

    def endPolygon(self) -> "void":
        r"""endPolygon(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_endPolygon(self)

    def triangle(self, v0: "SbVec3f", v1: "SbVec3f", v2: "SbVec3f") -> "void":
        r"""triangle(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2)"""
        return _coin.SoNormalGenerator_triangle(self, v0, v1, v2)

    def quad(self, v0: "SbVec3f", v1: "SbVec3f", v2: "SbVec3f", v3: "SbVec3f") -> "void":
        r"""quad(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f v3)"""
        return _coin.SoNormalGenerator_quad(self, v0, v1, v2, v3)

    def generate(self, creaseAngle: "float const", striplens: "int32_t const *"=None, numstrips: "int const"=0) -> "void":
        r"""generate(SoNormalGenerator self, float const creaseAngle, int32_t const * striplens=None, int const numstrips=0)"""
        return _coin.SoNormalGenerator_generate(self, creaseAngle, striplens, numstrips)

    def generatePerStrip(self, striplens: "int32_t const *", numstrips: "int const") -> "void":
        r"""generatePerStrip(SoNormalGenerator self, int32_t const * striplens, int const numstrips)"""
        return _coin.SoNormalGenerator_generatePerStrip(self, striplens, numstrips)

    def generatePerFace(self) -> "void":
        r"""generatePerFace(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_generatePerFace(self)

    def generateOverall(self) -> "void":
        r"""generateOverall(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_generateOverall(self)

    def getNumNormals(self) -> "int":
        r"""getNumNormals(SoNormalGenerator self) -> int"""
        return _coin.SoNormalGenerator_getNumNormals(self)

    def setNumNormals(self, num: "int const") -> "void":
        r"""setNumNormals(SoNormalGenerator self, int const num)"""
        return _coin.SoNormalGenerator_setNumNormals(self, num)

    def getNormals(self) -> "SbVec3f const *":
        r"""getNormals(SoNormalGenerator self) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormals(self)

    def getNormal(self, i: "int32_t const") -> "SbVec3f const &":
        r"""getNormal(SoNormalGenerator self, int32_t const i) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormal(self, i)

    def setNormal(self, index: "int32_t const", normal: "SbVec3f") -> "void":
        r"""setNormal(SoNormalGenerator self, int32_t const index, SbVec3f normal)"""
        return _coin.SoNormalGenerator_setNormal(self, index, normal)

# Register SoNormalGenerator in _coin:
_coin.SoNormalGenerator_swigregister(SoNormalGenerator)

class SoNormalElement(SoReplacedElement):
    r"""Proxy of C++ SoNormalElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormalElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoNormalElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoNormalElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNormalElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoNormalElement self, SoState state)"""
        return _coin.SoNormalElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numNormals: "int32_t const", normals: "SbVec3f", normalsAreUnitLength: "SbBool const"=0) -> "void":
        r"""set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)"""
        return _coin.SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength)

    @staticmethod
    def getInstance(state: "SoState") -> "SoNormalElement const *":
        r"""getInstance(SoState state) -> SoNormalElement"""
        return _coin.SoNormalElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoNormalElement self) -> int32_t"""
        return _coin.SoNormalElement_getNum(self)

    def get(self, index: "int const") -> "SbVec3f const &":
        r"""get(SoNormalElement self, int const index) -> SbVec3f"""
        return _coin.SoNormalElement_get(self, index)

    def getArrayPtr(self) -> "SbVec3f const *":
        r"""getArrayPtr(SoNormalElement self) -> SbVec3f"""
        return _coin.SoNormalElement_getArrayPtr(self)

    def areNormalsUnitLength(self) -> "SbBool":
        r"""areNormalsUnitLength(SoNormalElement self) -> SbBool"""
        return _coin.SoNormalElement_areNormalsUnitLength(self)

# Register SoNormalElement in _coin:
_coin.SoNormalElement_swigregister(SoNormalElement)

def SoNormalElement_getClassTypeId() -> "SoType":
    r"""SoNormalElement_getClassTypeId() -> SoType"""
    return _coin.SoNormalElement_getClassTypeId()

def SoNormalElement_getClassStackIndex() -> "int":
    r"""SoNormalElement_getClassStackIndex() -> int"""
    return _coin.SoNormalElement_getClassStackIndex()

def SoNormalElement_createInstance() -> "void *":
    r"""SoNormalElement_createInstance() -> void *"""
    return _coin.SoNormalElement_createInstance()

def SoNormalElement_initClass() -> "void":
    r"""SoNormalElement_initClass()"""
    return _coin.SoNormalElement_initClass()

def SoNormalElement_set(state: "SoState", node: "SoNode", numNormals: "int32_t const", normals: "SbVec3f", normalsAreUnitLength: "SbBool const"=0) -> "void":
    r"""SoNormalElement_set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)"""
    return _coin.SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength)

def SoNormalElement_getInstance(state: "SoState") -> "SoNormalElement const *":
    r"""SoNormalElement_getInstance(SoState state) -> SoNormalElement"""
    return _coin.SoNormalElement_getInstance(state)

class SoGLNormalElement(SoNormalElement):
    r"""Proxy of C++ SoGLNormalElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLNormalElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLNormalElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLNormalElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLNormalElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLNormalElement self, SoState state)"""
        return _coin.SoGLNormalElement_init(self, state)

    def send(self, index: "int const") -> "void":
        r"""send(SoGLNormalElement self, int const index)"""
        return _coin.SoGLNormalElement_send(self, index)

# Register SoGLNormalElement in _coin:
_coin.SoGLNormalElement_swigregister(SoGLNormalElement)

def SoGLNormalElement_getClassTypeId() -> "SoType":
    r"""SoGLNormalElement_getClassTypeId() -> SoType"""
    return _coin.SoGLNormalElement_getClassTypeId()

def SoGLNormalElement_getClassStackIndex() -> "int":
    r"""SoGLNormalElement_getClassStackIndex() -> int"""
    return _coin.SoGLNormalElement_getClassStackIndex()

def SoGLNormalElement_createInstance() -> "void *":
    r"""SoGLNormalElement_createInstance() -> void *"""
    return _coin.SoGLNormalElement_createInstance()

def SoGLNormalElement_initClass() -> "void":
    r"""SoGLNormalElement_initClass()"""
    return _coin.SoGLNormalElement_initClass()

class SoNormalBundle(SoBundle):
    r"""Proxy of C++ SoNormalBundle class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    generator = property(_coin.SoNormalBundle_generator_get, _coin.SoNormalBundle_generator_set, doc=r"""generator : p.SoNormalGenerator""")

# Register SoNormalBundle in _coin:
_coin.SoNormalBundle_swigregister(SoNormalBundle)

class SoGLMultiTextureCoordinateElement(SoMultiTextureCoordinateElement):
    r"""Proxy of C++ SoGLMultiTextureCoordinateElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureCoordinateElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLMultiTextureCoordinateElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLMultiTextureCoordinateElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureCoordinateElement_pop(self, state, prevTopElement)

    def getType(self, unit: "int const"=0) -> "SoMultiTextureCoordinateElement::CoordType":
        r"""getType(SoGLMultiTextureCoordinateElement self, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType"""
        return _coin.SoGLMultiTextureCoordinateElement_getType(self, unit)

    @staticmethod
    def getInstance(state: "SoState") -> "SoGLMultiTextureCoordinateElement const *":
        r"""getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
        return _coin.SoGLMultiTextureCoordinateElement_getInstance(state)

    def initRender(self, enabled: "SbBool const *", maxenabled: "int const") -> "void":
        r"""initRender(SoGLMultiTextureCoordinateElement self, SbBool const * enabled, int const maxenabled)"""
        return _coin.SoGLMultiTextureCoordinateElement_initRender(self, enabled, maxenabled)

    def send(self, *args) -> "void":
        r"""
        send(SoGLMultiTextureCoordinateElement self, int const unit, int const index)
        send(SoGLMultiTextureCoordinateElement self, int const unit, int const index, SbVec3f c, SbVec3f n)
        send(SoGLMultiTextureCoordinateElement self, int const index)
        send(SoGLMultiTextureCoordinateElement self, int const index, SbVec3f c, SbVec3f n)
        """
        return _coin.SoGLMultiTextureCoordinateElement_send(self, *args)

    def initMulti(self, state: "SoState") -> "void":
        r"""initMulti(SoGLMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_initMulti(self, state)

# Register SoGLMultiTextureCoordinateElement in _coin:
_coin.SoGLMultiTextureCoordinateElement_swigregister(SoGLMultiTextureCoordinateElement)

def SoGLMultiTextureCoordinateElement_getClassTypeId() -> "SoType":
    r"""SoGLMultiTextureCoordinateElement_getClassTypeId() -> SoType"""
    return _coin.SoGLMultiTextureCoordinateElement_getClassTypeId()

def SoGLMultiTextureCoordinateElement_getClassStackIndex() -> "int":
    r"""SoGLMultiTextureCoordinateElement_getClassStackIndex() -> int"""
    return _coin.SoGLMultiTextureCoordinateElement_getClassStackIndex()

def SoGLMultiTextureCoordinateElement_createInstance() -> "void *":
    r"""SoGLMultiTextureCoordinateElement_createInstance() -> void *"""
    return _coin.SoGLMultiTextureCoordinateElement_createInstance()

def SoGLMultiTextureCoordinateElement_initClass() -> "void":
    r"""SoGLMultiTextureCoordinateElement_initClass()"""
    return _coin.SoGLMultiTextureCoordinateElement_initClass()

def SoGLMultiTextureCoordinateElement_getInstance(state: "SoState") -> "SoGLMultiTextureCoordinateElement const *":
    r"""SoGLMultiTextureCoordinateElement_getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
    return _coin.SoGLMultiTextureCoordinateElement_getInstance(state)

class SoTextureCoordinateBundle(SoBundle):
    r"""Proxy of C++ SoTextureCoordinateBundle class."""

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

    def __init__(self, action: "SoAction", forRendering: "SbBool const", setUpDefault: "SbBool const"=1):
        r"""__init__(SoTextureCoordinateBundle self, SoAction action, SbBool const forRendering, SbBool const setUpDefault=1) -> SoTextureCoordinateBundle"""
        _coin.SoTextureCoordinateBundle_swiginit(self, _coin.new_SoTextureCoordinateBundle(action, forRendering, setUpDefault))
    __swig_destroy__ = _coin.delete_SoTextureCoordinateBundle

    def needCoordinates(self) -> "SbBool":
        r"""needCoordinates(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_needCoordinates(self)

    def isFunction(self) -> "SbBool":
        r"""isFunction(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_isFunction(self)

    def get(self, *args) -> "SbVec4f const &":
        r"""
        get(SoTextureCoordinateBundle self, int const index) -> SbVec4f
        get(SoTextureCoordinateBundle self, SbVec3f point, SbVec3f normal) -> SbVec4f
        """
        return _coin.SoTextureCoordinateBundle_get(self, *args)

    def send(self, *args) -> "void":
        r"""
        send(SoTextureCoordinateBundle self, int const index)
        send(SoTextureCoordinateBundle self, int const index, SbVec3f point, SbVec3f normal)
        """
        return _coin.SoTextureCoordinateBundle_send(self, *args)

    def needIndices(self) -> "SbBool":
        r"""needIndices(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_needIndices(self)

# Register SoTextureCoordinateBundle in _coin:
_coin.SoTextureCoordinateBundle_swigregister(SoTextureCoordinateBundle)

class SoCache(object):
    r"""Proxy of C++ SoCache class."""

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

    def __init__(self, state: "SoState"):
        r"""__init__(SoCache self, SoState state) -> SoCache"""
        _coin.SoCache_swiginit(self, _coin.new_SoCache(state))

    def ref(self) -> "void":
        r"""ref(SoCache self)"""
        return _coin.SoCache_ref(self)

    def unref(self, state: "SoState"=None) -> "void":
        r"""unref(SoCache self, SoState state=None)"""
        return _coin.SoCache_unref(self, state)

    def addElement(self, elem: "SoElement") -> "void":
        r"""addElement(SoCache self, SoElement elem)"""
        return _coin.SoCache_addElement(self, elem)

    def addCacheDependency(self, state: "SoState", cache: "SoCache") -> "void":
        r"""addCacheDependency(SoCache self, SoState state, SoCache cache)"""
        return _coin.SoCache_addCacheDependency(self, state, cache)

    def isValid(self, state: "SoState") -> "SbBool":
        r"""isValid(SoCache self, SoState state) -> SbBool"""
        return _coin.SoCache_isValid(self, state)

    def getInvalidElement(self, state: "SoState") -> "SoElement const *":
        r"""getInvalidElement(SoCache self, SoState state) -> SoElement"""
        return _coin.SoCache_getInvalidElement(self, state)

    def invalidate(self) -> "void":
        r"""invalidate(SoCache self)"""
        return _coin.SoCache_invalidate(self)

# Register SoCache in _coin:
_coin.SoCache_swigregister(SoCache)

class SoBoundingBoxCache(SoCache):
    r"""Proxy of C++ SoBoundingBoxCache class."""

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

    def __init__(self, state: "SoState"):
        r"""__init__(SoBoundingBoxCache self, SoState state) -> SoBoundingBoxCache"""
        _coin.SoBoundingBoxCache_swiginit(self, _coin.new_SoBoundingBoxCache(state))
    __swig_destroy__ = _coin.delete_SoBoundingBoxCache

    def set(self, boundingbox: "SbXfBox3f", centerset: "SbBool", centerpoint: "SbVec3f") -> "void":
        r"""set(SoBoundingBoxCache self, SbXfBox3f boundingbox, SbBool centerset, SbVec3f centerpoint)"""
        return _coin.SoBoundingBoxCache_set(self, boundingbox, centerset, centerpoint)

    def getBox(self) -> "SbXfBox3f const &":
        r"""getBox(SoBoundingBoxCache self) -> SbXfBox3f"""
        return _coin.SoBoundingBoxCache_getBox(self)

    def getProjectedBox(self) -> "SbBox3f const &":
        r"""getProjectedBox(SoBoundingBoxCache self) -> SbBox3f"""
        return _coin.SoBoundingBoxCache_getProjectedBox(self)

    def isCenterSet(self) -> "SbBool":
        r"""isCenterSet(SoBoundingBoxCache self) -> SbBool"""
        return _coin.SoBoundingBoxCache_isCenterSet(self)

    def getCenter(self) -> "SbVec3f const &":
        r"""getCenter(SoBoundingBoxCache self) -> SbVec3f"""
        return _coin.SoBoundingBoxCache_getCenter(self)

    @staticmethod
    def setHasLinesOrPoints(state: "SoState") -> "void":
        r"""setHasLinesOrPoints(SoState state)"""
        return _coin.SoBoundingBoxCache_setHasLinesOrPoints(state)

    def hasLinesOrPoints(self) -> "SbBool":
        r"""hasLinesOrPoints(SoBoundingBoxCache self) -> SbBool"""
        return _coin.SoBoundingBoxCache_hasLinesOrPoints(self)

# Register SoBoundingBoxCache in _coin:
_coin.SoBoundingBoxCache_swigregister(SoBoundingBoxCache)

def SoBoundingBoxCache_setHasLinesOrPoints(state: "SoState") -> "void":
    r"""SoBoundingBoxCache_setHasLinesOrPoints(SoState state)"""
    return _coin.SoBoundingBoxCache_setHasLinesOrPoints(state)

class SoConvexDataCache(SoCache):
    r"""Proxy of C++ SoConvexDataCache class."""

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

    def __init__(self, state: "SoState"):
        r"""__init__(SoConvexDataCache self, SoState state) -> SoConvexDataCache"""
        _coin.SoConvexDataCache_swiginit(self, _coin.new_SoConvexDataCache(state))
    __swig_destroy__ = _coin.delete_SoConvexDataCache
    NONE = _coin.SoConvexDataCache_NONE
    
    PER_FACE = _coin.SoConvexDataCache_PER_FACE
    
    PER_FACE_INDEXED = _coin.SoConvexDataCache_PER_FACE_INDEXED
    
    PER_VERTEX = _coin.SoConvexDataCache_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoConvexDataCache_PER_VERTEX_INDEXED
    

    def generate(self, coords: "SoCoordinateElement", coordindices: "int32_t const *", numcoordindices: "int const", matindices: "int32_t const *", normindices: "int32_t const *", texindices: "int32_t const *", matbinding: "SoConvexDataCache::Binding const", normbinding: "SoConvexDataCache::Binding const", texbinding: "SoConvexDataCache::Binding const") -> "void":
        r"""generate(SoConvexDataCache self, SoCoordinateElement coords, int32_t const * coordindices, int const numcoordindices, int32_t const * matindices, int32_t const * normindices, int32_t const * texindices, SoConvexDataCache::Binding const matbinding, SoConvexDataCache::Binding const normbinding, SoConvexDataCache::Binding const texbinding)"""
        return _coin.SoConvexDataCache_generate(self, coords, coordindices, numcoordindices, matindices, normindices, texindices, matbinding, normbinding, texbinding)

    def getCoordIndices(self) -> "int32_t const *":
        r"""getCoordIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getCoordIndices(self)

    def getNumCoordIndices(self) -> "int":
        r"""getNumCoordIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumCoordIndices(self)

    def getMaterialIndices(self) -> "int32_t const *":
        r"""getMaterialIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getMaterialIndices(self)

    def getNumMaterialIndices(self) -> "int":
        r"""getNumMaterialIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumMaterialIndices(self)

    def getNormalIndices(self) -> "int32_t const *":
        r"""getNormalIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getNormalIndices(self)

    def getNumNormalIndices(self) -> "int":
        r"""getNumNormalIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumNormalIndices(self)

    def getTexIndices(self) -> "int32_t const *":
        r"""getTexIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getTexIndices(self)

    def getNumTexIndices(self) -> "int":
        r"""getNumTexIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumTexIndices(self)

# Register SoConvexDataCache in _coin:
_coin.SoConvexDataCache_swigregister(SoConvexDataCache)

class SoGLCacheList(object):
    r"""Proxy of C++ SoGLCacheList class."""

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

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

# Register SoGLCacheList in _coin:
_coin.SoGLCacheList_swigregister(SoGLCacheList)

class SoGLLazyElement(SoLazyElement):
    r"""Proxy of C++ SoGLLazyElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLazyElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLazyElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLLazyElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLLazyElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLLazyElement self, SoState state)"""
        return _coin.SoGLLazyElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLLazyElement self, SoState state)"""
        return _coin.SoGLLazyElement_push(self, state)

    def pop(self, state: "SoState", prevtopelement: "SoElement") -> "void":
        r"""pop(SoGLLazyElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLLazyElement_pop(self, state, prevtopelement)

    @staticmethod
    def sendAllMaterial(state: "SoState") -> "void":
        r"""sendAllMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendAllMaterial(state)

    @staticmethod
    def sendNoMaterial(state: "SoState") -> "void":
        r"""sendNoMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendNoMaterial(state)

    @staticmethod
    def sendOnlyDiffuseColor(state: "SoState") -> "void":
        r"""sendOnlyDiffuseColor(SoState state)"""
        return _coin.SoGLLazyElement_sendOnlyDiffuseColor(state)

    @staticmethod
    def sendLightModel(state: "SoState", model: "int32_t const") -> "void":
        r"""sendLightModel(SoState state, int32_t const model)"""
        return _coin.SoGLLazyElement_sendLightModel(state, model)

    @staticmethod
    def sendPackedDiffuse(state: "SoState", diffuse: "uint32_t const") -> "void":
        r"""sendPackedDiffuse(SoState state, uint32_t const diffuse)"""
        return _coin.SoGLLazyElement_sendPackedDiffuse(state, diffuse)

    @staticmethod
    def sendFlatshading(state: "SoState", onoff: "SbBool const") -> "void":
        r"""sendFlatshading(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendFlatshading(state, onoff)

    @staticmethod
    def sendVertexOrdering(state: "SoState", ordering: "SoLazyElement::VertexOrdering const") -> "void":
        r"""sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"""
        return _coin.SoGLLazyElement_sendVertexOrdering(state, ordering)

    @staticmethod
    def sendTwosideLighting(state: "SoState", onoff: "SbBool const") -> "void":
        r"""sendTwosideLighting(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendTwosideLighting(state, onoff)

    @staticmethod
    def sendBackfaceCulling(state: "SoState", onoff: "SbBool const") -> "void":
        r"""sendBackfaceCulling(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendBackfaceCulling(state, onoff)

    def sendDiffuseByIndex(self, index: "int const") -> "void":
        r"""sendDiffuseByIndex(SoGLLazyElement self, int const index)"""
        return _coin.SoGLLazyElement_sendDiffuseByIndex(self, index)

    @staticmethod
    def isColorIndex(state: "SoState") -> "SbBool":
        r"""isColorIndex(SoState state) -> SbBool"""
        return _coin.SoGLLazyElement_isColorIndex(state)

    @staticmethod
    def getInstance(state: "SoState") -> "SoGLLazyElement *":
        r"""getInstance(SoState state) -> SoGLLazyElement"""
        return _coin.SoGLLazyElement_getInstance(state)

    def send(self, state: "SoState", mask: "uint32_t") -> "void":
        r"""send(SoGLLazyElement self, SoState state, uint32_t mask)"""
        return _coin.SoGLLazyElement_send(self, state, mask)

    def sendVPPacked(self, state: "SoState", pcolor: "unsigned char const *") -> "void":
        r"""sendVPPacked(SoGLLazyElement self, SoState state, unsigned char const * pcolor)"""
        return _coin.SoGLLazyElement_sendVPPacked(self, state, pcolor)

    def reset(self, state: "SoState", bitmask: "uint32_t") -> "void":
        r"""reset(SoGLLazyElement self, SoState state, uint32_t bitmask)"""
        return _coin.SoGLLazyElement_reset(self, state, bitmask)

    def setDiffuseElt(self, arg2: "SoNode", numcolors: "int32_t", colors: "SbColor", packer: "SoColorPacker") -> "void":
        r"""setDiffuseElt(SoGLLazyElement self, SoNode arg2, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
        return _coin.SoGLLazyElement_setDiffuseElt(self, arg2, numcolors, colors, packer)

    def setPackedElt(self, node: "SoNode", numcolors: "int32_t", colors: "uint32_t const *", packedtransparency: "SbBool const") -> "void":
        r"""setPackedElt(SoGLLazyElement self, SoNode node, int32_t numcolors, uint32_t const * colors, SbBool const packedtransparency)"""
        return _coin.SoGLLazyElement_setPackedElt(self, node, numcolors, colors, packedtransparency)

    def setColorIndexElt(self, node: "SoNode", numindices: "int32_t", indices: "int32_t const *") -> "void":
        r"""setColorIndexElt(SoGLLazyElement self, SoNode node, int32_t numindices, int32_t const * indices)"""
        return _coin.SoGLLazyElement_setColorIndexElt(self, node, numindices, indices)

    def setTranspElt(self, node: "SoNode", numtransp: "int32_t", transp: "float const *", packer: "SoColorPacker") -> "void":
        r"""setTranspElt(SoGLLazyElement self, SoNode node, int32_t numtransp, float const * transp, SoColorPacker packer)"""
        return _coin.SoGLLazyElement_setTranspElt(self, node, numtransp, transp, packer)

    def setTranspTypeElt(self, type: "int32_t") -> "void":
        r"""setTranspTypeElt(SoGLLazyElement self, int32_t type)"""
        return _coin.SoGLLazyElement_setTranspTypeElt(self, type)

    def setAmbientElt(self, color: "SbColor") -> "void":
        r"""setAmbientElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setAmbientElt(self, color)

    def setEmissiveElt(self, color: "SbColor") -> "void":
        r"""setEmissiveElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setEmissiveElt(self, color)

    def setSpecularElt(self, color: "SbColor") -> "void":
        r"""setSpecularElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setSpecularElt(self, color)

    def setShininessElt(self, value: "float") -> "void":
        r"""setShininessElt(SoGLLazyElement self, float value)"""
        return _coin.SoGLLazyElement_setShininessElt(self, value)

    def setColorMaterialElt(self, value: "SbBool") -> "void":
        r"""setColorMaterialElt(SoGLLazyElement self, SbBool value)"""
        return _coin.SoGLLazyElement_setColorMaterialElt(self, value)

    def enableBlendingElt(self, sfactor: "int", dfactor: "int", alpha_sfactor: "int", alpha_dfactor: "int") -> "void":
        r"""enableBlendingElt(SoGLLazyElement self, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
        return _coin.SoGLLazyElement_enableBlendingElt(self, sfactor, dfactor, alpha_sfactor, alpha_dfactor)

    def disableBlendingElt(self) -> "void":
        r"""disableBlendingElt(SoGLLazyElement self)"""
        return _coin.SoGLLazyElement_disableBlendingElt(self)

    def setLightModelElt(self, state: "SoState", model: "int32_t") -> "void":
        r"""setLightModelElt(SoGLLazyElement self, SoState state, int32_t model)"""
        return _coin.SoGLLazyElement_setLightModelElt(self, state, model)

    def setMaterialElt(self, node: "SoNode", bitmask: "uint32_t", packer: "SoColorPacker", diffuse: "SbColor", numdiffuse: "int const", transp: "float const *", numtransp: "int const", ambient: "SbColor", emissive: "SbColor", specular: "SbColor", shininess: "float const", istransparent: "SbBool const") -> "void":
        r"""setMaterialElt(SoGLLazyElement self, SoNode node, uint32_t bitmask, SoColorPacker packer, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
        return _coin.SoGLLazyElement_setMaterialElt(self, node, bitmask, packer, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)

    def setVertexOrderingElt(self, ordering: "SoLazyElement::VertexOrdering") -> "void":
        r"""setVertexOrderingElt(SoGLLazyElement self, SoLazyElement::VertexOrdering ordering)"""
        return _coin.SoGLLazyElement_setVertexOrderingElt(self, ordering)

    def setBackfaceCullingElt(self, onoff: "SbBool") -> "void":
        r"""setBackfaceCullingElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setBackfaceCullingElt(self, onoff)

    def setTwosideLightingElt(self, onoff: "SbBool") -> "void":
        r"""setTwosideLightingElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setTwosideLightingElt(self, onoff)

    def setShadeModelElt(self, flatshading: "SbBool") -> "void":
        r"""setShadeModelElt(SoGLLazyElement self, SbBool flatshading)"""
        return _coin.SoGLLazyElement_setShadeModelElt(self, flatshading)

    def setAlphaTestElt(self, func: "int", value: "float") -> "void":
        r"""setAlphaTestElt(SoGLLazyElement self, int func, float value)"""
        return _coin.SoGLLazyElement_setAlphaTestElt(self, func, value)

    @staticmethod
    def beginCaching(state: "SoState", prestate: "SoGLLazyElement::GLState *", poststate: "SoGLLazyElement::GLState *") -> "void":
        r"""beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"""
        return _coin.SoGLLazyElement_beginCaching(state, prestate, poststate)

    @staticmethod
    def endCaching(state: "SoState") -> "void":
        r"""endCaching(SoState state)"""
        return _coin.SoGLLazyElement_endCaching(state)

    @staticmethod
    def preCacheCall(state: "SoState", prestate: "SoGLLazyElement::GLState const *") -> "SbBool":
        r"""preCacheCall(SoState state, SoGLLazyElement::GLState const * prestate) -> SbBool"""
        return _coin.SoGLLazyElement_preCacheCall(state, prestate)

    @staticmethod
    def postCacheCall(state: "SoState", poststate: "SoGLLazyElement::GLState const *") -> "void":
        r"""postCacheCall(SoState state, SoGLLazyElement::GLState const * poststate)"""
        return _coin.SoGLLazyElement_postCacheCall(state, poststate)

    @staticmethod
    def mergeCacheInfo(state: "SoState", childprestate: "SoGLLazyElement::GLState *", childpoststate: "SoGLLazyElement::GLState *") -> "void":
        r"""mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"""
        return _coin.SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate)

    def updateColorVBO(self, vbo: "SoVBO *") -> "void":
        r"""updateColorVBO(SoGLLazyElement self, SoVBO * vbo)"""
        return _coin.SoGLLazyElement_updateColorVBO(self, vbo)

# Register SoGLLazyElement in _coin:
_coin.SoGLLazyElement_swigregister(SoGLLazyElement)

def SoGLLazyElement_getClassTypeId() -> "SoType":
    r"""SoGLLazyElement_getClassTypeId() -> SoType"""
    return _coin.SoGLLazyElement_getClassTypeId()

def SoGLLazyElement_getClassStackIndex() -> "int":
    r"""SoGLLazyElement_getClassStackIndex() -> int"""
    return _coin.SoGLLazyElement_getClassStackIndex()

def SoGLLazyElement_createInstance() -> "void *":
    r"""SoGLLazyElement_createInstance() -> void *"""
    return _coin.SoGLLazyElement_createInstance()

def SoGLLazyElement_initClass() -> "void":
    r"""SoGLLazyElement_initClass()"""
    return _coin.SoGLLazyElement_initClass()

def SoGLLazyElement_sendAllMaterial(state: "SoState") -> "void":
    r"""SoGLLazyElement_sendAllMaterial(SoState state)"""
    return _coin.SoGLLazyElement_sendAllMaterial(state)

def SoGLLazyElement_sendNoMaterial(state: "SoState") -> "void":
    r"""SoGLLazyElement_sendNoMaterial(SoState state)"""
    return _coin.SoGLLazyElement_sendNoMaterial(state)

def SoGLLazyElement_sendOnlyDiffuseColor(state: "SoState") -> "void":
    r"""SoGLLazyElement_sendOnlyDiffuseColor(SoState state)"""
    return _coin.SoGLLazyElement_sendOnlyDiffuseColor(state)

def SoGLLazyElement_sendLightModel(state: "SoState", model: "int32_t const") -> "void":
    r"""SoGLLazyElement_sendLightModel(SoState state, int32_t const model)"""
    return _coin.SoGLLazyElement_sendLightModel(state, model)

def SoGLLazyElement_sendPackedDiffuse(state: "SoState", diffuse: "uint32_t const") -> "void":
    r"""SoGLLazyElement_sendPackedDiffuse(SoState state, uint32_t const diffuse)"""
    return _coin.SoGLLazyElement_sendPackedDiffuse(state, diffuse)

def SoGLLazyElement_sendFlatshading(state: "SoState", onoff: "SbBool const") -> "void":
    r"""SoGLLazyElement_sendFlatshading(SoState state, SbBool const onoff)"""
    return _coin.SoGLLazyElement_sendFlatshading(state, onoff)

def SoGLLazyElement_sendVertexOrdering(state: "SoState", ordering: "SoLazyElement::VertexOrdering const") -> "void":
    r"""SoGLLazyElement_sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"""
    return _coin.SoGLLazyElement_sendVertexOrdering(state, ordering)

def SoGLLazyElement_sendTwosideLighting(state: "SoState", onoff: "SbBool const") -> "void":
    r"""SoGLLazyElement_sendTwosideLighting(SoState state, SbBool const onoff)"""
    return _coin.SoGLLazyElement_sendTwosideLighting(state, onoff)

def SoGLLazyElement_sendBackfaceCulling(state: "SoState", onoff: "SbBool const") -> "void":
    r"""SoGLLazyElement_sendBackfaceCulling(SoState state, SbBool const onoff)"""
    return _coin.SoGLLazyElement_sendBackfaceCulling(state, onoff)

def SoGLLazyElement_isColorIndex(state: "SoState") -> "SbBool":
    r"""SoGLLazyElement_isColorIndex(SoState state) -> SbBool"""
    return _coin.SoGLLazyElement_isColorIndex(state)

def SoGLLazyElement_getInstance(state: "SoState") -> "SoGLLazyElement *":
    r"""SoGLLazyElement_getInstance(SoState state) -> SoGLLazyElement"""
    return _coin.SoGLLazyElement_getInstance(state)

def SoGLLazyElement_beginCaching(state: "SoState", prestate: "SoGLLazyElement::GLState *", poststate: "SoGLLazyElement::GLState *") -> "void":
    r"""SoGLLazyElement_beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"""
    return _coin.SoGLLazyElement_beginCaching(state, prestate, poststate)

def SoGLLazyElement_endCaching(state: "SoState") -> "void":
    r"""SoGLLazyElement_endCaching(SoState state)"""
    return _coin.SoGLLazyElement_endCaching(state)

def SoGLLazyElement_preCacheCall(state: "SoState", prestate: "SoGLLazyElement::GLState const *") -> "SbBool":
    r"""SoGLLazyElement_preCacheCall(SoState state, SoGLLazyElement::GLState const * prestate) -> SbBool"""
    return _coin.SoGLLazyElement_preCacheCall(state, prestate)

def SoGLLazyElement_postCacheCall(state: "SoState", poststate: "SoGLLazyElement::GLState const *") -> "void":
    r"""SoGLLazyElement_postCacheCall(SoState state, SoGLLazyElement::GLState const * poststate)"""
    return _coin.SoGLLazyElement_postCacheCall(state, poststate)

def SoGLLazyElement_mergeCacheInfo(state: "SoState", childprestate: "SoGLLazyElement::GLState *", childpoststate: "SoGLLazyElement::GLState *") -> "void":
    r"""SoGLLazyElement_mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"""
    return _coin.SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate)

class SoGLRenderCache(SoCache):
    r"""Proxy of C++ SoGLRenderCache class."""

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

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

    def isValid(self, state: "SoState") -> "SbBool":
        r"""isValid(SoGLRenderCache self, SoState state) -> SbBool"""
        return _coin.SoGLRenderCache_isValid(self, state)

    def addNestedCache(self, child: "SoGLDisplayList") -> "void":
        r"""addNestedCache(SoGLRenderCache self, SoGLDisplayList child)"""
        return _coin.SoGLRenderCache_addNestedCache(self, child)

# Register SoGLRenderCache in _coin:
_coin.SoGLRenderCache_swigregister(SoGLRenderCache)

class SoNormalCache(SoCache):
    r"""Proxy of C++ SoNormalCache class."""

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

    def __init__(self, state: "SoState"):
        r"""__init__(SoNormalCache self, SoState state) -> SoNormalCache"""
        _coin.SoNormalCache_swiginit(self, _coin.new_SoNormalCache(state))
    __swig_destroy__ = _coin.delete_SoNormalCache

    def set(self, *args) -> "void":
        r"""
        set(SoNormalCache self, int const num, SbVec3f normals)
        set(SoNormalCache self, SoNormalGenerator generator)
        """
        return _coin.SoNormalCache_set(self, *args)

    def getNum(self) -> "int":
        r"""getNum(SoNormalCache self) -> int"""
        return _coin.SoNormalCache_getNum(self)

    def getNormals(self) -> "SbVec3f const *":
        r"""getNormals(SoNormalCache self) -> SbVec3f"""
        return _coin.SoNormalCache_getNormals(self)

    def getNumIndices(self) -> "int":
        r"""getNumIndices(SoNormalCache self) -> int"""
        return _coin.SoNormalCache_getNumIndices(self)

    def getIndices(self) -> "int32_t const *":
        r"""getIndices(SoNormalCache self) -> int32_t const *"""
        return _coin.SoNormalCache_getIndices(self)

    def generatePerVertex(self, coords: "SbVec3f", numcoords: "unsigned int const", coordindices: "int32_t const *", numcoordindices: "int const", crease_angle: "float const", facenormals: "SbVec3f"=None, numfacenormals: "int const"=-1, ccw: "SbBool const"=1, tristrip: "SbBool const"=0) -> "void":
        r"""generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1, SbBool const ccw=1, SbBool const tristrip=0)"""
        return _coin.SoNormalCache_generatePerVertex(self, coords, numcoords, coordindices, numcoordindices, crease_angle, facenormals, numfacenormals, ccw, tristrip)

    def generatePerFace(self, coords: "SbVec3f", numcoords: "unsigned int const", coordindices: "int32_t const *", numcoorindices: "int const", ccw: "SbBool const") -> "void":
        r"""generatePerFace(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerFace(self, coords, numcoords, coordindices, numcoorindices, ccw)

    def generatePerFaceStrip(self, coords: "SbVec3f", numcoords: "unsigned int const", coordindices: "int32_t const *", numcoorindices: "int const", ccw: "SbBool const") -> "void":
        r"""generatePerFaceStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerFaceStrip(self, coords, numcoords, coordindices, numcoorindices, ccw)

    def generatePerStrip(self, coords: "SbVec3f", numcoords: "unsigned int const", coordindices: "int32_t const *", numcoorindices: "int const", ccw: "SbBool const") -> "void":
        r"""generatePerStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerStrip(self, coords, numcoords, coordindices, numcoorindices, ccw)

    def generatePerVertexQuad(self, coords: "SbVec3f", numcoords: "unsigned int const", vPerRow: "int const", vPerColumn: "int const", ccw: "SbBool const") -> "void":
        r"""generatePerVertexQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerVertexQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)

    def generatePerFaceQuad(self, coords: "SbVec3f", numcoords: "unsigned int const", vPerRow: "int const", vPerColumn: "int const", ccw: "SbBool const") -> "void":
        r"""generatePerFaceQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerFaceQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)

    def generatePerRowQuad(self, coords: "SbVec3f", numcoords: "unsigned int const", vPerRow: "int const", vPerColumn: "int const", ccw: "SbBool const") -> "void":
        r"""generatePerRowQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerRowQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)

# Register SoNormalCache in _coin:
_coin.SoNormalCache_swigregister(SoNormalCache)

class SoTextureCoordinateCache(SoCache):
    r"""Proxy of C++ SoTextureCoordinateCache class."""

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

    def __init__(self, state: "SoState"):
        r"""__init__(SoTextureCoordinateCache self, SoState state) -> SoTextureCoordinateCache"""
        _coin.SoTextureCoordinateCache_swiginit(self, _coin.new_SoTextureCoordinateCache(state))
    __swig_destroy__ = _coin.delete_SoTextureCoordinateCache

    def generate(self, bbox: "SbBox3f", vertices: "SbVec3f", numvertices: "int const") -> "void":
        r"""generate(SoTextureCoordinateCache self, SbBox3f bbox, SbVec3f vertices, int const numvertices)"""
        return _coin.SoTextureCoordinateCache_generate(self, bbox, vertices, numvertices)

    def get(self) -> "SbVec2f const *":
        r"""get(SoTextureCoordinateCache self) -> SbVec2f"""
        return _coin.SoTextureCoordinateCache_get(self)

    def getNum(self) -> "int":
        r"""getNum(SoTextureCoordinateCache self) -> int"""
        return _coin.SoTextureCoordinateCache_getNum(self)

# Register SoTextureCoordinateCache in _coin:
_coin.SoTextureCoordinateCache_swigregister(SoTextureCoordinateCache)

class SoDetail(object):
    r"""Proxy of C++ SoDetail class."""

    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__ = _coin.delete_SoDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDetail_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoDetail_initClasses()

    def copy(self) -> "SoDetail *":
        r"""copy(SoDetail self) -> SoDetail"""
        return _coin.SoDetail_copy(self)

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDetail self) -> SoType"""
        return _coin.SoDetail_getTypeId(self)

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(SoDetail self, SoType type) -> SbBool"""
        return _coin.SoDetail_isOfType(self, type)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDetail_getClassTypeId()

# Register SoDetail in _coin:
_coin.SoDetail_swigregister(SoDetail)

def SoDetail_initClass() -> "void":
    r"""SoDetail_initClass()"""
    return _coin.SoDetail_initClass()

def SoDetail_initClasses() -> "void":
    r"""SoDetail_initClasses()"""
    return _coin.SoDetail_initClasses()

def SoDetail_getClassTypeId() -> "SoType":
    r"""SoDetail_getClassTypeId() -> SoType"""
    return _coin.SoDetail_getClassTypeId()

class SoConeDetail(SoDetail):
    r"""Proxy of C++ SoConeDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoConeDetail self) -> SoType"""
        return _coin.SoConeDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoConeDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoConeDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoConeDetail self) -> SoConeDetail"""
        _coin.SoConeDetail_swiginit(self, _coin.new_SoConeDetail())
    __swig_destroy__ = _coin.delete_SoConeDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoConeDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoConeDetail self) -> SoDetail"""
        return _coin.SoConeDetail_copy(self)

    def setPart(self, part: "int const") -> "void":
        r"""setPart(SoConeDetail self, int const part)"""
        return _coin.SoConeDetail_setPart(self, part)

    def getPart(self) -> "int":
        r"""getPart(SoConeDetail self) -> int"""
        return _coin.SoConeDetail_getPart(self)

# Register SoConeDetail in _coin:
_coin.SoConeDetail_swigregister(SoConeDetail)

def SoConeDetail_getClassTypeId() -> "SoType":
    r"""SoConeDetail_getClassTypeId() -> SoType"""
    return _coin.SoConeDetail_getClassTypeId()

def SoConeDetail_cleanupClass() -> "void":
    r"""SoConeDetail_cleanupClass()"""
    return _coin.SoConeDetail_cleanupClass()

def SoConeDetail_initClass() -> "void":
    r"""SoConeDetail_initClass()"""
    return _coin.SoConeDetail_initClass()

class SoCubeDetail(SoDetail):
    r"""Proxy of C++ SoCubeDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCubeDetail self) -> SoType"""
        return _coin.SoCubeDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCubeDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoCubeDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoCubeDetail self) -> SoCubeDetail"""
        _coin.SoCubeDetail_swiginit(self, _coin.new_SoCubeDetail())
    __swig_destroy__ = _coin.delete_SoCubeDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCubeDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoCubeDetail self) -> SoDetail"""
        return _coin.SoCubeDetail_copy(self)

    def setPart(self, part: "int const") -> "void":
        r"""setPart(SoCubeDetail self, int const part)"""
        return _coin.SoCubeDetail_setPart(self, part)

    def getPart(self) -> "int":
        r"""getPart(SoCubeDetail self) -> int"""
        return _coin.SoCubeDetail_getPart(self)

# Register SoCubeDetail in _coin:
_coin.SoCubeDetail_swigregister(SoCubeDetail)

def SoCubeDetail_getClassTypeId() -> "SoType":
    r"""SoCubeDetail_getClassTypeId() -> SoType"""
    return _coin.SoCubeDetail_getClassTypeId()

def SoCubeDetail_cleanupClass() -> "void":
    r"""SoCubeDetail_cleanupClass()"""
    return _coin.SoCubeDetail_cleanupClass()

def SoCubeDetail_initClass() -> "void":
    r"""SoCubeDetail_initClass()"""
    return _coin.SoCubeDetail_initClass()

class SoCylinderDetail(SoDetail):
    r"""Proxy of C++ SoCylinderDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCylinderDetail self) -> SoType"""
        return _coin.SoCylinderDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCylinderDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoCylinderDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoCylinderDetail self) -> SoCylinderDetail"""
        _coin.SoCylinderDetail_swiginit(self, _coin.new_SoCylinderDetail())
    __swig_destroy__ = _coin.delete_SoCylinderDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCylinderDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoCylinderDetail self) -> SoDetail"""
        return _coin.SoCylinderDetail_copy(self)

    def setPart(self, part: "int const") -> "void":
        r"""setPart(SoCylinderDetail self, int const part)"""
        return _coin.SoCylinderDetail_setPart(self, part)

    def getPart(self) -> "int":
        r"""getPart(SoCylinderDetail self) -> int"""
        return _coin.SoCylinderDetail_getPart(self)

# Register SoCylinderDetail in _coin:
_coin.SoCylinderDetail_swigregister(SoCylinderDetail)

def SoCylinderDetail_getClassTypeId() -> "SoType":
    r"""SoCylinderDetail_getClassTypeId() -> SoType"""
    return _coin.SoCylinderDetail_getClassTypeId()

def SoCylinderDetail_cleanupClass() -> "void":
    r"""SoCylinderDetail_cleanupClass()"""
    return _coin.SoCylinderDetail_cleanupClass()

def SoCylinderDetail_initClass() -> "void":
    r"""SoCylinderDetail_initClass()"""
    return _coin.SoCylinderDetail_initClass()

class SoPointDetail(SoDetail):
    r"""Proxy of C++ SoPointDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPointDetail self) -> SoType"""
        return _coin.SoPointDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoPointDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoPointDetail self) -> SoPointDetail"""
        _coin.SoPointDetail_swiginit(self, _coin.new_SoPointDetail())
    __swig_destroy__ = _coin.delete_SoPointDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPointDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoPointDetail self) -> SoDetail"""
        return _coin.SoPointDetail_copy(self)

    def getCoordinateIndex(self) -> "int":
        r"""getCoordinateIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getCoordinateIndex(self)

    def getMaterialIndex(self) -> "int":
        r"""getMaterialIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getMaterialIndex(self)

    def getNormalIndex(self) -> "int":
        r"""getNormalIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getNormalIndex(self)

    def getTextureCoordIndex(self) -> "int":
        r"""getTextureCoordIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getTextureCoordIndex(self)

    def setCoordinateIndex(self, idx: "int const") -> "void":
        r"""setCoordinateIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setCoordinateIndex(self, idx)

    def setMaterialIndex(self, idx: "int const") -> "void":
        r"""setMaterialIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setMaterialIndex(self, idx)

    def setNormalIndex(self, idx: "int const") -> "void":
        r"""setNormalIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setNormalIndex(self, idx)

    def setTextureCoordIndex(self, idx: "int const") -> "void":
        r"""setTextureCoordIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setTextureCoordIndex(self, idx)

# Register SoPointDetail in _coin:
_coin.SoPointDetail_swigregister(SoPointDetail)

def SoPointDetail_getClassTypeId() -> "SoType":
    r"""SoPointDetail_getClassTypeId() -> SoType"""
    return _coin.SoPointDetail_getClassTypeId()

def SoPointDetail_cleanupClass() -> "void":
    r"""SoPointDetail_cleanupClass()"""
    return _coin.SoPointDetail_cleanupClass()

def SoPointDetail_initClass() -> "void":
    r"""SoPointDetail_initClass()"""
    return _coin.SoPointDetail_initClass()

class SoFaceDetail(SoDetail):
    r"""Proxy of C++ SoFaceDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFaceDetail self) -> SoType"""
        return _coin.SoFaceDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFaceDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoFaceDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoFaceDetail self) -> SoFaceDetail"""
        _coin.SoFaceDetail_swiginit(self, _coin.new_SoFaceDetail())
    __swig_destroy__ = _coin.delete_SoFaceDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFaceDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoFaceDetail self) -> SoDetail"""
        return _coin.SoFaceDetail_copy(self)

    def getNumPoints(self) -> "int":
        r"""getNumPoints(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getNumPoints(self)

    def getPoint(self, idx: "int const") -> "SoPointDetail const *":
        r"""getPoint(SoFaceDetail self, int const idx) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoint(self, idx)

    def getPoints(self) -> "SoPointDetail *":
        r"""getPoints(SoFaceDetail self) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoints(self)

    def getFaceIndex(self) -> "int":
        r"""getFaceIndex(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getFaceIndex(self)

    def getPartIndex(self) -> "int":
        r"""getPartIndex(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getPartIndex(self)

    def setNumPoints(self, num: "int const") -> "void":
        r"""setNumPoints(SoFaceDetail self, int const num)"""
        return _coin.SoFaceDetail_setNumPoints(self, num)

    def setPoint(self, idx: "int const", detail: "SoPointDetail") -> "void":
        r"""setPoint(SoFaceDetail self, int const idx, SoPointDetail detail)"""
        return _coin.SoFaceDetail_setPoint(self, idx, detail)

    def setFaceIndex(self, idx: "int const") -> "void":
        r"""setFaceIndex(SoFaceDetail self, int const idx)"""
        return _coin.SoFaceDetail_setFaceIndex(self, idx)

    def setPartIndex(self, idx: "int const") -> "void":
        r"""setPartIndex(SoFaceDetail self, int const idx)"""
        return _coin.SoFaceDetail_setPartIndex(self, idx)

    def incFaceIndex(self) -> "void":
        r"""incFaceIndex(SoFaceDetail self)"""
        return _coin.SoFaceDetail_incFaceIndex(self)

    def incPartIndex(self) -> "void":
        r"""incPartIndex(SoFaceDetail self)"""
        return _coin.SoFaceDetail_incPartIndex(self)

# Register SoFaceDetail in _coin:
_coin.SoFaceDetail_swigregister(SoFaceDetail)

def SoFaceDetail_getClassTypeId() -> "SoType":
    r"""SoFaceDetail_getClassTypeId() -> SoType"""
    return _coin.SoFaceDetail_getClassTypeId()

def SoFaceDetail_cleanupClass() -> "void":
    r"""SoFaceDetail_cleanupClass()"""
    return _coin.SoFaceDetail_cleanupClass()

def SoFaceDetail_initClass() -> "void":
    r"""SoFaceDetail_initClass()"""
    return _coin.SoFaceDetail_initClass()

class SoLineDetail(SoDetail):
    r"""Proxy of C++ SoLineDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLineDetail self) -> SoType"""
        return _coin.SoLineDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoLineDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoLineDetail self) -> SoLineDetail"""
        _coin.SoLineDetail_swiginit(self, _coin.new_SoLineDetail())
    __swig_destroy__ = _coin.delete_SoLineDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLineDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoLineDetail self) -> SoDetail"""
        return _coin.SoLineDetail_copy(self)

    def getPoint0(self) -> "SoPointDetail const *":
        r"""getPoint0(SoLineDetail self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint0(self)

    def getPoint1(self) -> "SoPointDetail const *":
        r"""getPoint1(SoLineDetail self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint1(self)

    def getLineIndex(self) -> "int":
        r"""getLineIndex(SoLineDetail self) -> int"""
        return _coin.SoLineDetail_getLineIndex(self)

    def getPartIndex(self) -> "int":
        r"""getPartIndex(SoLineDetail self) -> int"""
        return _coin.SoLineDetail_getPartIndex(self)

    def setPoint0(self, detail: "SoPointDetail") -> "void":
        r"""setPoint0(SoLineDetail self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint0(self, detail)

    def setPoint1(self, detail: "SoPointDetail") -> "void":
        r"""setPoint1(SoLineDetail self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint1(self, detail)

    def setLineIndex(self, idx: "int const") -> "void":
        r"""setLineIndex(SoLineDetail self, int const idx)"""
        return _coin.SoLineDetail_setLineIndex(self, idx)

    def setPartIndex(self, idx: "int const") -> "void":
        r"""setPartIndex(SoLineDetail self, int const idx)"""
        return _coin.SoLineDetail_setPartIndex(self, idx)

    def incLineIndex(self) -> "void":
        r"""incLineIndex(SoLineDetail self)"""
        return _coin.SoLineDetail_incLineIndex(self)

    def incPartIndex(self) -> "void":
        r"""incPartIndex(SoLineDetail self)"""
        return _coin.SoLineDetail_incPartIndex(self)

# Register SoLineDetail in _coin:
_coin.SoLineDetail_swigregister(SoLineDetail)

def SoLineDetail_getClassTypeId() -> "SoType":
    r"""SoLineDetail_getClassTypeId() -> SoType"""
    return _coin.SoLineDetail_getClassTypeId()

def SoLineDetail_cleanupClass() -> "void":
    r"""SoLineDetail_cleanupClass()"""
    return _coin.SoLineDetail_cleanupClass()

def SoLineDetail_initClass() -> "void":
    r"""SoLineDetail_initClass()"""
    return _coin.SoLineDetail_initClass()

class SoNodeKitDetail(SoDetail):
    r"""Proxy of C++ SoNodeKitDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNodeKitDetail self) -> SoType"""
        return _coin.SoNodeKitDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNodeKitDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoNodeKitDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoNodeKitDetail self) -> SoNodeKitDetail"""
        _coin.SoNodeKitDetail_swiginit(self, _coin.new_SoNodeKitDetail())
    __swig_destroy__ = _coin.delete_SoNodeKitDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNodeKitDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoNodeKitDetail self) -> SoDetail"""
        return _coin.SoNodeKitDetail_copy(self)

    def setNodeKit(self, kit: "SoBaseKit") -> "void":
        r"""setNodeKit(SoNodeKitDetail self, SoBaseKit kit)"""
        return _coin.SoNodeKitDetail_setNodeKit(self, kit)

    def getNodeKit(self) -> "SoBaseKit *":
        r"""getNodeKit(SoNodeKitDetail self) -> SoBaseKit"""
        return _coin.SoNodeKitDetail_getNodeKit(self)

    def setPart(self, part: "SoNode") -> "void":
        r"""setPart(SoNodeKitDetail self, SoNode part)"""
        return _coin.SoNodeKitDetail_setPart(self, part)

    def getPart(self) -> "SoNode *":
        r"""getPart(SoNodeKitDetail self) -> SoNode"""
        return _coin.SoNodeKitDetail_getPart(self)

    def setPartName(self, name: "SbName") -> "void":
        r"""setPartName(SoNodeKitDetail self, SbName name)"""
        return _coin.SoNodeKitDetail_setPartName(self, name)

    def getPartName(self) -> "SbName const &":
        r"""getPartName(SoNodeKitDetail self) -> SbName"""
        return _coin.SoNodeKitDetail_getPartName(self)

# Register SoNodeKitDetail in _coin:
_coin.SoNodeKitDetail_swigregister(SoNodeKitDetail)

def SoNodeKitDetail_getClassTypeId() -> "SoType":
    r"""SoNodeKitDetail_getClassTypeId() -> SoType"""
    return _coin.SoNodeKitDetail_getClassTypeId()

def SoNodeKitDetail_cleanupClass() -> "void":
    r"""SoNodeKitDetail_cleanupClass()"""
    return _coin.SoNodeKitDetail_cleanupClass()

def SoNodeKitDetail_initClass() -> "void":
    r"""SoNodeKitDetail_initClass()"""
    return _coin.SoNodeKitDetail_initClass()

class SoTextDetail(SoDetail):
    r"""Proxy of C++ SoTextDetail class."""

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

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextDetail self) -> SoType"""
        return _coin.SoTextDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextDetail_getClassTypeId()

    @staticmethod
    def cleanupClass() -> "void":
        r"""cleanupClass()"""
        return _coin.SoTextDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoTextDetail self) -> SoTextDetail"""
        _coin.SoTextDetail_swiginit(self, _coin.new_SoTextDetail())
    __swig_destroy__ = _coin.delete_SoTextDetail

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextDetail_initClass()

    def copy(self) -> "SoDetail *":
        r"""copy(SoTextDetail self) -> SoDetail"""
        return _coin.SoTextDetail_copy(self)

    def getStringIndex(self) -> "int":
        r"""getStringIndex(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getStringIndex(self)

    def getCharacterIndex(self) -> "int":
        r"""getCharacterIndex(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getCharacterIndex(self)

    def getPart(self) -> "int":
        r"""getPart(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getPart(self)

    def setStringIndex(self, idx: "int const") -> "void":
        r"""setStringIndex(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setStringIndex(self, idx)

    def setCharacterIndex(self, idx: "int const") -> "void":
        r"""setCharacterIndex(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setCharacterIndex(self, idx)

    def setPart(self, idx: "int const") -> "void":
        r"""setPart(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setPart(self, idx)

# Register SoTextDetail in _coin:
_coin.SoTextDetail_swigregister(SoTextDetail)

def SoTextDetail_getClassTypeId() -> "SoType":
    r"""SoTextDetail_getClassTypeId() -> SoType"""
    return _coin.SoTextDetail_getClassTypeId()

def SoTextDetail_cleanupClass() -> "void":
    r"""SoTextDetail_cleanupClass()"""
    return _coin.SoTextDetail_cleanupClass()

def SoTextDetail_initClass() -> "void":
    r"""SoTextDetail_initClass()"""
    return _coin.SoTextDetail_initClass()

class SoSFNode(SoSField):
    r"""Proxy of C++ SoSFNode class."""

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

    def __init__(self):
        r"""__init__(SoSFNode self) -> SoSFNode"""
        _coin.SoSFNode_swiginit(self, _coin.new_SoSFNode())
    __swig_destroy__ = _coin.delete_SoSFNode

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFNode_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFNode_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFNode self) -> SoType"""
        return _coin.SoSFNode_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFNode self, SoField field)"""
        return _coin.SoSFNode_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFNode self, SoField field) -> SbBool"""
        return _coin.SoSFNode_isSame(self, field)

    def getValue(self) -> "SoNode *":
        r"""getValue(SoSFNode self) -> SoNode"""
        return _coin.SoSFNode_getValue(self)

    def __eq__(self, field: "SoSFNode") -> "int":
        r"""__eq__(SoSFNode self, SoSFNode field) -> int"""
        return _coin.SoSFNode___eq__(self, field)

    def __ne__(self, field: "SoSFNode") -> "int":
        r"""__ne__(SoSFNode self, SoSFNode field) -> int"""
        return _coin.SoSFNode___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFNode_initClass()

    def fixCopy(self, copyconnections: "SbBool") -> "void":
        r"""fixCopy(SoSFNode self, SbBool copyconnections)"""
        return _coin.SoSFNode_fixCopy(self, copyconnections)

    def referencesCopy(self) -> "SbBool":
        r"""referencesCopy(SoSFNode self) -> SbBool"""
        return _coin.SoSFNode_referencesCopy(self)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFNode self, SoNode newvalue)
        setValue(SoSFNode self, SoSFNode other)
        """
        return _coin.SoSFNode_setValue(self, *args)

# Register SoSFNode in _coin:
_coin.SoSFNode_swigregister(SoSFNode)

def SoSFNode_createInstance() -> "void *":
    r"""SoSFNode_createInstance() -> void *"""
    return _coin.SoSFNode_createInstance()

def SoSFNode_getClassTypeId() -> "SoType":
    r"""SoSFNode_getClassTypeId() -> SoType"""
    return _coin.SoSFNode_getClassTypeId()

def SoSFNode_initClass() -> "void":
    r"""SoSFNode_initClass()"""
    return _coin.SoSFNode_initClass()

SO_CATALOG_NAME_NOT_FOUND = _coin.SO_CATALOG_NAME_NOT_FOUND

class SoNodekitCatalog(object):
    r"""Proxy of C++ SoNodekitCatalog class."""

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

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNodekitCatalog_initClass()

    def __init__(self):
        r"""__init__(SoNodekitCatalog self) -> SoNodekitCatalog"""
        _coin.SoNodekitCatalog_swiginit(self, _coin.new_SoNodekitCatalog())
    __swig_destroy__ = _coin.delete_SoNodekitCatalog

    def getNumEntries(self) -> "int":
        r"""getNumEntries(SoNodekitCatalog self) -> int"""
        return _coin.SoNodekitCatalog_getNumEntries(self)

    def getPartNumber(self, name: "SbName") -> "int":
        r"""getPartNumber(SoNodekitCatalog self, SbName name) -> int"""
        return _coin.SoNodekitCatalog_getPartNumber(self, name)

    def getName(self, part: "int") -> "SbName const &":
        r"""getName(SoNodekitCatalog self, int part) -> SbName"""
        return _coin.SoNodekitCatalog_getName(self, part)

    def getType(self, *args) -> "SoType":
        r"""
        getType(SoNodekitCatalog self, int part) -> SoType
        getType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getType(self, *args)

    def getDefaultType(self, *args) -> "SoType":
        r"""
        getDefaultType(SoNodekitCatalog self, int part) -> SoType
        getDefaultType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getDefaultType(self, *args)

    def isNullByDefault(self, *args) -> "SbBool":
        r"""
        isNullByDefault(SoNodekitCatalog self, int part) -> SbBool
        isNullByDefault(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isNullByDefault(self, *args)

    def isLeaf(self, *args) -> "SbBool":
        r"""
        isLeaf(SoNodekitCatalog self, int part) -> SbBool
        isLeaf(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isLeaf(self, *args)

    def getParentName(self, *args) -> "SbName const &":
        r"""
        getParentName(SoNodekitCatalog self, int part) -> SbName
        getParentName(SoNodekitCatalog self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getParentName(self, *args)

    def getParentPartNumber(self, *args) -> "int":
        r"""
        getParentPartNumber(SoNodekitCatalog self, int part) -> int
        getParentPartNumber(SoNodekitCatalog self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getParentPartNumber(self, *args)

    def getRightSiblingName(self, *args) -> "SbName const &":
        r"""
        getRightSiblingName(SoNodekitCatalog self, int part) -> SbName
        getRightSiblingName(SoNodekitCatalog self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getRightSiblingName(self, *args)

    def getRightSiblingPartNumber(self, *args) -> "int":
        r"""
        getRightSiblingPartNumber(SoNodekitCatalog self, int part) -> int
        getRightSiblingPartNumber(SoNodekitCatalog self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getRightSiblingPartNumber(self, *args)

    def isList(self, *args) -> "SbBool":
        r"""
        isList(SoNodekitCatalog self, int part) -> SbBool
        isList(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isList(self, *args)

    def getListContainerType(self, *args) -> "SoType":
        r"""
        getListContainerType(SoNodekitCatalog self, int part) -> SoType
        getListContainerType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getListContainerType(self, *args)

    def getListItemTypes(self, *args) -> "SoTypeList const &":
        r"""
        getListItemTypes(SoNodekitCatalog self, int part) -> SoTypeList
        getListItemTypes(SoNodekitCatalog self, SbName name) -> SoTypeList
        """
        return _coin.SoNodekitCatalog_getListItemTypes(self, *args)

    def isPublic(self, *args) -> "SbBool":
        r"""
        isPublic(SoNodekitCatalog self, int part) -> SbBool
        isPublic(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isPublic(self, *args)

    def clone(self, type: "SoType") -> "SoNodekitCatalog *":
        r"""clone(SoNodekitCatalog self, SoType type) -> SoNodekitCatalog"""
        return _coin.SoNodekitCatalog_clone(self, type)

    def addEntry(self, name: "SbName", type: "SoType", defaulttype: "SoType", isdefaultnull: "SbBool", parent: "SbName", rightsibling: "SbName", islist: "SbBool", listcontainertype: "SoType", listitemtype: "SoType", ispublic: "SbBool") -> "SbBool":
        r"""addEntry(SoNodekitCatalog self, SbName name, SoType type, SoType defaulttype, SbBool isdefaultnull, SbName parent, SbName rightsibling, SbBool islist, SoType listcontainertype, SoType listitemtype, SbBool ispublic) -> SbBool"""
        return _coin.SoNodekitCatalog_addEntry(self, name, type, defaulttype, isdefaultnull, parent, rightsibling, islist, listcontainertype, listitemtype, ispublic)

    def addListItemType(self, *args) -> "void":
        r"""
        addListItemType(SoNodekitCatalog self, int part, SoType type)
        addListItemType(SoNodekitCatalog self, SbName name, SoType type)
        """
        return _coin.SoNodekitCatalog_addListItemType(self, *args)

    def narrowTypes(self, name: "SbName", newtype: "SoType", newdefaulttype: "SoType") -> "void":
        r"""narrowTypes(SoNodekitCatalog self, SbName name, SoType newtype, SoType newdefaulttype)"""
        return _coin.SoNodekitCatalog_narrowTypes(self, name, newtype, newdefaulttype)

    def setNullByDefault(self, name: "SbName", nullbydefault: "SbBool") -> "void":
        r"""setNullByDefault(SoNodekitCatalog self, SbName name, SbBool nullbydefault)"""
        return _coin.SoNodekitCatalog_setNullByDefault(self, name, nullbydefault)

    def recursiveSearch(self, part: "int", name: "SbName", checked: "SoTypeList") -> "SbBool":
        r"""recursiveSearch(SoNodekitCatalog self, int part, SbName name, SoTypeList checked) -> SbBool"""
        return _coin.SoNodekitCatalog_recursiveSearch(self, part, name, checked)

    def printCheck(self) -> "void":
        r"""printCheck(SoNodekitCatalog self)"""
        return _coin.SoNodekitCatalog_printCheck(self)

# Register SoNodekitCatalog in _coin:
_coin.SoNodekitCatalog_swigregister(SoNodekitCatalog)

def SoNodekitCatalog_initClass() -> "void":
    r"""SoNodekitCatalog_initClass()"""
    return _coin.SoNodekitCatalog_initClass()

class SoSFName(SoSField):
    r"""Proxy of C++ SoSFName class."""

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

    def __init__(self):
        r"""__init__(SoSFName self) -> SoSFName"""
        _coin.SoSFName_swiginit(self, _coin.new_SoSFName())
    __swig_destroy__ = _coin.delete_SoSFName

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFName_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFName_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFName self) -> SoType"""
        return _coin.SoSFName_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFName self, SoField field)"""
        return _coin.SoSFName_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFName self, SoField field) -> SbBool"""
        return _coin.SoSFName_isSame(self, field)

    def getValue(self) -> "SbName const &":
        r"""getValue(SoSFName self) -> SbName"""
        return _coin.SoSFName_getValue(self)

    def __eq__(self, field: "SoSFName") -> "int":
        r"""__eq__(SoSFName self, SoSFName field) -> int"""
        return _coin.SoSFName___eq__(self, field)

    def __ne__(self, field: "SoSFName") -> "int":
        r"""__ne__(SoSFName self, SoSFName field) -> int"""
        return _coin.SoSFName___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFName_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFName self, SbName newvalue)
        setValue(SoSFName self, char const *const name)
        setValue(SoSFName self, SoSFName other)
        """
        return _coin.SoSFName_setValue(self, *args)

# Register SoSFName in _coin:
_coin.SoSFName_swigregister(SoSFName)

def SoSFName_createInstance() -> "void *":
    r"""SoSFName_createInstance() -> void *"""
    return _coin.SoSFName_createInstance()

def SoSFName_getClassTypeId() -> "SoType":
    r"""SoSFName_getClassTypeId() -> SoType"""
    return _coin.SoSFName_getClassTypeId()

def SoSFName_initClass() -> "void":
    r"""SoSFName_initClass()"""
    return _coin.SoSFName_initClass()

class SoMFName(SoMField):
    r"""Proxy of C++ SoMFName class."""

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

    def __init__(self):
        r"""__init__(SoMFName self) -> SoMFName"""
        _coin.SoMFName_swiginit(self, _coin.new_SoMFName())
    __swig_destroy__ = _coin.delete_SoMFName

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFName_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFName_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFName self) -> SoType"""
        return _coin.SoMFName_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFName self, SoField field)"""
        return _coin.SoMFName_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFName self, SoField field) -> SbBool"""
        return _coin.SoMFName_isSame(self, field)

    def find(self, value: "SbName", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFName self, SbName value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFName_find(self, value, addifnotfound)

    def set1Value(self, idx: "int const", value: "SbName") -> "void":
        r"""set1Value(SoMFName self, int const idx, SbName value)"""
        return _coin.SoMFName_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFName") -> "SbBool":
        r"""__eq__(SoMFName self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___eq__(self, field)

    def __ne__(self, field: "SoMFName") -> "SbBool":
        r"""__ne__(SoMFName self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___ne__(self, field)

    def startEditing(self) -> "SbName *":
        r"""startEditing(SoMFName self) -> SbName"""
        return _coin.SoMFName_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFName self)"""
        return _coin.SoMFName_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFName_initClass()

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFName_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFName_setValues(args[0], args[1], len(args[2]), args[2])
       return _coin.SoMFName_setValues(*args)



    def __getitem__(self, i: "int") -> "SbName const &":
        r"""__getitem__(SoMFName self, int i) -> SbName"""
        return _coin.SoMFName___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbName") -> "void":
        r"""__setitem__(SoMFName self, int i, SbName value)"""
        return _coin.SoMFName___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFName self, SbName value)
        setValue(SoMFName self, char const * str)
        setValue(SoMFName self, SoMFName other)
        """
        return _coin.SoMFName_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SbName const *":
        r"""getValues(SoMFName self, int i=0) -> SbName"""
        return _coin.SoMFName_getValues(self, i)

# Register SoMFName in _coin:
_coin.SoMFName_swigregister(SoMFName)

def SoMFName_createInstance() -> "void *":
    r"""SoMFName_createInstance() -> void *"""
    return _coin.SoMFName_createInstance()

def SoMFName_getClassTypeId() -> "SoType":
    r"""SoMFName_getClassTypeId() -> SoType"""
    return _coin.SoMFName_getClassTypeId()

def SoMFName_initClass() -> "void":
    r"""SoMFName_initClass()"""
    return _coin.SoMFName_initClass()

class SoNodeKitListPart(SoNode):
    r"""Proxy of C++ SoNodeKitListPart class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNodeKitListPart_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNodeKitListPart self) -> SoType"""
        return _coin.SoNodeKitListPart_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNodeKitListPart_initClass()

    def __init__(self):
        r"""__init__(SoNodeKitListPart self) -> SoNodeKitListPart"""
        _coin.SoNodeKitListPart_swiginit(self, _coin.new_SoNodeKitListPart())

    def getContainerType(self) -> "SoType":
        r"""getContainerType(SoNodeKitListPart self) -> SoType"""
        return _coin.SoNodeKitListPart_getContainerType(self)

    def setContainerType(self, newContainerType: "SoType") -> "void":
        r"""setContainerType(SoNodeKitListPart self, SoType newContainerType)"""
        return _coin.SoNodeKitListPart_setContainerType(self, newContainerType)

    def getChildTypes(self) -> "SoTypeList const &":
        r"""getChildTypes(SoNodeKitListPart self) -> SoTypeList"""
        return _coin.SoNodeKitListPart_getChildTypes(self)

    def addChildType(self, typeToAdd: "SoType") -> "void":
        r"""addChildType(SoNodeKitListPart self, SoType typeToAdd)"""
        return _coin.SoNodeKitListPart_addChildType(self, typeToAdd)

    def isTypePermitted(self, typeToCheck: "SoType") -> "SbBool":
        r"""isTypePermitted(SoNodeKitListPart self, SoType typeToCheck) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypePermitted(self, typeToCheck)

    def isChildPermitted(self, child: "SoNode") -> "SbBool":
        r"""isChildPermitted(SoNodeKitListPart self, SoNode child) -> SbBool"""
        return _coin.SoNodeKitListPart_isChildPermitted(self, child)

    def containerSet(self, fieldDataString: "char const *") -> "void":
        r"""containerSet(SoNodeKitListPart self, char const * fieldDataString)"""
        return _coin.SoNodeKitListPart_containerSet(self, fieldDataString)

    def lockTypes(self) -> "void":
        r"""lockTypes(SoNodeKitListPart self)"""
        return _coin.SoNodeKitListPart_lockTypes(self)

    def isTypeLocked(self) -> "SbBool":
        r"""isTypeLocked(SoNodeKitListPart self) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypeLocked(self)

    def addChild(self, child: "SoNode") -> "void":
        r"""addChild(SoNodeKitListPart self, SoNode child)"""
        return _coin.SoNodeKitListPart_addChild(self, child)

    def insertChild(self, child: "SoNode", childIndex: "int") -> "void":
        r"""insertChild(SoNodeKitListPart self, SoNode child, int childIndex)"""
        return _coin.SoNodeKitListPart_insertChild(self, child, childIndex)

    def getChild(self, index: "int") -> "SoNode *":
        r"""getChild(SoNodeKitListPart self, int index) -> SoNode"""
        return _coin.SoNodeKitListPart_getChild(self, index)

    def findChild(self, child: "SoNode") -> "int":
        r"""findChild(SoNodeKitListPart self, SoNode child) -> int"""
        return _coin.SoNodeKitListPart_findChild(self, child)

    def getNumChildren(self) -> "int":
        r"""getNumChildren(SoNodeKitListPart self) -> int"""
        return _coin.SoNodeKitListPart_getNumChildren(self)

    def removeChild(self, *args) -> "void":
        r"""
        removeChild(SoNodeKitListPart self, int index)
        removeChild(SoNodeKitListPart self, SoNode child)
        """
        return _coin.SoNodeKitListPart_removeChild(self, *args)

    def replaceChild(self, *args) -> "void":
        r"""
        replaceChild(SoNodeKitListPart self, int index, SoNode newChild)
        replaceChild(SoNodeKitListPart self, SoNode oldChild, SoNode newChild)
        """
        return _coin.SoNodeKitListPart_replaceChild(self, *args)

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoNodeKitListPart self) -> SbBool"""
        return _coin.SoNodeKitListPart_affectsState(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoNodeKitListPart self, SoAction action)"""
        return _coin.SoNodeKitListPart_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoNodeKitListPart self, SoCallbackAction action)"""
        return _coin.SoNodeKitListPart_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoNodeKitListPart self, SoGLRenderAction action)"""
        return _coin.SoNodeKitListPart_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoNodeKitListPart self, SoGetBoundingBoxAction action)"""
        return _coin.SoNodeKitListPart_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoNodeKitListPart self, SoGetMatrixAction action)"""
        return _coin.SoNodeKitListPart_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoNodeKitListPart self, SoHandleEventAction action)"""
        return _coin.SoNodeKitListPart_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoNodeKitListPart self, SoPickAction action)"""
        return _coin.SoNodeKitListPart_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoNodeKitListPart self, SoSearchAction action)"""
        return _coin.SoNodeKitListPart_search(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoNodeKitListPart self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNodeKitListPart_getPrimitiveCount(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoNodeKitListPart self) -> SoChildList"""
        return _coin.SoNodeKitListPart_getChildren(self)

# Register SoNodeKitListPart in _coin:
_coin.SoNodeKitListPart_swigregister(SoNodeKitListPart)

def SoNodeKitListPart_getClassTypeId() -> "SoType":
    r"""SoNodeKitListPart_getClassTypeId() -> SoType"""
    return _coin.SoNodeKitListPart_getClassTypeId()

def SoNodeKitListPart_initClass() -> "void":
    r"""SoNodeKitListPart_initClass()"""
    return _coin.SoNodeKitListPart_initClass()

class SoNodeKitPath(SoPath):
    r"""Proxy of C++ SoNodeKitPath class."""

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

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

    def getLength(self) -> "int":
        r"""getLength(SoNodeKitPath self) -> int"""
        return _coin.SoNodeKitPath_getLength(self)

    def getTail(self) -> "SoNode *":
        r"""getTail(SoNodeKitPath self) -> SoNode"""
        return _coin.SoNodeKitPath_getTail(self)

    def getNode(self, idx: "int const") -> "SoNode *":
        r"""getNode(SoNodeKitPath self, int const idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNode(self, idx)

    def getNodeFromTail(self, idx: "int const") -> "SoNode *":
        r"""getNodeFromTail(SoNodeKitPath self, int const idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNodeFromTail(self, idx)

    def truncate(self, length: "int const") -> "void":
        r"""truncate(SoNodeKitPath self, int const length)"""
        return _coin.SoNodeKitPath_truncate(self, length)

    def pop(self) -> "void":
        r"""pop(SoNodeKitPath self)"""
        return _coin.SoNodeKitPath_pop(self)

    def append(self, *args) -> "void":
        r"""
        append(SoNodeKitPath self, SoBaseKit childKit)
        append(SoNodeKitPath self, SoNodeKitPath fromPath)
        """
        return _coin.SoNodeKitPath_append(self, *args)

    def containsNode(self, node: "SoBaseKit") -> "SbBool":
        r"""containsNode(SoNodeKitPath self, SoBaseKit node) -> SbBool"""
        return _coin.SoNodeKitPath_containsNode(self, node)

    def findFork(self, path: "SoNodeKitPath") -> "int":
        r"""findFork(SoNodeKitPath self, SoNodeKitPath path) -> int"""
        return _coin.SoNodeKitPath_findFork(self, path)

    def __iter__(self):
       for i in range(self.getLength()):
          yield self.getNode(i)

    def index(self):
       for i in range(self.getLength()):
          yield self.getIndex(i)


    def __eq__(self, u: "SoNodeKitPath") -> "int":
        r"""__eq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___eq__(self, u)

    def __nq__(self, u: "SoNodeKitPath") -> "int":
        r"""__nq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___nq__(self, u)

# Register SoNodeKitPath in _coin:
_coin.SoNodeKitPath_swigregister(SoNodeKitPath)

class SoChildList(SoNodeList):
    r"""Proxy of C++ SoChildList class."""

    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):
        r"""
        __init__(SoChildList self, SoNode parent) -> SoChildList
        __init__(SoChildList self, SoNode parent, int const size) -> SoChildList
        __init__(SoChildList self, SoNode parent, SoChildList cl) -> SoChildList
        """
        _coin.SoChildList_swiginit(self, _coin.new_SoChildList(*args))
    __swig_destroy__ = _coin.delete_SoChildList

    def append(self, node: "SoNode") -> "void":
        r"""append(SoChildList self, SoNode node)"""
        return _coin.SoChildList_append(self, node)

    def insert(self, ptr: "SoNode", addbefore: "int const") -> "void":
        r"""insert(SoChildList self, SoNode ptr, int const addbefore)"""
        return _coin.SoChildList_insert(self, ptr, addbefore)

    def remove(self, index: "int const") -> "void":
        r"""remove(SoChildList self, int const index)"""
        return _coin.SoChildList_remove(self, index)

    def truncate(self, length: "int const") -> "void":
        r"""truncate(SoChildList self, int const length)"""
        return _coin.SoChildList_truncate(self, length)

    def copy(self, cl: "SoChildList") -> "void":
        r"""copy(SoChildList self, SoChildList cl)"""
        return _coin.SoChildList_copy(self, cl)

    def set(self, index: "int const", node: "SoNode") -> "void":
        r"""set(SoChildList self, int const index, SoNode node)"""
        return _coin.SoChildList_set(self, index, node)

    def traverseInPath(self, action: "SoAction", numindices: "int const", indices: "int const *") -> "void":
        r"""traverseInPath(SoChildList self, SoAction action, int const numindices, int const * indices)"""
        return _coin.SoChildList_traverseInPath(self, action, numindices, indices)

    def traverse(self, *args) -> "void":
        r"""
        traverse(SoChildList self, SoAction action)
        traverse(SoChildList self, SoAction action, int const index)
        traverse(SoChildList self, SoAction action, SoNode node)
        traverse(SoChildList self, SoAction action, int const first, int const last)
        """
        return _coin.SoChildList_traverse(self, *args)

    def addPathAuditor(self, path: "SoPath") -> "void":
        r"""addPathAuditor(SoChildList self, SoPath path)"""
        return _coin.SoChildList_addPathAuditor(self, path)

    def removePathAuditor(self, path: "SoPath") -> "void":
        r"""removePathAuditor(SoChildList self, SoPath path)"""
        return _coin.SoChildList_removePathAuditor(self, path)

# Register SoChildList in _coin:
_coin.SoChildList_swigregister(SoChildList)

class SoBaseKit(SoNode):
    r"""Proxy of C++ SoBaseKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBaseKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBaseKit self) -> SoType"""
        return _coin.SoBaseKit_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBaseKit_initClass()

    def __init__(self):
        r"""__init__(SoBaseKit self) -> SoBaseKit"""
        _coin.SoBaseKit_swiginit(self, _coin.new_SoBaseKit())

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoBaseKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoBaseKit self) -> SoNodekitCatalog"""
        return _coin.SoBaseKit_getNodekitCatalog(self)

    def getPart(self, partname: "SbName", makeifneeded: "SbBool") -> "SoNode *":
        r"""getPart(SoBaseKit self, SbName partname, SbBool makeifneeded) -> SoNode"""
        return _coin.SoBaseKit_getPart(self, partname, makeifneeded)

    def getPartString(self, part: "SoBase") -> "SbString":
        r"""getPartString(SoBaseKit self, SoBase part) -> SbString"""
        return _coin.SoBaseKit_getPartString(self, part)

    def createPathToPart(self, partname: "SbName", makeifneeded: "SbBool", pathtoextend: "SoPath"=None) -> "SoNodeKitPath *":
        r"""createPathToPart(SoBaseKit self, SbName partname, SbBool makeifneeded, SoPath pathtoextend=None) -> SoNodeKitPath"""
        return _coin.SoBaseKit_createPathToPart(self, partname, makeifneeded, pathtoextend)

    def setPart(self, partname: "SbName", srcFrom: "SoNode") -> "SbBool":
        r"""setPart(SoBaseKit self, SbName partname, SoNode srcFrom) -> SbBool"""
        return _coin.SoBaseKit_setPart(self, partname, srcFrom)

    def set(self, *args) -> "SbBool":
        r"""
        set(SoBaseKit self, char const * namevaluepairliststring) -> SbBool
        set(SoBaseKit self, char const * partnamestring, char const * parameterstring) -> SbBool
        """
        return _coin.SoBaseKit_set(self, *args)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoBaseKit self, SoAction action)"""
        return _coin.SoBaseKit_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoBaseKit self, SoCallbackAction action)"""
        return _coin.SoBaseKit_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoBaseKit self, SoGLRenderAction action)"""
        return _coin.SoBaseKit_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoBaseKit self, SoGetBoundingBoxAction action)"""
        return _coin.SoBaseKit_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoBaseKit self, SoGetMatrixAction action)"""
        return _coin.SoBaseKit_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoBaseKit self, SoHandleEventAction action)"""
        return _coin.SoBaseKit_handleEvent(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoBaseKit self, SoRayPickAction action)"""
        return _coin.SoBaseKit_rayPick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoBaseKit self, SoSearchAction action)"""
        return _coin.SoBaseKit_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoBaseKit self, SoWriteAction action)"""
        return _coin.SoBaseKit_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoBaseKit self, SoGetPrimitiveCountAction action)"""
        return _coin.SoBaseKit_getPrimitiveCount(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoBaseKit self) -> SoChildList"""
        return _coin.SoBaseKit_getChildren(self)

    def printDiagram(self) -> "void":
        r"""printDiagram(SoBaseKit self)"""
        return _coin.SoBaseKit_printDiagram(self)

    def printSubDiagram(self, rootname: "SbName", level: "int") -> "void":
        r"""printSubDiagram(SoBaseKit self, SbName rootname, int level)"""
        return _coin.SoBaseKit_printSubDiagram(self, rootname, level)

    def printTable(self) -> "void":
        r"""printTable(SoBaseKit self)"""
        return _coin.SoBaseKit_printTable(self)

    def addWriteReference(self, out: "SoOutput", isfromfield: "SbBool"=0) -> "void":
        r"""addWriteReference(SoBaseKit self, SoOutput out, SbBool isfromfield=0)"""
        return _coin.SoBaseKit_addWriteReference(self, out, isfromfield)

    def forceChildDrivenWriteRefs(self, out: "SoOutput") -> "SbBool":
        r"""forceChildDrivenWriteRefs(SoBaseKit self, SoOutput out) -> SbBool"""
        return _coin.SoBaseKit_forceChildDrivenWriteRefs(self, out)

    @staticmethod
    def isSearchingChildren() -> "SbBool":
        r"""isSearchingChildren() -> SbBool"""
        return _coin.SoBaseKit_isSearchingChildren()

    @staticmethod
    def setSearchingChildren(newval: "SbBool const") -> "void":
        r"""setSearchingChildren(SbBool const newval)"""
        return _coin.SoBaseKit_setSearchingChildren(newval)

    def __getattr__(self,name):
       c = _coin.SoBaseKit_getNodekitCatalog(self)
       if c.getPartNumber(name) >= 0:
           part = self.getPart(name,1)
           return part
       return SoNode.__getattr__(self, name)

    def __setattr__(self,name,value):
       if name == 'this':
          return SoNode.__setattr__(self,name,value)
       c = _coin.SoBaseKit_getNodekitCatalog(self)
       if c.getPartNumber(name) >= 0:
          return self.setPart(name, value)
       return SoNode.__setattr__(self,name,value)       


# Register SoBaseKit in _coin:
_coin.SoBaseKit_swigregister(SoBaseKit)

def SoBaseKit_getClassTypeId() -> "SoType":
    r"""SoBaseKit_getClassTypeId() -> SoType"""
    return _coin.SoBaseKit_getClassTypeId()

def SoBaseKit_initClass() -> "void":
    r"""SoBaseKit_initClass()"""
    return _coin.SoBaseKit_initClass()

def SoBaseKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoBaseKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoBaseKit_getClassNodekitCatalog()

def SoBaseKit_isSearchingChildren() -> "SbBool":
    r"""SoBaseKit_isSearchingChildren() -> SbBool"""
    return _coin.SoBaseKit_isSearchingChildren()

def SoBaseKit_setSearchingChildren(newval: "SbBool const") -> "void":
    r"""SoBaseKit_setSearchingChildren(SbBool const newval)"""
    return _coin.SoBaseKit_setSearchingChildren(newval)

class SoSensor(object):
    r"""Proxy of C++ SoSensor class."""

    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__ = _coin.delete_SoSensor

    def setFunction(self, callbackfunction: "SoSensorCB *") -> "void":
        r"""setFunction(SoSensor self, SoSensorCB * callbackfunction)"""
        return _coin.SoSensor_setFunction(self, callbackfunction)

    def getFunction(self) -> "SoSensorCBPtr":
        r"""getFunction(SoSensor self) -> SoSensorCBPtr"""
        return _coin.SoSensor_getFunction(self)

    def setData(self, callbackdata: "void *") -> "void":
        r"""setData(SoSensor self, void * callbackdata)"""
        return _coin.SoSensor_setData(self, callbackdata)

    def getData(self) -> "void *":
        r"""getData(SoSensor self) -> void *"""
        return _coin.SoSensor_getData(self)

    def schedule(self) -> "void":
        r"""schedule(SoSensor self)"""
        return _coin.SoSensor_schedule(self)

    def unschedule(self) -> "void":
        r"""unschedule(SoSensor self)"""
        return _coin.SoSensor_unschedule(self)

    def isScheduled(self) -> "SbBool":
        r"""isScheduled(SoSensor self) -> SbBool"""
        return _coin.SoSensor_isScheduled(self)

    def trigger(self) -> "void":
        r"""trigger(SoSensor self)"""
        return _coin.SoSensor_trigger(self)

    def isBefore(self, s: "SoSensor") -> "SbBool":
        r"""isBefore(SoSensor self, SoSensor s) -> SbBool"""
        return _coin.SoSensor_isBefore(self, s)

    def setNextInQueue(self, next: "SoSensor") -> "void":
        r"""setNextInQueue(SoSensor self, SoSensor next)"""
        return _coin.SoSensor_setNextInQueue(self, next)

    def getNextInQueue(self) -> "SoSensor *":
        r"""getNextInQueue(SoSensor self) -> SoSensor"""
        return _coin.SoSensor_getNextInQueue(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSensor_initClass()

# Register SoSensor in _coin:
_coin.SoSensor_swigregister(SoSensor)

def SoSensor_initClass() -> "void":
    r"""SoSensor_initClass()"""
    return _coin.SoSensor_initClass()

class SoDelayQueueSensor(SoSensor):
    r"""Proxy of C++ SoDelayQueueSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoDelayQueueSensor *"))
          newobj = _coin.new_SoDelayQueueSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoDelayQueueSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoDelayQueueSensor

    def setPriority(self, pri: "uint32_t") -> "void":
        r"""setPriority(SoDelayQueueSensor self, uint32_t pri)"""
        return _coin.SoDelayQueueSensor_setPriority(self, pri)

    def getPriority(self) -> "uint32_t":
        r"""getPriority(SoDelayQueueSensor self) -> uint32_t"""
        return _coin.SoDelayQueueSensor_getPriority(self)

    @staticmethod
    def getDefaultPriority() -> "uint32_t":
        r"""getDefaultPriority() -> uint32_t"""
        return _coin.SoDelayQueueSensor_getDefaultPriority()

    def schedule(self) -> "void":
        r"""schedule(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_schedule(self)

    def unschedule(self) -> "void":
        r"""unschedule(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_unschedule(self)

    def isScheduled(self) -> "SbBool":
        r"""isScheduled(SoDelayQueueSensor self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isScheduled(self)

    def isIdleOnly(self) -> "SbBool":
        r"""isIdleOnly(SoDelayQueueSensor self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isIdleOnly(self)

    def trigger(self) -> "void":
        r"""trigger(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_trigger(self)

# Register SoDelayQueueSensor in _coin:
_coin.SoDelayQueueSensor_swigregister(SoDelayQueueSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoDelayQueueSensor *"))
      newobj = _coin.new_SoDelayQueueSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoDelayQueueSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



def SoDelayQueueSensor_getDefaultPriority() -> "uint32_t":
    r"""SoDelayQueueSensor_getDefaultPriority() -> uint32_t"""
    return _coin.SoDelayQueueSensor_getDefaultPriority()

class SoDataSensor(SoDelayQueueSensor):
    r"""Proxy of C++ SoDataSensor class."""

    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__ = _coin.delete_SoDataSensor

    def setDeleteCallback(self, function: "SoSensorCB *", data: "void *"=None) -> "void":
        r"""setDeleteCallback(SoDataSensor self, SoSensorCB * function, void * data=None)"""
        return _coin.SoDataSensor_setDeleteCallback(self, function, data)

    def getTriggerNode(self) -> "SoNode *":
        r"""getTriggerNode(SoDataSensor self) -> SoNode"""
        return _coin.SoDataSensor_getTriggerNode(self)

    def getTriggerField(self) -> "SoField *":
        r"""getTriggerField(SoDataSensor self) -> SoField"""
        return _coin.SoDataSensor_getTriggerField(self)

    def getTriggerPath(self) -> "SoPath *":
        r"""getTriggerPath(SoDataSensor self) -> SoPath"""
        return _coin.SoDataSensor_getTriggerPath(self)

    def setTriggerPathFlag(self, flag: "SbBool") -> "void":
        r"""setTriggerPathFlag(SoDataSensor self, SbBool flag)"""
        return _coin.SoDataSensor_setTriggerPathFlag(self, flag)

    def getTriggerPathFlag(self) -> "SbBool":
        r"""getTriggerPathFlag(SoDataSensor self) -> SbBool"""
        return _coin.SoDataSensor_getTriggerPathFlag(self)

    def getTriggerOperationType(self) -> "SoNotRec::OperationType":
        r"""getTriggerOperationType(SoDataSensor self) -> SoNotRec::OperationType"""
        return _coin.SoDataSensor_getTriggerOperationType(self)

    def getTriggerIndex(self) -> "int":
        r"""getTriggerIndex(SoDataSensor self) -> int"""
        return _coin.SoDataSensor_getTriggerIndex(self)

    def getTriggerFieldNumIndices(self) -> "int":
        r"""getTriggerFieldNumIndices(SoDataSensor self) -> int"""
        return _coin.SoDataSensor_getTriggerFieldNumIndices(self)

    def getTriggerGroupChild(self) -> "SoNode *":
        r"""getTriggerGroupChild(SoDataSensor self) -> SoNode"""
        return _coin.SoDataSensor_getTriggerGroupChild(self)

    def getTriggerReplacedGroupChild(self) -> "SoNode *":
        r"""getTriggerReplacedGroupChild(SoDataSensor self) -> SoNode"""
        return _coin.SoDataSensor_getTriggerReplacedGroupChild(self)

    def trigger(self) -> "void":
        r"""trigger(SoDataSensor self)"""
        return _coin.SoDataSensor_trigger(self)

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoDataSensor self, SoNotList l)"""
        return _coin.SoDataSensor_notify(self, l)

    def dyingReference(self) -> "void":
        r"""dyingReference(SoDataSensor self)"""
        return _coin.SoDataSensor_dyingReference(self)

# Register SoDataSensor in _coin:
_coin.SoDataSensor_swigregister(SoDataSensor)

class SoFieldSensor(SoDataSensor):
    r"""Proxy of C++ SoFieldSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoFieldSensor *"))
          newobj = _coin.new_SoFieldSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoFieldSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoFieldSensor

    def attach(self, field: "SoField") -> "void":
        r"""attach(SoFieldSensor self, SoField field)"""
        return _coin.SoFieldSensor_attach(self, field)

    def detach(self) -> "void":
        r"""detach(SoFieldSensor self)"""
        return _coin.SoFieldSensor_detach(self)

    def getAttachedField(self) -> "SoField *":
        r"""getAttachedField(SoFieldSensor self) -> SoField"""
        return _coin.SoFieldSensor_getAttachedField(self)

    def trigger(self) -> "void":
        r"""trigger(SoFieldSensor self)"""
        return _coin.SoFieldSensor_trigger(self)

# Register SoFieldSensor in _coin:
_coin.SoFieldSensor_swigregister(SoFieldSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoFieldSensor *"))
      newobj = _coin.new_SoFieldSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoFieldSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoInteractionKit(SoBaseKit):
    r"""Proxy of C++ SoInteractionKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInteractionKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInteractionKit self) -> SoType"""
        return _coin.SoInteractionKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoInteractionKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoInteractionKit self) -> SoNodekitCatalog"""
        return _coin.SoInteractionKit_getNodekitCatalog(self)
    renderCaching = property(_coin.SoInteractionKit_renderCaching_get, _coin.SoInteractionKit_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoInteractionKit_boundingBoxCaching_get, _coin.SoInteractionKit_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoInteractionKit_renderCulling_get, _coin.SoInteractionKit_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoInteractionKit_pickCulling_get, _coin.SoInteractionKit_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")

    def __init__(self):
        r"""__init__(SoInteractionKit self) -> SoInteractionKit"""
        _coin.SoInteractionKit_swiginit(self, _coin.new_SoInteractionKit())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInteractionKit_initClass()
    OFF = _coin.SoInteractionKit_OFF
    
    ON = _coin.SoInteractionKit_ON
    
    AUTO = _coin.SoInteractionKit_AUTO
    

    def setPartAsPath(self, partname: "SbName", path: "SoPath") -> "SbBool":
        r"""setPartAsPath(SoInteractionKit self, SbName partname, SoPath path) -> SbBool"""
        return _coin.SoInteractionKit_setPartAsPath(self, partname, path)

    def setPartAsDefault(self, *args) -> "SbBool":
        r"""
        setPartAsDefault(SoInteractionKit self, SbName partname, SoNode node, SbBool onlyifdefault=1) -> SbBool
        setPartAsDefault(SoInteractionKit self, SbName partname, SbName nodename, SbBool onlyifdefault=1) -> SbBool
        """
        return _coin.SoInteractionKit_setPartAsDefault(self, *args)

    def isPathSurrogateInMySubgraph(self, *args) -> "SbBool":
        r"""
        isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path, SoPath *& pathToOwner, SbName surrogatename, SoPath *& surrogatepath, SbBool fillargs=1) -> SbBool
        isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path) -> SbBool
        """
        return _coin.SoInteractionKit_isPathSurrogateInMySubgraph(self, *args)

    @staticmethod
    def setSwitchValue(node: "SoNode", newVal: "int const") -> "void":
        r"""setSwitchValue(SoNode node, int const newVal)"""
        return _coin.SoInteractionKit_setSwitchValue(node, newVal)

    def setPart(self, partname: "SbName", srcFrom: "SoNode") -> "SbBool":
        r"""setPart(SoInteractionKit self, SbName partname, SoNode srcFrom) -> SbBool"""
        return _coin.SoInteractionKit_setPart(self, partname, srcFrom)

# Register SoInteractionKit in _coin:
_coin.SoInteractionKit_swigregister(SoInteractionKit)

def SoInteractionKit_getClassTypeId() -> "SoType":
    r"""SoInteractionKit_getClassTypeId() -> SoType"""
    return _coin.SoInteractionKit_getClassTypeId()

def SoInteractionKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoInteractionKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoInteractionKit_getClassNodekitCatalog()

def SoInteractionKit_initClass() -> "void":
    r"""SoInteractionKit_initClass()"""
    return _coin.SoInteractionKit_initClass()

def SoInteractionKit_setSwitchValue(node: "SoNode", newVal: "int const") -> "void":
    r"""SoInteractionKit_setSwitchValue(SoNode node, int const newVal)"""
    return _coin.SoInteractionKit_setSwitchValue(node, newVal)

class SoCallbackList(object):
    r"""Proxy of C++ SoCallbackList class."""

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

    def __init__(self):
        r"""__init__(SoCallbackList self) -> SoCallbackList"""
        _coin.SoCallbackList_swiginit(self, _coin.new_SoCallbackList())
    __swig_destroy__ = _coin.delete_SoCallbackList

    def addCallback(self, f: "SoCallbackListCB *", userData: "void *"=None) -> "void":
        r"""addCallback(SoCallbackList self, SoCallbackListCB * f, void * userData=None)"""
        return _coin.SoCallbackList_addCallback(self, f, userData)

    def removeCallback(self, f: "SoCallbackListCB *", userdata: "void *"=None) -> "void":
        r"""removeCallback(SoCallbackList self, SoCallbackListCB * f, void * userdata=None)"""
        return _coin.SoCallbackList_removeCallback(self, f, userdata)

    def clearCallbacks(self) -> "void":
        r"""clearCallbacks(SoCallbackList self)"""
        return _coin.SoCallbackList_clearCallbacks(self)

    def getNumCallbacks(self) -> "int":
        r"""getNumCallbacks(SoCallbackList self) -> int"""
        return _coin.SoCallbackList_getNumCallbacks(self)

    def invokeCallbacks(self, callbackdata: "void *") -> "void":
        r"""invokeCallbacks(SoCallbackList self, void * callbackdata)"""
        return _coin.SoCallbackList_invokeCallbacks(self, callbackdata)

# Register SoCallbackList in _coin:
_coin.SoCallbackList_swigregister(SoCallbackList)

class SbVec3d(object):
    r"""Proxy of C++ SbVec3d class."""

    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):
        r"""
        __init__(SbVec3d self) -> SbVec3d
        __init__(SbVec3d self, double const [3] v) -> SbVec3d
        __init__(SbVec3d self, double x, double y, double z) -> SbVec3d
        __init__(SbVec3d self, SbVec3f v) -> SbVec3d
        __init__(SbVec3d self, SbVec3b v) -> SbVec3d
        __init__(SbVec3d self, SbVec3s v) -> SbVec3d
        __init__(SbVec3d self, SbVec3i32 v) -> SbVec3d
        __init__(SbVec3d self, SbDPPlane p0, SbDPPlane p1, SbDPPlane p2) -> SbVec3d
        """
        _coin.SbVec3d_swiginit(self, _coin.new_SbVec3d(*args))

    def setValue(self, *args) -> "SbVec3d &":
        r"""
        setValue(SbVec3d self, double const [3] v) -> SbVec3d
        setValue(SbVec3d self, double x, double y, double z) -> SbVec3d
        setValue(SbVec3d self, SbVec3d barycentric, SbVec3d v0, SbVec3d v1, SbVec3d v2) -> SbVec3d
        setValue(SbVec3d self, SbVec3f v) -> SbVec3d
        setValue(SbVec3d self, SbVec3b v) -> SbVec3d
        setValue(SbVec3d self, SbVec3s v) -> SbVec3d
        setValue(SbVec3d self, SbVec3i32 v) -> SbVec3d
        """
        return _coin.SbVec3d_setValue(self, *args)

    def getValue(self) -> "double const *":
        r"""getValue(SbVec3d self) -> double const *"""
        return _coin.SbVec3d_getValue(self)

    def cross(self, v: "SbVec3d") -> "SbVec3d":
        r"""cross(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d_cross(self, v)

    def dot(self, v: "SbVec3d") -> "double":
        r"""dot(SbVec3d self, SbVec3d v) -> double"""
        return _coin.SbVec3d_dot(self, v)

    def equals(self, v: "SbVec3d", tolerance: "double") -> "SbBool":
        r"""equals(SbVec3d self, SbVec3d v, double tolerance) -> SbBool"""
        return _coin.SbVec3d_equals(self, v, tolerance)

    def getClosestAxis(self) -> "SbVec3d":
        r"""getClosestAxis(SbVec3d self) -> SbVec3d"""
        return _coin.SbVec3d_getClosestAxis(self)

    def length(self) -> "double":
        r"""length(SbVec3d self) -> double"""
        return _coin.SbVec3d_length(self)

    def sqrLength(self) -> "double":
        r"""sqrLength(SbVec3d self) -> double"""
        return _coin.SbVec3d_sqrLength(self)

    def negate(self) -> "void":
        r"""negate(SbVec3d self)"""
        return _coin.SbVec3d_negate(self)

    def normalize(self) -> "double":
        r"""normalize(SbVec3d self) -> double"""
        return _coin.SbVec3d_normalize(self)

    def __imul__(self, d: "double") -> "SbVec3d &":
        r"""__imul__(SbVec3d self, double d) -> SbVec3d"""
        return _coin.SbVec3d___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec3d___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec3d") -> "SbVec3d &":
        r"""__iadd__(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___iadd__(self, v)

    def __isub__(self, v: "SbVec3d") -> "SbVec3d &":
        r"""__isub__(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___isub__(self, v)

    def __neg__(self) -> "SbVec3d":
        r"""__neg__(SbVec3d self) -> SbVec3d"""
        return _coin.SbVec3d___neg__(self)

    def toString(self) -> "SbString":
        r"""toString(SbVec3d self) -> SbString"""
        return _coin.SbVec3d_toString(self)

    def fromString(self, str: "SbString") -> "SbBool":
        r"""fromString(SbVec3d self, SbString str) -> SbBool"""
        return _coin.SbVec3d_fromString(self, str)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec3d self, FILE * fp)"""
        return _coin.SbVec3d_output(self, fp)

    def __add__(self, u: "SbVec3d") -> "SbVec3d":
        r"""__add__(SbVec3d self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___add__(self, u)

    def __sub__(self, u: "SbVec3d") -> "SbVec3d":
        r"""__sub__(SbVec3d self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___sub__(self, u)

    def __mul__(self, *args) -> "SbVec3d":
        r"""
        __mul__(SbVec3d self, double const d) -> SbVec3d
        __mul__(SbVec3d self, SbDPMatrix m) -> SbVec3d
        """
        return _coin.SbVec3d___mul__(self, *args)

    def __rmul__(self, d: "double const") -> "SbVec3d":
        r"""__rmul__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___rmul__(self, d)

    def __div__(self, d: "double const") -> "SbVec3d":
        r"""__div__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___div__(self, d)

    def __truediv__(self, d: "double const") -> "SbVec3d":
        r"""__truediv__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___truediv__(self, d)

    def __eq__(self, u: "SbVec3d") -> "int":
        r"""__eq__(SbVec3d self, SbVec3d u) -> int"""
        return _coin.SbVec3d___eq__(self, u)

    def __nq__(self, u: "SbVec3d") -> "int":
        r"""__nq__(SbVec3d self, SbVec3d u) -> int"""
        return _coin.SbVec3d___nq__(self, u)

    def __getitem__(self, i: "int") -> "double":
        r"""__getitem__(SbVec3d self, int i) -> double"""
        return _coin.SbVec3d___getitem__(self, i)

    def __setitem__(self, i: "int", value: "double") -> "void":
        r"""__setitem__(SbVec3d self, int i, double value)"""
        return _coin.SbVec3d___setitem__(self, i, value)

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

    def __len__(self):
          return 3

    __swig_destroy__ = _coin.delete_SbVec3d

# Register SbVec3d in _coin:
_coin.SbVec3d_swigregister(SbVec3d)

class SbDPViewVolume(object):
    r"""Proxy of C++ SbDPViewVolume class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ORTHOGRAPHIC = _coin.SbDPViewVolume_ORTHOGRAPHIC
    
    PERSPECTIVE = _coin.SbDPViewVolume_PERSPECTIVE
    

    def __init__(self):
        r"""__init__(SbDPViewVolume self) -> SbDPViewVolume"""
        _coin.SbDPViewVolume_swiginit(self, _coin.new_SbDPViewVolume())
    __swig_destroy__ = _coin.delete_SbDPViewVolume

    def getMatrices(self, affine: "SbDPMatrix", proj: "SbDPMatrix") -> "void":
        r"""getMatrices(SbDPViewVolume self, SbDPMatrix affine, SbDPMatrix proj)"""
        return _coin.SbDPViewVolume_getMatrices(self, affine, proj)

    def getMatrix(self) -> "SbDPMatrix":
        r"""getMatrix(SbDPViewVolume self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getMatrix(self)

    def getCameraSpaceMatrix(self) -> "SbDPMatrix":
        r"""getCameraSpaceMatrix(SbDPViewVolume self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getCameraSpaceMatrix(self)

    def projectPointToLine(self, *args) -> "void":
        r"""
        projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbDPLine line)
        projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbVec3d line0, SbVec3d line1)
        """
        return _coin.SbDPViewVolume_projectPointToLine(self, *args)

    def projectToScreen(self, src: "SbVec3d", dst: "SbVec3d") -> "void":
        r"""projectToScreen(SbDPViewVolume self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPViewVolume_projectToScreen(self, src, dst)

    def getPlane(self, distFromEye: "double const") -> "SbPlane":
        r"""getPlane(SbDPViewVolume self, double const distFromEye) -> SbPlane"""
        return _coin.SbDPViewVolume_getPlane(self, distFromEye)

    def getSightPoint(self, distFromEye: "double const") -> "SbVec3d":
        r"""getSightPoint(SbDPViewVolume self, double const distFromEye) -> SbVec3d"""
        return _coin.SbDPViewVolume_getSightPoint(self, distFromEye)

    def getPlanePoint(self, distFromEye: "double const", normPoint: "SbVec2d") -> "SbVec3d":
        r"""getPlanePoint(SbDPViewVolume self, double const distFromEye, SbVec2d normPoint) -> SbVec3d"""
        return _coin.SbDPViewVolume_getPlanePoint(self, distFromEye, normPoint)

    def getAlignRotation(self, rightAngleOnly: "SbBool"=0) -> "SbDPRotation":
        r"""getAlignRotation(SbDPViewVolume self, SbBool rightAngleOnly=0) -> SbDPRotation"""
        return _coin.SbDPViewVolume_getAlignRotation(self, rightAngleOnly)

    def getWorldToScreenScale(self, worldCenter: "SbVec3d", normRadius: "double") -> "double":
        r"""getWorldToScreenScale(SbDPViewVolume self, SbVec3d worldCenter, double normRadius) -> double"""
        return _coin.SbDPViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)

    def projectBox(self, box: "SbBox3f") -> "SbVec2d":
        r"""projectBox(SbDPViewVolume self, SbBox3f box) -> SbVec2d"""
        return _coin.SbDPViewVolume_projectBox(self, box)

    def narrow(self, *args) -> "SbDPViewVolume":
        r"""
        narrow(SbDPViewVolume self, double left, double bottom, double right, double top) -> SbDPViewVolume
        narrow(SbDPViewVolume self, SbBox3f box) -> SbDPViewVolume
        """
        return _coin.SbDPViewVolume_narrow(self, *args)

    def ortho(self, left: "double", right: "double", bottom: "double", top: "double", nearval: "double", farval: "double") -> "void":
        r"""ortho(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"""
        return _coin.SbDPViewVolume_ortho(self, left, right, bottom, top, nearval, farval)

    def perspective(self, fovy: "double", aspect: "double", nearval: "double", farval: "double") -> "void":
        r"""perspective(SbDPViewVolume self, double fovy, double aspect, double nearval, double farval)"""
        return _coin.SbDPViewVolume_perspective(self, fovy, aspect, nearval, farval)

    def frustum(self, left: "double", right: "double", bottom: "double", top: "double", nearval: "double", farval: "double") -> "void":
        r"""frustum(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"""
        return _coin.SbDPViewVolume_frustum(self, left, right, bottom, top, nearval, farval)

    def rotateCamera(self, q: "SbDPRotation") -> "void":
        r"""rotateCamera(SbDPViewVolume self, SbDPRotation q)"""
        return _coin.SbDPViewVolume_rotateCamera(self, q)

    def translateCamera(self, v: "SbVec3d") -> "void":
        r"""translateCamera(SbDPViewVolume self, SbVec3d v)"""
        return _coin.SbDPViewVolume_translateCamera(self, v)

    def zVector(self) -> "SbVec3d":
        r"""zVector(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_zVector(self)

    def zNarrow(self, nearval: "double", farval: "double") -> "SbDPViewVolume":
        r"""zNarrow(SbDPViewVolume self, double nearval, double farval) -> SbDPViewVolume"""
        return _coin.SbDPViewVolume_zNarrow(self, nearval, farval)

    def scale(self, factor: "double") -> "void":
        r"""scale(SbDPViewVolume self, double factor)"""
        return _coin.SbDPViewVolume_scale(self, factor)

    def scaleWidth(self, ratio: "double") -> "void":
        r"""scaleWidth(SbDPViewVolume self, double ratio)"""
        return _coin.SbDPViewVolume_scaleWidth(self, ratio)

    def scaleHeight(self, ratio: "double") -> "void":
        r"""scaleHeight(SbDPViewVolume self, double ratio)"""
        return _coin.SbDPViewVolume_scaleHeight(self, ratio)

    def getProjectionType(self) -> "SbDPViewVolume::ProjectionType":
        r"""getProjectionType(SbDPViewVolume self) -> SbDPViewVolume::ProjectionType"""
        return _coin.SbDPViewVolume_getProjectionType(self)

    def getProjectionPoint(self) -> "SbVec3d const &":
        r"""getProjectionPoint(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionPoint(self)

    def getProjectionDirection(self) -> "SbVec3d const &":
        r"""getProjectionDirection(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionDirection(self)

    def getNearDist(self) -> "double":
        r"""getNearDist(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getNearDist(self)

    def getWidth(self) -> "double":
        r"""getWidth(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getWidth(self)

    def getHeight(self) -> "double":
        r"""getHeight(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getHeight(self)

    def getDepth(self) -> "double":
        r"""getDepth(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getDepth(self)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbDPViewVolume self, FILE * fp)"""
        return _coin.SbDPViewVolume_output(self, fp)

    def getViewVolumePlanes(self, planes: "SbPlane") -> "void":
        r"""getViewVolumePlanes(SbDPViewVolume self, SbPlane planes)"""
        return _coin.SbDPViewVolume_getViewVolumePlanes(self, planes)

    def transform(self, matrix: "SbDPMatrix") -> "void":
        r"""transform(SbDPViewVolume self, SbDPMatrix matrix)"""
        return _coin.SbDPViewVolume_transform(self, matrix)

    def getViewUp(self) -> "SbVec3d":
        r"""getViewUp(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getViewUp(self)

    def copyValues(self, vv: "SbViewVolume") -> "void":
        r"""copyValues(SbDPViewVolume self, SbViewVolume vv)"""
        return _coin.SbDPViewVolume_copyValues(self, vv)

# Register SbDPViewVolume in _coin:
_coin.SbDPViewVolume_swigregister(SbDPViewVolume)

class SbViewVolume(object):
    r"""Proxy of C++ SbViewVolume class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ORTHOGRAPHIC = _coin.SbViewVolume_ORTHOGRAPHIC
    
    PERSPECTIVE = _coin.SbViewVolume_PERSPECTIVE
    

    def __init__(self):
        r"""__init__(SbViewVolume self) -> SbViewVolume"""
        _coin.SbViewVolume_swiginit(self, _coin.new_SbViewVolume())
    __swig_destroy__ = _coin.delete_SbViewVolume

    def getMatrices(self, affine: "SbMatrix", proj: "SbMatrix") -> "void":
        r"""getMatrices(SbViewVolume self, SbMatrix affine, SbMatrix proj)"""
        return _coin.SbViewVolume_getMatrices(self, affine, proj)

    def getMatrix(self) -> "SbMatrix":
        r"""getMatrix(SbViewVolume self) -> SbMatrix"""
        return _coin.SbViewVolume_getMatrix(self)

    def getCameraSpaceMatrix(self) -> "SbMatrix":
        r"""getCameraSpaceMatrix(SbViewVolume self) -> SbMatrix"""
        return _coin.SbViewVolume_getCameraSpaceMatrix(self)

    def getPlane(self, distFromEye: "float const") -> "SbPlane":
        r"""getPlane(SbViewVolume self, float const distFromEye) -> SbPlane"""
        return _coin.SbViewVolume_getPlane(self, distFromEye)

    def getSightPoint(self, distFromEye: "float const") -> "SbVec3f":
        r"""getSightPoint(SbViewVolume self, float const distFromEye) -> SbVec3f"""
        return _coin.SbViewVolume_getSightPoint(self, distFromEye)

    def getPlanePoint(self, distFromEye: "float const", normPoint: "SbVec2f") -> "SbVec3f":
        r"""getPlanePoint(SbViewVolume self, float const distFromEye, SbVec2f normPoint) -> SbVec3f"""
        return _coin.SbViewVolume_getPlanePoint(self, distFromEye, normPoint)

    def getAlignRotation(self, rightAngleOnly: "SbBool"=0) -> "SbRotation":
        r"""getAlignRotation(SbViewVolume self, SbBool rightAngleOnly=0) -> SbRotation"""
        return _coin.SbViewVolume_getAlignRotation(self, rightAngleOnly)

    def getWorldToScreenScale(self, worldCenter: "SbVec3f", normRadius: "float") -> "float":
        r"""getWorldToScreenScale(SbViewVolume self, SbVec3f worldCenter, float normRadius) -> float"""
        return _coin.SbViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)

    def projectBox(self, box: "SbBox3f") -> "SbVec2f":
        r"""projectBox(SbViewVolume self, SbBox3f box) -> SbVec2f"""
        return _coin.SbViewVolume_projectBox(self, box)

    def narrow(self, *args) -> "SbViewVolume":
        r"""
        narrow(SbViewVolume self, float left, float bottom, float right, float top) -> SbViewVolume
        narrow(SbViewVolume self, SbBox3f box) -> SbViewVolume
        """
        return _coin.SbViewVolume_narrow(self, *args)

    def ortho(self, left: "float", right: "float", bottom: "float", top: "float", nearval: "float", farval: "float") -> "void":
        r"""ortho(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"""
        return _coin.SbViewVolume_ortho(self, left, right, bottom, top, nearval, farval)

    def perspective(self, fovy: "float", aspect: "float", nearval: "float", farval: "float") -> "void":
        r"""perspective(SbViewVolume self, float fovy, float aspect, float nearval, float farval)"""
        return _coin.SbViewVolume_perspective(self, fovy, aspect, nearval, farval)

    def frustum(self, left: "float", right: "float", bottom: "float", top: "float", nearval: "float", farval: "float") -> "void":
        r"""frustum(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"""
        return _coin.SbViewVolume_frustum(self, left, right, bottom, top, nearval, farval)

    def rotateCamera(self, q: "SbRotation") -> "void":
        r"""rotateCamera(SbViewVolume self, SbRotation q)"""
        return _coin.SbViewVolume_rotateCamera(self, q)

    def translateCamera(self, v: "SbVec3f") -> "void":
        r"""translateCamera(SbViewVolume self, SbVec3f v)"""
        return _coin.SbViewVolume_translateCamera(self, v)

    def zVector(self) -> "SbVec3f":
        r"""zVector(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_zVector(self)

    def zNarrow(self, nearval: "float", farval: "float") -> "SbViewVolume":
        r"""zNarrow(SbViewVolume self, float nearval, float farval) -> SbViewVolume"""
        return _coin.SbViewVolume_zNarrow(self, nearval, farval)

    def scale(self, factor: "float") -> "void":
        r"""scale(SbViewVolume self, float factor)"""
        return _coin.SbViewVolume_scale(self, factor)

    def scaleWidth(self, ratio: "float") -> "void":
        r"""scaleWidth(SbViewVolume self, float ratio)"""
        return _coin.SbViewVolume_scaleWidth(self, ratio)

    def scaleHeight(self, ratio: "float") -> "void":
        r"""scaleHeight(SbViewVolume self, float ratio)"""
        return _coin.SbViewVolume_scaleHeight(self, ratio)

    def getProjectionType(self) -> "SbViewVolume::ProjectionType":
        r"""getProjectionType(SbViewVolume self) -> SbViewVolume::ProjectionType"""
        return _coin.SbViewVolume_getProjectionType(self)

    def getProjectionPoint(self) -> "SbVec3f const &":
        r"""getProjectionPoint(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionPoint(self)

    def getProjectionDirection(self) -> "SbVec3f const &":
        r"""getProjectionDirection(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionDirection(self)

    def getNearDist(self) -> "float":
        r"""getNearDist(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getNearDist(self)

    def getWidth(self) -> "float":
        r"""getWidth(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getWidth(self)

    def getHeight(self) -> "float":
        r"""getHeight(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getHeight(self)

    def getDepth(self) -> "float":
        r"""getDepth(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getDepth(self)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbViewVolume self, FILE * fp)"""
        return _coin.SbViewVolume_output(self, fp)

    def getViewVolumePlanes(self, planes: "SbPlane") -> "void":
        r"""getViewVolumePlanes(SbViewVolume self, SbPlane planes)"""
        return _coin.SbViewVolume_getViewVolumePlanes(self, planes)

    def transform(self) -> "void":
        r"""transform(SbViewVolume self)"""
        return _coin.SbViewVolume_transform(self)

    def getViewUp(self) -> "SbVec3f":
        r"""getViewUp(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getViewUp(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbViewVolume self, SbVec3f p) -> SbBool
        intersect(SbViewVolume self, SbVec3f p0, SbVec3f p1, SbVec3f closestpoint) -> SbBool
        intersect(SbViewVolume self, SbBox3f box) -> SbBool
        """
        return _coin.SbViewVolume_intersect(self, *args)

    def intersectionBox(self, box: "SbBox3f") -> "SbBox3f":
        r"""intersectionBox(SbViewVolume self, SbBox3f box) -> SbBox3f"""
        return _coin.SbViewVolume_intersectionBox(self, box)

    def outsideTest(self, p: "SbPlane", bmin: "SbVec3f", bmax: "SbVec3f") -> "SbBool":
        r"""outsideTest(SbViewVolume self, SbPlane p, SbVec3f bmin, SbVec3f bmax) -> SbBool"""
        return _coin.SbViewVolume_outsideTest(self, p, bmin, bmax)

    def getDPViewVolume(self) -> "SbDPViewVolume const &":
        r"""getDPViewVolume(SbViewVolume self) -> SbDPViewVolume"""
        return _coin.SbViewVolume_getDPViewVolume(self)
    type = property(_coin.SbViewVolume_type_get, _coin.SbViewVolume_type_set, doc=r"""type : SbViewVolume::ProjectionType""")
    projPoint = property(_coin.SbViewVolume_projPoint_get, _coin.SbViewVolume_projPoint_set, doc=r"""projPoint : SbVec3f""")
    projDir = property(_coin.SbViewVolume_projDir_get, _coin.SbViewVolume_projDir_set, doc=r"""projDir : SbVec3f""")
    nearDist = property(_coin.SbViewVolume_nearDist_get, _coin.SbViewVolume_nearDist_set, doc=r"""nearDist : float""")
    nearToFar = property(_coin.SbViewVolume_nearToFar_get, _coin.SbViewVolume_nearToFar_set, doc=r"""nearToFar : float""")
    llf = property(_coin.SbViewVolume_llf_get, _coin.SbViewVolume_llf_set, doc=r"""llf : SbVec3f""")
    lrf = property(_coin.SbViewVolume_lrf_get, _coin.SbViewVolume_lrf_set, doc=r"""lrf : SbVec3f""")
    ulf = property(_coin.SbViewVolume_ulf_get, _coin.SbViewVolume_ulf_set, doc=r"""ulf : SbVec3f""")

    def projectPointToLine(self, pt: "SbVec2f") -> "PyObject *":
        r"""projectPointToLine(SbVec3f) -> (SbVec3f, SbVec3f)"""
        return _coin.SbViewVolume_projectPointToLine(self, pt)

    def projectToScreen(self, src: "SbVec3f") -> "PyObject *":
        r"""projectToScreen(SbVec3f) -> SbVec3f"""
        return _coin.SbViewVolume_projectToScreen(self, src)

# Register SbViewVolume in _coin:
_coin.SbViewVolume_swigregister(SbViewVolume)

class SoSFVec3f(SoSField):
    r"""Proxy of C++ SoSFVec3f class."""

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

    def __init__(self):
        r"""__init__(SoSFVec3f self) -> SoSFVec3f"""
        _coin.SoSFVec3f_swiginit(self, _coin.new_SoSFVec3f())
    __swig_destroy__ = _coin.delete_SoSFVec3f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec3f self) -> SoType"""
        return _coin.SoSFVec3f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec3f self, SoField field)"""
        return _coin.SoSFVec3f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec3f self, SoField field) -> SbBool"""
        return _coin.SoSFVec3f_isSame(self, field)

    def getValue(self) -> "SbVec3f const &":
        r"""getValue(SoSFVec3f self) -> SbVec3f"""
        return _coin.SoSFVec3f_getValue(self)

    def __eq__(self, field: "SoSFVec3f") -> "int":
        r"""__eq__(SoSFVec3f self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___eq__(self, field)

    def __ne__(self, field: "SoSFVec3f") -> "int":
        r"""__ne__(SoSFVec3f self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec3f_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec3f self, SbVec3f newvalue)
        setValue(SoSFVec3f self, float x, float y, float z)
        setValue(SoSFVec3f self, float const [3] xyz)
        setValue(SoSFVec3f self, SoSFVec3f other)
        """
        return _coin.SoSFVec3f_setValue(self, *args)

# Register SoSFVec3f in _coin:
_coin.SoSFVec3f_swigregister(SoSFVec3f)

def SoSFVec3f_createInstance() -> "void *":
    r"""SoSFVec3f_createInstance() -> void *"""
    return _coin.SoSFVec3f_createInstance()

def SoSFVec3f_getClassTypeId() -> "SoType":
    r"""SoSFVec3f_getClassTypeId() -> SoType"""
    return _coin.SoSFVec3f_getClassTypeId()

def SoSFVec3f_initClass() -> "void":
    r"""SoSFVec3f_initClass()"""
    return _coin.SoSFVec3f_initClass()

class SoScale(SoTransformation):
    r"""Proxy of C++ SoScale class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScale self) -> SoType"""
        return _coin.SoScale_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScale_initClass()

    def __init__(self):
        r"""__init__(SoScale self) -> SoScale"""
        _coin.SoScale_swiginit(self, _coin.new_SoScale())
    scaleFactor = property(_coin.SoScale_scaleFactor_get, _coin.SoScale_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoScale self, SoAction action)"""
        return _coin.SoScale_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoScale self, SoCallbackAction action)"""
        return _coin.SoScale_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoScale self, SoGLRenderAction action)"""
        return _coin.SoScale_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoScale self, SoGetBoundingBoxAction action)"""
        return _coin.SoScale_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoScale self, SoGetMatrixAction action)"""
        return _coin.SoScale_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoScale self, SoPickAction action)"""
        return _coin.SoScale_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoScale self, SoGetPrimitiveCountAction action)"""
        return _coin.SoScale_getPrimitiveCount(self, action)

# Register SoScale in _coin:
_coin.SoScale_swigregister(SoScale)

def SoScale_getClassTypeId() -> "SoType":
    r"""SoScale_getClassTypeId() -> SoType"""
    return _coin.SoScale_getClassTypeId()

def SoScale_initClass() -> "void":
    r"""SoScale_initClass()"""
    return _coin.SoScale_initClass()

class SoDragger(SoInteractionKit):
    r"""Proxy of C++ SoDragger class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDragger self) -> SoType"""
        return _coin.SoDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoDragger self) -> SoNodekitCatalog"""
        return _coin.SoDragger_getNodekitCatalog(self)
    isActive = property(_coin.SoDragger_isActive_get, _coin.SoDragger_isActive_set, doc=r"""isActive : SoSFBool""")
    FRONT = _coin.SoDragger_FRONT
    
    BACK = _coin.SoDragger_BACK
    
    USE_PICK = _coin.SoDragger_USE_PICK
    

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoDragger self, SoCallbackAction action)"""
        return _coin.SoDragger_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoDragger self, SoGLRenderAction action)"""
        return _coin.SoDragger_GLRender(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoDragger self, SoGetMatrixAction action)"""
        return _coin.SoDragger_getMatrix(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoDragger self, SoRayPickAction action)"""
        return _coin.SoDragger_rayPick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoDragger self, SoSearchAction action)"""
        return _coin.SoDragger_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoDragger self, SoWriteAction action)"""
        return _coin.SoDragger_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoDragger self, SoGetPrimitiveCountAction action)"""
        return _coin.SoDragger_getPrimitiveCount(self, action)

    def setProjectorEpsilon(self, epsilon: "float const") -> "void":
        r"""setProjectorEpsilon(SoDragger self, float const epsilon)"""
        return _coin.SoDragger_setProjectorEpsilon(self, epsilon)

    def getProjectorEpsilon(self) -> "float":
        r"""getProjectorEpsilon(SoDragger self) -> float"""
        return _coin.SoDragger_getProjectorEpsilon(self)

    def setMinGesture(self, pixels: "int") -> "void":
        r"""setMinGesture(SoDragger self, int pixels)"""
        return _coin.SoDragger_setMinGesture(self, pixels)

    def getMinGesture(self) -> "int":
        r"""getMinGesture(SoDragger self) -> int"""
        return _coin.SoDragger_getMinGesture(self)

    def enableValueChangedCallbacks(self, newval: "SbBool") -> "SbBool":
        r"""enableValueChangedCallbacks(SoDragger self, SbBool newval) -> SbBool"""
        return _coin.SoDragger_enableValueChangedCallbacks(self, newval)

    def getMotionMatrix(self) -> "SbMatrix const &":
        r"""getMotionMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getMotionMatrix(self)

    def registerChildDragger(self, child: "SoDragger") -> "void":
        r"""registerChildDragger(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_registerChildDragger(self, child)

    def unregisterChildDragger(self, child: "SoDragger") -> "void":
        r"""unregisterChildDragger(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDragger(self, child)

    def registerChildDraggerMovingIndependently(self, child: "SoDragger") -> "void":
        r"""registerChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_registerChildDraggerMovingIndependently(self, child)

    def unregisterChildDraggerMovingIndependently(self, child: "SoDragger") -> "void":
        r"""unregisterChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDraggerMovingIndependently(self, child)

    def getLocalToWorldMatrix(self) -> "SbMatrix":
        r"""getLocalToWorldMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getLocalToWorldMatrix(self)

    def getWorldToLocalMatrix(self) -> "SbMatrix":
        r"""getWorldToLocalMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getWorldToLocalMatrix(self)

    def getLocalStartingPoint(self) -> "SbVec3f":
        r"""getLocalStartingPoint(SoDragger self) -> SbVec3f"""
        return _coin.SoDragger_getLocalStartingPoint(self)

    def getWorldStartingPoint(self) -> "SbVec3f":
        r"""getWorldStartingPoint(SoDragger self) -> SbVec3f"""
        return _coin.SoDragger_getWorldStartingPoint(self)

    def getPartToLocalMatrix(self, partname: "SbName", parttolocalmatrix: "SbMatrix", localtopartmatrix: "SbMatrix") -> "void":
        r"""getPartToLocalMatrix(SoDragger self, SbName partname, SbMatrix parttolocalmatrix, SbMatrix localtopartmatrix)"""
        return _coin.SoDragger_getPartToLocalMatrix(self, partname, parttolocalmatrix, localtopartmatrix)

    def transformMatrixLocalToWorld(self, frommatrix: "SbMatrix", tomatrix: "SbMatrix") -> "void":
        r"""transformMatrixLocalToWorld(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixLocalToWorld(self, frommatrix, tomatrix)

    def transformMatrixWorldToLocal(self, frommatrix: "SbMatrix", tomatrix: "SbMatrix") -> "void":
        r"""transformMatrixWorldToLocal(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixWorldToLocal(self, frommatrix, tomatrix)

    def transformMatrixToLocalSpace(self, frommatrix: "SbMatrix", tomatrix: "SbMatrix", fromspacepartname: "SbName") -> "void":
        r"""transformMatrixToLocalSpace(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix, SbName fromspacepartname)"""
        return _coin.SoDragger_transformMatrixToLocalSpace(self, frommatrix, tomatrix, fromspacepartname)

    def setMotionMatrix(self, newmatrix: "SbMatrix") -> "void":
        r"""setMotionMatrix(SoDragger self, SbMatrix newmatrix)"""
        return _coin.SoDragger_setMotionMatrix(self, newmatrix)

    def valueChanged(self) -> "void":
        r"""valueChanged(SoDragger self)"""
        return _coin.SoDragger_valueChanged(self)

    def getStartMotionMatrix(self) -> "SbMatrix const &":
        r"""getStartMotionMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getStartMotionMatrix(self)

    def saveStartParameters(self) -> "void":
        r"""saveStartParameters(SoDragger self)"""
        return _coin.SoDragger_saveStartParameters(self)

    def getPickPath(self) -> "SoPath const *":
        r"""getPickPath(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getPickPath(self)

    def getEvent(self) -> "SoEvent const *":
        r"""getEvent(SoDragger self) -> SoEvent"""
        return _coin.SoDragger_getEvent(self)

    def createPathToThis(self) -> "SoPath *":
        r"""createPathToThis(SoDragger self) -> SoPath"""
        return _coin.SoDragger_createPathToThis(self)

    def getSurrogatePartPickedOwner(self) -> "SoPath const *":
        r"""getSurrogatePartPickedOwner(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedOwner(self)

    def getSurrogatePartPickedName(self) -> "SbName const &":
        r"""getSurrogatePartPickedName(SoDragger self) -> SbName"""
        return _coin.SoDragger_getSurrogatePartPickedName(self)

    def getSurrogatePartPickedPath(self) -> "SoPath const *":
        r"""getSurrogatePartPickedPath(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedPath(self)

    def setStartingPoint(self, *args) -> "void":
        r"""
        setStartingPoint(SoDragger self, SoPickedPoint newpoint)
        setStartingPoint(SoDragger self, SbVec3f newpoint)
        """
        return _coin.SoDragger_setStartingPoint(self, *args)

    def getViewVolume(self) -> "SbViewVolume const &":
        r"""getViewVolume(SoDragger self) -> SbViewVolume"""
        return _coin.SoDragger_getViewVolume(self)

    def setViewVolume(self, vol: "SbViewVolume") -> "void":
        r"""setViewVolume(SoDragger self, SbViewVolume vol)"""
        return _coin.SoDragger_setViewVolume(self, vol)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoDragger self) -> SbViewportRegion"""
        return _coin.SoDragger_getViewportRegion(self)

    def setViewportRegion(self, reg: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoDragger self, SbViewportRegion reg)"""
        return _coin.SoDragger_setViewportRegion(self, reg)

    def getHandleEventAction(self) -> "SoHandleEventAction *":
        r"""getHandleEventAction(SoDragger self) -> SoHandleEventAction"""
        return _coin.SoDragger_getHandleEventAction(self)

    def setHandleEventAction(self, newAction: "SoHandleEventAction") -> "void":
        r"""setHandleEventAction(SoDragger self, SoHandleEventAction newAction)"""
        return _coin.SoDragger_setHandleEventAction(self, newAction)

    def setTempPathToThis(self, somethingclose: "SoPath") -> "void":
        r"""setTempPathToThis(SoDragger self, SoPath somethingclose)"""
        return _coin.SoDragger_setTempPathToThis(self, somethingclose)

    def grabEventsSetup(self) -> "void":
        r"""grabEventsSetup(SoDragger self)"""
        return _coin.SoDragger_grabEventsSetup(self)

    def grabEventsCleanup(self) -> "void":
        r"""grabEventsCleanup(SoDragger self)"""
        return _coin.SoDragger_grabEventsCleanup(self)

    def workFieldsIntoTransform(self, mtx: "SbMatrix") -> "void":
        r"""workFieldsIntoTransform(SoDragger self, SbMatrix mtx)"""
        return _coin.SoDragger_workFieldsIntoTransform(self, mtx)

    def setFrontOnProjector(self, newval: "SoDragger::ProjectorFrontSetting") -> "void":
        r"""setFrontOnProjector(SoDragger self, SoDragger::ProjectorFrontSetting newval)"""
        return _coin.SoDragger_setFrontOnProjector(self, newval)

    def getFrontOnProjector(self) -> "SoDragger::ProjectorFrontSetting":
        r"""getFrontOnProjector(SoDragger self) -> SoDragger::ProjectorFrontSetting"""
        return _coin.SoDragger_getFrontOnProjector(self)

    @staticmethod
    def setMinScale(newminscale: "float") -> "void":
        r"""setMinScale(float newminscale)"""
        return _coin.SoDragger_setMinScale(newminscale)

    @staticmethod
    def getMinScale() -> "float":
        r"""getMinScale() -> float"""
        return _coin.SoDragger_getMinScale()

    @staticmethod
    def workValuesIntoTransform(mtx: "SbMatrix", translationptr: "SbVec3f", rotationptr: "SbRotation", scalefactorptr: "SbVec3f", scaleorientationptr: "SbRotation", centerptr: "SbVec3f") -> "void":
        r"""workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"""
        return _coin.SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr)

    @staticmethod
    def getTransformFast(*args) -> "void":
        r"""
        getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation, SbVec3f center)
        getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation)
        """
        return _coin.SoDragger_getTransformFast(*args)

    @staticmethod
    def appendTranslation(mtx: "SbMatrix", translation: "SbVec3f", conversion: "SbMatrix"=None) -> "SbMatrix":
        r"""appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix"""
        return _coin.SoDragger_appendTranslation(mtx, translation, conversion)

    @staticmethod
    def appendScale(mtx: "SbMatrix", scale: "SbVec3f", scalecenter: "SbVec3f", conversion: "SbMatrix"=None) -> "SbMatrix":
        r"""appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix"""
        return _coin.SoDragger_appendScale(mtx, scale, scalecenter, conversion)

    @staticmethod
    def appendRotation(mtx: "SbMatrix", rot: "SbRotation", rotcenter: "SbVec3f", conversion: "SbMatrix"=None) -> "SbMatrix":
        r"""appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix"""
        return _coin.SoDragger_appendRotation(mtx, rot, rotcenter, conversion)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDragger_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoDragger_initClasses()

    def addStartCallback(self, *args) -> "void":
        r"""
        addStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addStartCallback(self, *args)

    def removeStartCallback(self, *args) -> "void":
        r"""
        removeStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeStartCallback(self, *args)

    def addMotionCallback(self, *args) -> "void":
        r"""
        addMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addMotionCallback(self, *args)

    def removeMotionCallback(self, *args) -> "void":
        r"""
        removeMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeMotionCallback(self, *args)

    def addFinishCallback(self, *args) -> "void":
        r"""
        addFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addFinishCallback(self, *args)

    def removeFinishCallback(self, *args) -> "void":
        r"""
        removeFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeFinishCallback(self, *args)

    def addValueChangedCallback(self, *args) -> "void":
        r"""
        addValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addValueChangedCallback(self, *args)

    def removeValueChangedCallback(self, *args) -> "void":
        r"""
        removeValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeValueChangedCallback(self, *args)

    def addOtherEventCallback(self, *args) -> "void":
        r"""
        addOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addOtherEventCallback(self, *args)

    def removeOtherEventCallback(self, *args) -> "void":
        r"""
        removeOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeOtherEventCallback(self, *args)

# Register SoDragger in _coin:
_coin.SoDragger_swigregister(SoDragger)

def SoDragger_getClassTypeId() -> "SoType":
    r"""SoDragger_getClassTypeId() -> SoType"""
    return _coin.SoDragger_getClassTypeId()

def SoDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoDragger_getClassNodekitCatalog()

def SoDragger_setMinScale(newminscale: "float") -> "void":
    r"""SoDragger_setMinScale(float newminscale)"""
    return _coin.SoDragger_setMinScale(newminscale)

def SoDragger_getMinScale() -> "float":
    r"""SoDragger_getMinScale() -> float"""
    return _coin.SoDragger_getMinScale()

def SoDragger_workValuesIntoTransform(mtx: "SbMatrix", translationptr: "SbVec3f", rotationptr: "SbRotation", scalefactorptr: "SbVec3f", scaleorientationptr: "SbRotation", centerptr: "SbVec3f") -> "void":
    r"""SoDragger_workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"""
    return _coin.SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr)

def SoDragger_getTransformFast(*args) -> "void":
    r"""
    SoDragger_getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation, SbVec3f center)
    SoDragger_getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation)
    """
    return _coin.SoDragger_getTransformFast(*args)

def SoDragger_appendTranslation(mtx: "SbMatrix", translation: "SbVec3f", conversion: "SbMatrix"=None) -> "SbMatrix":
    r"""SoDragger_appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix"""
    return _coin.SoDragger_appendTranslation(mtx, translation, conversion)

def SoDragger_appendScale(mtx: "SbMatrix", scale: "SbVec3f", scalecenter: "SbVec3f", conversion: "SbMatrix"=None) -> "SbMatrix":
    r"""SoDragger_appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix"""
    return _coin.SoDragger_appendScale(mtx, scale, scalecenter, conversion)

def SoDragger_appendRotation(mtx: "SbMatrix", rot: "SbRotation", rotcenter: "SbVec3f", conversion: "SbMatrix"=None) -> "SbMatrix":
    r"""SoDragger_appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix"""
    return _coin.SoDragger_appendRotation(mtx, rot, rotcenter, conversion)

def SoDragger_initClass() -> "void":
    r"""SoDragger_initClass()"""
    return _coin.SoDragger_initClass()

def SoDragger_initClasses() -> "void":
    r"""SoDragger_initClasses()"""
    return _coin.SoDragger_initClasses()

class SoSFRotation(SoSField):
    r"""Proxy of C++ SoSFRotation class."""

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

    def __init__(self):
        r"""__init__(SoSFRotation self) -> SoSFRotation"""
        _coin.SoSFRotation_swiginit(self, _coin.new_SoSFRotation())
    __swig_destroy__ = _coin.delete_SoSFRotation

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFRotation_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFRotation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFRotation self) -> SoType"""
        return _coin.SoSFRotation_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFRotation self, SoField field)"""
        return _coin.SoSFRotation_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFRotation self, SoField field) -> SbBool"""
        return _coin.SoSFRotation_isSame(self, field)

    def __eq__(self, field: "SoSFRotation") -> "int":
        r"""__eq__(SoSFRotation self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___eq__(self, field)

    def __ne__(self, field: "SoSFRotation") -> "int":
        r"""__ne__(SoSFRotation self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFRotation_initClass()

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFRotation self) -> SbRotation
        getValue(SoSFRotation self, float & angle)
        """
        return _coin.SoSFRotation_getValue(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFRotation self, SbRotation newvalue)
        setValue(SoSFRotation self, float const q0, float const q1, float const q2, float const q3)
        setValue(SoSFRotation self, float const [4] q)
        setValue(SoSFRotation self, SbVec3f axis, float const angle)
        setValue(SoSFRotation self, SoSFRotation other)
        """
        return _coin.SoSFRotation_setValue(self, *args)

# Register SoSFRotation in _coin:
_coin.SoSFRotation_swigregister(SoSFRotation)

def SoSFRotation_createInstance() -> "void *":
    r"""SoSFRotation_createInstance() -> void *"""
    return _coin.SoSFRotation_createInstance()

def SoSFRotation_getClassTypeId() -> "SoType":
    r"""SoSFRotation_getClassTypeId() -> SoType"""
    return _coin.SoSFRotation_getClassTypeId()

def SoSFRotation_initClass() -> "void":
    r"""SoSFRotation_initClass()"""
    return _coin.SoSFRotation_initClass()

class SoCenterballDragger(SoDragger):
    r"""Proxy of C++ SoCenterballDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCenterballDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCenterballDragger self) -> SoType"""
        return _coin.SoCenterballDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoCenterballDragger self) -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCenterballDragger_initClass()

    def __init__(self):
        r"""__init__(SoCenterballDragger self) -> SoCenterballDragger"""
        _coin.SoCenterballDragger_swiginit(self, _coin.new_SoCenterballDragger())

    def saveStartParameters(self) -> "void":
        r"""saveStartParameters(SoCenterballDragger self)"""
        return _coin.SoCenterballDragger_saveStartParameters(self)
    rotation = property(_coin.SoCenterballDragger_rotation_get, _coin.SoCenterballDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    center = property(_coin.SoCenterballDragger_center_get, _coin.SoCenterballDragger_center_set, doc=r"""center : SoSFVec3f""")

# Register SoCenterballDragger in _coin:
_coin.SoCenterballDragger_swigregister(SoCenterballDragger)

def SoCenterballDragger_getClassTypeId() -> "SoType":
    r"""SoCenterballDragger_getClassTypeId() -> SoType"""
    return _coin.SoCenterballDragger_getClassTypeId()

def SoCenterballDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoCenterballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoCenterballDragger_getClassNodekitCatalog()

def SoCenterballDragger_initClass() -> "void":
    r"""SoCenterballDragger_initClass()"""
    return _coin.SoCenterballDragger_initClass()

class SoDirectionalLightDragger(SoDragger):
    r"""Proxy of C++ SoDirectionalLightDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLightDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDirectionalLightDragger self) -> SoType"""
        return _coin.SoDirectionalLightDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoDirectionalLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDirectionalLightDragger_initClass()

    def __init__(self):
        r"""__init__(SoDirectionalLightDragger self) -> SoDirectionalLightDragger"""
        _coin.SoDirectionalLightDragger_swiginit(self, _coin.new_SoDirectionalLightDragger())
    rotation = property(_coin.SoDirectionalLightDragger_rotation_get, _coin.SoDirectionalLightDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoDirectionalLightDragger_translation_get, _coin.SoDirectionalLightDragger_translation_set, doc=r"""translation : SoSFVec3f""")

# Register SoDirectionalLightDragger in _coin:
_coin.SoDirectionalLightDragger_swigregister(SoDirectionalLightDragger)

def SoDirectionalLightDragger_getClassTypeId() -> "SoType":
    r"""SoDirectionalLightDragger_getClassTypeId() -> SoType"""
    return _coin.SoDirectionalLightDragger_getClassTypeId()

def SoDirectionalLightDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoDirectionalLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()

def SoDirectionalLightDragger_initClass() -> "void":
    r"""SoDirectionalLightDragger_initClass()"""
    return _coin.SoDirectionalLightDragger_initClass()

class SoDragPointDragger(SoDragger):
    r"""Proxy of C++ SoDragPointDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDragPointDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDragPointDragger self) -> SoType"""
        return _coin.SoDragPointDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoDragPointDragger self) -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDragPointDragger_initClass()

    def __init__(self):
        r"""__init__(SoDragPointDragger self) -> SoDragPointDragger"""
        _coin.SoDragPointDragger_swiginit(self, _coin.new_SoDragPointDragger())
    translation = property(_coin.SoDragPointDragger_translation_get, _coin.SoDragPointDragger_translation_set, doc=r"""translation : SoSFVec3f""")

    def setJumpLimit(self, limit: "float const") -> "void":
        r"""setJumpLimit(SoDragPointDragger self, float const limit)"""
        return _coin.SoDragPointDragger_setJumpLimit(self, limit)

    def getJumpLimit(self) -> "float":
        r"""getJumpLimit(SoDragPointDragger self) -> float"""
        return _coin.SoDragPointDragger_getJumpLimit(self)

    def showNextDraggerSet(self) -> "void":
        r"""showNextDraggerSet(SoDragPointDragger self)"""
        return _coin.SoDragPointDragger_showNextDraggerSet(self)

# Register SoDragPointDragger in _coin:
_coin.SoDragPointDragger_swigregister(SoDragPointDragger)

def SoDragPointDragger_getClassTypeId() -> "SoType":
    r"""SoDragPointDragger_getClassTypeId() -> SoType"""
    return _coin.SoDragPointDragger_getClassTypeId()

def SoDragPointDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoDragPointDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoDragPointDragger_getClassNodekitCatalog()

def SoDragPointDragger_initClass() -> "void":
    r"""SoDragPointDragger_initClass()"""
    return _coin.SoDragPointDragger_initClass()

class SoHandleBoxDragger(SoDragger):
    r"""Proxy of C++ SoHandleBoxDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHandleBoxDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoHandleBoxDragger self) -> SoType"""
        return _coin.SoHandleBoxDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoHandleBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoHandleBoxDragger_initClass()

    def __init__(self):
        r"""__init__(SoHandleBoxDragger self) -> SoHandleBoxDragger"""
        _coin.SoHandleBoxDragger_swiginit(self, _coin.new_SoHandleBoxDragger())
    scaleFactor = property(_coin.SoHandleBoxDragger_scaleFactor_get, _coin.SoHandleBoxDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    translation = property(_coin.SoHandleBoxDragger_translation_get, _coin.SoHandleBoxDragger_translation_set, doc=r"""translation : SoSFVec3f""")

# Register SoHandleBoxDragger in _coin:
_coin.SoHandleBoxDragger_swigregister(SoHandleBoxDragger)

def SoHandleBoxDragger_getClassTypeId() -> "SoType":
    r"""SoHandleBoxDragger_getClassTypeId() -> SoType"""
    return _coin.SoHandleBoxDragger_getClassTypeId()

def SoHandleBoxDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoHandleBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoHandleBoxDragger_getClassNodekitCatalog()

def SoHandleBoxDragger_initClass() -> "void":
    r"""SoHandleBoxDragger_initClass()"""
    return _coin.SoHandleBoxDragger_initClass()

class SoJackDragger(SoDragger):
    r"""Proxy of C++ SoJackDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoJackDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoJackDragger self) -> SoType"""
        return _coin.SoJackDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoJackDragger self) -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoJackDragger_initClass()

    def __init__(self):
        r"""__init__(SoJackDragger self) -> SoJackDragger"""
        _coin.SoJackDragger_swiginit(self, _coin.new_SoJackDragger())
    rotation = property(_coin.SoJackDragger_rotation_get, _coin.SoJackDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoJackDragger_translation_get, _coin.SoJackDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoJackDragger_scaleFactor_get, _coin.SoJackDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoJackDragger in _coin:
_coin.SoJackDragger_swigregister(SoJackDragger)

def SoJackDragger_getClassTypeId() -> "SoType":
    r"""SoJackDragger_getClassTypeId() -> SoType"""
    return _coin.SoJackDragger_getClassTypeId()

def SoJackDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoJackDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoJackDragger_getClassNodekitCatalog()

def SoJackDragger_initClass() -> "void":
    r"""SoJackDragger_initClass()"""
    return _coin.SoJackDragger_initClass()

class SoPointLightDragger(SoDragger):
    r"""Proxy of C++ SoPointLightDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointLightDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPointLightDragger self) -> SoType"""
        return _coin.SoPointLightDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoPointLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPointLightDragger_initClass()

    def __init__(self):
        r"""__init__(SoPointLightDragger self) -> SoPointLightDragger"""
        _coin.SoPointLightDragger_swiginit(self, _coin.new_SoPointLightDragger())
    translation = property(_coin.SoPointLightDragger_translation_get, _coin.SoPointLightDragger_translation_set, doc=r"""translation : SoSFVec3f""")

# Register SoPointLightDragger in _coin:
_coin.SoPointLightDragger_swigregister(SoPointLightDragger)

def SoPointLightDragger_getClassTypeId() -> "SoType":
    r"""SoPointLightDragger_getClassTypeId() -> SoType"""
    return _coin.SoPointLightDragger_getClassTypeId()

def SoPointLightDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoPointLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoPointLightDragger_getClassNodekitCatalog()

def SoPointLightDragger_initClass() -> "void":
    r"""SoPointLightDragger_initClass()"""
    return _coin.SoPointLightDragger_initClass()

class SoRotateCylindricalDragger(SoDragger):
    r"""Proxy of C++ SoRotateCylindricalDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotateCylindricalDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoRotateCylindricalDragger self) -> SoType"""
        return _coin.SoRotateCylindricalDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoRotateCylindricalDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoRotateCylindricalDragger_initClass()

    def __init__(self):
        r"""__init__(SoRotateCylindricalDragger self) -> SoRotateCylindricalDragger"""
        _coin.SoRotateCylindricalDragger_swiginit(self, _coin.new_SoRotateCylindricalDragger())
    rotation = property(_coin.SoRotateCylindricalDragger_rotation_get, _coin.SoRotateCylindricalDragger_rotation_set, doc=r"""rotation : SoSFRotation""")

    def setProjector(self, p: "SbCylinderProjector") -> "void":
        r"""setProjector(SoRotateCylindricalDragger self, SbCylinderProjector p)"""
        return _coin.SoRotateCylindricalDragger_setProjector(self, p)

    def getProjector(self) -> "SbCylinderProjector const *":
        r"""getProjector(SoRotateCylindricalDragger self) -> SbCylinderProjector"""
        return _coin.SoRotateCylindricalDragger_getProjector(self)

# Register SoRotateCylindricalDragger in _coin:
_coin.SoRotateCylindricalDragger_swigregister(SoRotateCylindricalDragger)

def SoRotateCylindricalDragger_getClassTypeId() -> "SoType":
    r"""SoRotateCylindricalDragger_getClassTypeId() -> SoType"""
    return _coin.SoRotateCylindricalDragger_getClassTypeId()

def SoRotateCylindricalDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoRotateCylindricalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()

def SoRotateCylindricalDragger_initClass() -> "void":
    r"""SoRotateCylindricalDragger_initClass()"""
    return _coin.SoRotateCylindricalDragger_initClass()

class SoRotateDiscDragger(SoDragger):
    r"""Proxy of C++ SoRotateDiscDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotateDiscDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoRotateDiscDragger self) -> SoType"""
        return _coin.SoRotateDiscDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoRotateDiscDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoRotateDiscDragger_initClass()

    def __init__(self):
        r"""__init__(SoRotateDiscDragger self) -> SoRotateDiscDragger"""
        _coin.SoRotateDiscDragger_swiginit(self, _coin.new_SoRotateDiscDragger())
    rotation = property(_coin.SoRotateDiscDragger_rotation_get, _coin.SoRotateDiscDragger_rotation_set, doc=r"""rotation : SoSFRotation""")

# Register SoRotateDiscDragger in _coin:
_coin.SoRotateDiscDragger_swigregister(SoRotateDiscDragger)

def SoRotateDiscDragger_getClassTypeId() -> "SoType":
    r"""SoRotateDiscDragger_getClassTypeId() -> SoType"""
    return _coin.SoRotateDiscDragger_getClassTypeId()

def SoRotateDiscDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoRotateDiscDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoRotateDiscDragger_getClassNodekitCatalog()

def SoRotateDiscDragger_initClass() -> "void":
    r"""SoRotateDiscDragger_initClass()"""
    return _coin.SoRotateDiscDragger_initClass()

class SoRotateSphericalDragger(SoDragger):
    r"""Proxy of C++ SoRotateSphericalDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotateSphericalDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoRotateSphericalDragger self) -> SoType"""
        return _coin.SoRotateSphericalDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoRotateSphericalDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoRotateSphericalDragger_initClass()

    def __init__(self):
        r"""__init__(SoRotateSphericalDragger self) -> SoRotateSphericalDragger"""
        _coin.SoRotateSphericalDragger_swiginit(self, _coin.new_SoRotateSphericalDragger())
    rotation = property(_coin.SoRotateSphericalDragger_rotation_get, _coin.SoRotateSphericalDragger_rotation_set, doc=r"""rotation : SoSFRotation""")

    def setProjector(self, p: "SbSphereProjector") -> "void":
        r"""setProjector(SoRotateSphericalDragger self, SbSphereProjector p)"""
        return _coin.SoRotateSphericalDragger_setProjector(self, p)

    def getProjector(self) -> "SbSphereProjector const *":
        r"""getProjector(SoRotateSphericalDragger self) -> SbSphereProjector"""
        return _coin.SoRotateSphericalDragger_getProjector(self)

# Register SoRotateSphericalDragger in _coin:
_coin.SoRotateSphericalDragger_swigregister(SoRotateSphericalDragger)

def SoRotateSphericalDragger_getClassTypeId() -> "SoType":
    r"""SoRotateSphericalDragger_getClassTypeId() -> SoType"""
    return _coin.SoRotateSphericalDragger_getClassTypeId()

def SoRotateSphericalDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoRotateSphericalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()

def SoRotateSphericalDragger_initClass() -> "void":
    r"""SoRotateSphericalDragger_initClass()"""
    return _coin.SoRotateSphericalDragger_initClass()

class SoScale1Dragger(SoDragger):
    r"""Proxy of C++ SoScale1Dragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale1Dragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScale1Dragger self) -> SoType"""
        return _coin.SoScale1Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoScale1Dragger self) -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScale1Dragger_initClass()

    def __init__(self):
        r"""__init__(SoScale1Dragger self) -> SoScale1Dragger"""
        _coin.SoScale1Dragger_swiginit(self, _coin.new_SoScale1Dragger())
    scaleFactor = property(_coin.SoScale1Dragger_scaleFactor_get, _coin.SoScale1Dragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScale1Dragger in _coin:
_coin.SoScale1Dragger_swigregister(SoScale1Dragger)

def SoScale1Dragger_getClassTypeId() -> "SoType":
    r"""SoScale1Dragger_getClassTypeId() -> SoType"""
    return _coin.SoScale1Dragger_getClassTypeId()

def SoScale1Dragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoScale1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoScale1Dragger_getClassNodekitCatalog()

def SoScale1Dragger_initClass() -> "void":
    r"""SoScale1Dragger_initClass()"""
    return _coin.SoScale1Dragger_initClass()

class SoScale2Dragger(SoDragger):
    r"""Proxy of C++ SoScale2Dragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale2Dragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScale2Dragger self) -> SoType"""
        return _coin.SoScale2Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoScale2Dragger self) -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScale2Dragger_initClass()

    def __init__(self):
        r"""__init__(SoScale2Dragger self) -> SoScale2Dragger"""
        _coin.SoScale2Dragger_swiginit(self, _coin.new_SoScale2Dragger())
    scaleFactor = property(_coin.SoScale2Dragger_scaleFactor_get, _coin.SoScale2Dragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScale2Dragger in _coin:
_coin.SoScale2Dragger_swigregister(SoScale2Dragger)

def SoScale2Dragger_getClassTypeId() -> "SoType":
    r"""SoScale2Dragger_getClassTypeId() -> SoType"""
    return _coin.SoScale2Dragger_getClassTypeId()

def SoScale2Dragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoScale2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoScale2Dragger_getClassNodekitCatalog()

def SoScale2Dragger_initClass() -> "void":
    r"""SoScale2Dragger_initClass()"""
    return _coin.SoScale2Dragger_initClass()

class SoScale2UniformDragger(SoDragger):
    r"""Proxy of C++ SoScale2UniformDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale2UniformDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScale2UniformDragger self) -> SoType"""
        return _coin.SoScale2UniformDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoScale2UniformDragger self) -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScale2UniformDragger_initClass()

    def __init__(self):
        r"""__init__(SoScale2UniformDragger self) -> SoScale2UniformDragger"""
        _coin.SoScale2UniformDragger_swiginit(self, _coin.new_SoScale2UniformDragger())
    scaleFactor = property(_coin.SoScale2UniformDragger_scaleFactor_get, _coin.SoScale2UniformDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScale2UniformDragger in _coin:
_coin.SoScale2UniformDragger_swigregister(SoScale2UniformDragger)

def SoScale2UniformDragger_getClassTypeId() -> "SoType":
    r"""SoScale2UniformDragger_getClassTypeId() -> SoType"""
    return _coin.SoScale2UniformDragger_getClassTypeId()

def SoScale2UniformDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoScale2UniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoScale2UniformDragger_getClassNodekitCatalog()

def SoScale2UniformDragger_initClass() -> "void":
    r"""SoScale2UniformDragger_initClass()"""
    return _coin.SoScale2UniformDragger_initClass()

class SoScaleUniformDragger(SoDragger):
    r"""Proxy of C++ SoScaleUniformDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScaleUniformDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScaleUniformDragger self) -> SoType"""
        return _coin.SoScaleUniformDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoScaleUniformDragger self) -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScaleUniformDragger_initClass()

    def __init__(self):
        r"""__init__(SoScaleUniformDragger self) -> SoScaleUniformDragger"""
        _coin.SoScaleUniformDragger_swiginit(self, _coin.new_SoScaleUniformDragger())
    scaleFactor = property(_coin.SoScaleUniformDragger_scaleFactor_get, _coin.SoScaleUniformDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScaleUniformDragger in _coin:
_coin.SoScaleUniformDragger_swigregister(SoScaleUniformDragger)

def SoScaleUniformDragger_getClassTypeId() -> "SoType":
    r"""SoScaleUniformDragger_getClassTypeId() -> SoType"""
    return _coin.SoScaleUniformDragger_getClassTypeId()

def SoScaleUniformDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoScaleUniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoScaleUniformDragger_getClassNodekitCatalog()

def SoScaleUniformDragger_initClass() -> "void":
    r"""SoScaleUniformDragger_initClass()"""
    return _coin.SoScaleUniformDragger_initClass()

class SoSpotLightDragger(SoDragger):
    r"""Proxy of C++ SoSpotLightDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpotLightDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSpotLightDragger self) -> SoType"""
        return _coin.SoSpotLightDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoSpotLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSpotLightDragger_initClass()

    def __init__(self):
        r"""__init__(SoSpotLightDragger self) -> SoSpotLightDragger"""
        _coin.SoSpotLightDragger_swiginit(self, _coin.new_SoSpotLightDragger())
    rotation = property(_coin.SoSpotLightDragger_rotation_get, _coin.SoSpotLightDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoSpotLightDragger_translation_get, _coin.SoSpotLightDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    angle = property(_coin.SoSpotLightDragger_angle_get, _coin.SoSpotLightDragger_angle_set, doc=r"""angle : SoSFFloat""")

# Register SoSpotLightDragger in _coin:
_coin.SoSpotLightDragger_swigregister(SoSpotLightDragger)

def SoSpotLightDragger_getClassTypeId() -> "SoType":
    r"""SoSpotLightDragger_getClassTypeId() -> SoType"""
    return _coin.SoSpotLightDragger_getClassTypeId()

def SoSpotLightDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoSpotLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoSpotLightDragger_getClassNodekitCatalog()

def SoSpotLightDragger_initClass() -> "void":
    r"""SoSpotLightDragger_initClass()"""
    return _coin.SoSpotLightDragger_initClass()

class SoTabBoxDragger(SoDragger):
    r"""Proxy of C++ SoTabBoxDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTabBoxDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTabBoxDragger self) -> SoType"""
        return _coin.SoTabBoxDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoTabBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTabBoxDragger_initClass()

    def __init__(self):
        r"""__init__(SoTabBoxDragger self) -> SoTabBoxDragger"""
        _coin.SoTabBoxDragger_swiginit(self, _coin.new_SoTabBoxDragger())
    translation = property(_coin.SoTabBoxDragger_translation_get, _coin.SoTabBoxDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTabBoxDragger_scaleFactor_get, _coin.SoTabBoxDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def adjustScaleTabSize(self) -> "void":
        r"""adjustScaleTabSize(SoTabBoxDragger self)"""
        return _coin.SoTabBoxDragger_adjustScaleTabSize(self)

# Register SoTabBoxDragger in _coin:
_coin.SoTabBoxDragger_swigregister(SoTabBoxDragger)

def SoTabBoxDragger_getClassTypeId() -> "SoType":
    r"""SoTabBoxDragger_getClassTypeId() -> SoType"""
    return _coin.SoTabBoxDragger_getClassTypeId()

def SoTabBoxDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoTabBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoTabBoxDragger_getClassNodekitCatalog()

def SoTabBoxDragger_initClass() -> "void":
    r"""SoTabBoxDragger_initClass()"""
    return _coin.SoTabBoxDragger_initClass()

class SoTabPlaneDragger(SoDragger):
    r"""Proxy of C++ SoTabPlaneDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTabPlaneDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTabPlaneDragger self) -> SoType"""
        return _coin.SoTabPlaneDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoTabPlaneDragger self) -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTabPlaneDragger_initClass()

    def __init__(self):
        r"""__init__(SoTabPlaneDragger self) -> SoTabPlaneDragger"""
        _coin.SoTabPlaneDragger_swiginit(self, _coin.new_SoTabPlaneDragger())
    translation = property(_coin.SoTabPlaneDragger_translation_get, _coin.SoTabPlaneDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTabPlaneDragger_scaleFactor_get, _coin.SoTabPlaneDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def adjustScaleTabSize(self) -> "void":
        r"""adjustScaleTabSize(SoTabPlaneDragger self)"""
        return _coin.SoTabPlaneDragger_adjustScaleTabSize(self)

# Register SoTabPlaneDragger in _coin:
_coin.SoTabPlaneDragger_swigregister(SoTabPlaneDragger)

def SoTabPlaneDragger_getClassTypeId() -> "SoType":
    r"""SoTabPlaneDragger_getClassTypeId() -> SoType"""
    return _coin.SoTabPlaneDragger_getClassTypeId()

def SoTabPlaneDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoTabPlaneDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoTabPlaneDragger_getClassNodekitCatalog()

def SoTabPlaneDragger_initClass() -> "void":
    r"""SoTabPlaneDragger_initClass()"""
    return _coin.SoTabPlaneDragger_initClass()

class SoTrackballDragger(SoDragger):
    r"""Proxy of C++ SoTrackballDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTrackballDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTrackballDragger self) -> SoType"""
        return _coin.SoTrackballDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoTrackballDragger self) -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTrackballDragger_initClass()

    def __init__(self):
        r"""__init__(SoTrackballDragger self) -> SoTrackballDragger"""
        _coin.SoTrackballDragger_swiginit(self, _coin.new_SoTrackballDragger())
    rotation = property(_coin.SoTrackballDragger_rotation_get, _coin.SoTrackballDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    scaleFactor = property(_coin.SoTrackballDragger_scaleFactor_get, _coin.SoTrackballDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def isAnimationEnabled(self) -> "SbBool":
        r"""isAnimationEnabled(SoTrackballDragger self) -> SbBool"""
        return _coin.SoTrackballDragger_isAnimationEnabled(self)

    def setAnimationEnabled(self, newval: "SbBool") -> "void":
        r"""setAnimationEnabled(SoTrackballDragger self, SbBool newval)"""
        return _coin.SoTrackballDragger_setAnimationEnabled(self, newval)

# Register SoTrackballDragger in _coin:
_coin.SoTrackballDragger_swigregister(SoTrackballDragger)

def SoTrackballDragger_getClassTypeId() -> "SoType":
    r"""SoTrackballDragger_getClassTypeId() -> SoType"""
    return _coin.SoTrackballDragger_getClassTypeId()

def SoTrackballDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoTrackballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoTrackballDragger_getClassNodekitCatalog()

def SoTrackballDragger_initClass() -> "void":
    r"""SoTrackballDragger_initClass()"""
    return _coin.SoTrackballDragger_initClass()

class SoTransformBoxDragger(SoDragger):
    r"""Proxy of C++ SoTransformBoxDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformBoxDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformBoxDragger self) -> SoType"""
        return _coin.SoTransformBoxDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoTransformBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformBoxDragger_initClass()

    def __init__(self):
        r"""__init__(SoTransformBoxDragger self) -> SoTransformBoxDragger"""
        _coin.SoTransformBoxDragger_swiginit(self, _coin.new_SoTransformBoxDragger())
    rotation = property(_coin.SoTransformBoxDragger_rotation_get, _coin.SoTransformBoxDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoTransformBoxDragger_translation_get, _coin.SoTransformBoxDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTransformBoxDragger_scaleFactor_get, _coin.SoTransformBoxDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoTransformBoxDragger in _coin:
_coin.SoTransformBoxDragger_swigregister(SoTransformBoxDragger)

def SoTransformBoxDragger_getClassTypeId() -> "SoType":
    r"""SoTransformBoxDragger_getClassTypeId() -> SoType"""
    return _coin.SoTransformBoxDragger_getClassTypeId()

def SoTransformBoxDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoTransformBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoTransformBoxDragger_getClassNodekitCatalog()

def SoTransformBoxDragger_initClass() -> "void":
    r"""SoTransformBoxDragger_initClass()"""
    return _coin.SoTransformBoxDragger_initClass()

class SoTransformerDragger(SoDragger):
    r"""Proxy of C++ SoTransformerDragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformerDragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformerDragger self) -> SoType"""
        return _coin.SoTransformerDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoTransformerDragger self) -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformerDragger_initClass()

    def __init__(self):
        r"""__init__(SoTransformerDragger self) -> SoTransformerDragger"""
        _coin.SoTransformerDragger_swiginit(self, _coin.new_SoTransformerDragger())
    rotation = property(_coin.SoTransformerDragger_rotation_get, _coin.SoTransformerDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoTransformerDragger_translation_get, _coin.SoTransformerDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTransformerDragger_scaleFactor_get, _coin.SoTransformerDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    minDiscRotDot = property(_coin.SoTransformerDragger_minDiscRotDot_get, _coin.SoTransformerDragger_minDiscRotDot_set, doc=r"""minDiscRotDot : SoSFFloat""")
    INACTIVE = _coin.SoTransformerDragger_INACTIVE
    
    RIT_X_ROTATE = _coin.SoTransformerDragger_RIT_X_ROTATE
    
    TOP_Y_ROTATE = _coin.SoTransformerDragger_TOP_Y_ROTATE
    
    FNT_Z_ROTATE = _coin.SoTransformerDragger_FNT_Z_ROTATE
    
    LFT_X_ROTATE = _coin.SoTransformerDragger_LFT_X_ROTATE
    
    BOT_Y_ROTATE = _coin.SoTransformerDragger_BOT_Y_ROTATE
    
    BAK_Z_ROTATE = _coin.SoTransformerDragger_BAK_Z_ROTATE
    
    PX_PY_PZ_3D_SCALE = _coin.SoTransformerDragger_PX_PY_PZ_3D_SCALE
    
    PX_PY_NZ_3D_SCALE = _coin.SoTransformerDragger_PX_PY_NZ_3D_SCALE
    
    PX_NY_PZ_3D_SCALE = _coin.SoTransformerDragger_PX_NY_PZ_3D_SCALE
    
    PX_NY_NZ_3D_SCALE = _coin.SoTransformerDragger_PX_NY_NZ_3D_SCALE
    
    NX_PY_PZ_3D_SCALE = _coin.SoTransformerDragger_NX_PY_PZ_3D_SCALE
    
    NX_PY_NZ_3D_SCALE = _coin.SoTransformerDragger_NX_PY_NZ_3D_SCALE
    
    NX_NY_PZ_3D_SCALE = _coin.SoTransformerDragger_NX_NY_PZ_3D_SCALE
    
    NX_NY_NZ_3D_SCALE = _coin.SoTransformerDragger_NX_NY_NZ_3D_SCALE
    
    RIT_TRANSLATE = _coin.SoTransformerDragger_RIT_TRANSLATE
    
    TOP_TRANSLATE = _coin.SoTransformerDragger_TOP_TRANSLATE
    
    FNT_TRANSLATE = _coin.SoTransformerDragger_FNT_TRANSLATE
    
    LFT_TRANSLATE = _coin.SoTransformerDragger_LFT_TRANSLATE
    
    BOT_TRANSLATE = _coin.SoTransformerDragger_BOT_TRANSLATE
    
    BAK_TRANSLATE = _coin.SoTransformerDragger_BAK_TRANSLATE
    

    def getCurrentState(self) -> "SoTransformerDragger::State":
        r"""getCurrentState(SoTransformerDragger self) -> SoTransformerDragger::State"""
        return _coin.SoTransformerDragger_getCurrentState(self)

    def unsquishKnobs(self) -> "void":
        r"""unsquishKnobs(SoTransformerDragger self)"""
        return _coin.SoTransformerDragger_unsquishKnobs(self)

    def isLocateHighlighting(self) -> "SbBool":
        r"""isLocateHighlighting(SoTransformerDragger self) -> SbBool"""
        return _coin.SoTransformerDragger_isLocateHighlighting(self)

    def setLocateHighlighting(self, onoff: "SbBool") -> "void":
        r"""setLocateHighlighting(SoTransformerDragger self, SbBool onoff)"""
        return _coin.SoTransformerDragger_setLocateHighlighting(self, onoff)

    @staticmethod
    def setColinearThreshold(newval: "int") -> "void":
        r"""setColinearThreshold(int newval)"""
        return _coin.SoTransformerDragger_setColinearThreshold(newval)

    @staticmethod
    def getColinearThreshold() -> "int":
        r"""getColinearThreshold() -> int"""
        return _coin.SoTransformerDragger_getColinearThreshold()

    def getBoxPointInWorldSpace(self, pointonunitbox: "SbVec3f") -> "SbVec3f":
        r"""getBoxPointInWorldSpace(SoTransformerDragger self, SbVec3f pointonunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxPointInWorldSpace(self, pointonunitbox)

    def getBoxDirInWorldSpace(self, dironunitbox: "SbVec3f") -> "SbVec3f":
        r"""getBoxDirInWorldSpace(SoTransformerDragger self, SbVec3f dironunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxDirInWorldSpace(self, dironunitbox)

    def getWorldPointInBoxSpace(self, pointinworldspace: "SbVec3f") -> "SbVec3f":
        r"""getWorldPointInBoxSpace(SoTransformerDragger self, SbVec3f pointinworldspace) -> SbVec3f"""
        return _coin.SoTransformerDragger_getWorldPointInBoxSpace(self, pointinworldspace)

    def getWorldPointInPixelSpace(self, thepoint: "SbVec3f") -> "SbVec2f":
        r"""getWorldPointInPixelSpace(SoTransformerDragger self, SbVec3f thepoint) -> SbVec2f"""
        return _coin.SoTransformerDragger_getWorldPointInPixelSpace(self, thepoint)

    def getInteractiveCenterInBoxSpace(self) -> "SbVec3f":
        r"""getInteractiveCenterInBoxSpace(SoTransformerDragger self) -> SbVec3f"""
        return _coin.SoTransformerDragger_getInteractiveCenterInBoxSpace(self)

# Register SoTransformerDragger in _coin:
_coin.SoTransformerDragger_swigregister(SoTransformerDragger)

def SoTransformerDragger_getClassTypeId() -> "SoType":
    r"""SoTransformerDragger_getClassTypeId() -> SoType"""
    return _coin.SoTransformerDragger_getClassTypeId()

def SoTransformerDragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoTransformerDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoTransformerDragger_getClassNodekitCatalog()

def SoTransformerDragger_initClass() -> "void":
    r"""SoTransformerDragger_initClass()"""
    return _coin.SoTransformerDragger_initClass()

def SoTransformerDragger_setColinearThreshold(newval: "int") -> "void":
    r"""SoTransformerDragger_setColinearThreshold(int newval)"""
    return _coin.SoTransformerDragger_setColinearThreshold(newval)

def SoTransformerDragger_getColinearThreshold() -> "int":
    r"""SoTransformerDragger_getColinearThreshold() -> int"""
    return _coin.SoTransformerDragger_getColinearThreshold()

class SoTranslate1Dragger(SoDragger):
    r"""Proxy of C++ SoTranslate1Dragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTranslate1Dragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTranslate1Dragger self) -> SoType"""
        return _coin.SoTranslate1Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoTranslate1Dragger self) -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTranslate1Dragger_initClass()

    def __init__(self):
        r"""__init__(SoTranslate1Dragger self) -> SoTranslate1Dragger"""
        _coin.SoTranslate1Dragger_swiginit(self, _coin.new_SoTranslate1Dragger())
    translation = property(_coin.SoTranslate1Dragger_translation_get, _coin.SoTranslate1Dragger_translation_set, doc=r"""translation : SoSFVec3f""")
    minTranslation = property(_coin.SoTranslate1Dragger_minTranslation_get, _coin.SoTranslate1Dragger_minTranslation_set, doc=r"""minTranslation : SoSFFloat""")
    maxTranslation = property(_coin.SoTranslate1Dragger_maxTranslation_get, _coin.SoTranslate1Dragger_maxTranslation_set, doc=r"""maxTranslation : SoSFFloat""")

# Register SoTranslate1Dragger in _coin:
_coin.SoTranslate1Dragger_swigregister(SoTranslate1Dragger)

def SoTranslate1Dragger_getClassTypeId() -> "SoType":
    r"""SoTranslate1Dragger_getClassTypeId() -> SoType"""
    return _coin.SoTranslate1Dragger_getClassTypeId()

def SoTranslate1Dragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoTranslate1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoTranslate1Dragger_getClassNodekitCatalog()

def SoTranslate1Dragger_initClass() -> "void":
    r"""SoTranslate1Dragger_initClass()"""
    return _coin.SoTranslate1Dragger_initClass()

class SoSFVec2f(SoSField):
    r"""Proxy of C++ SoSFVec2f class."""

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

    def __init__(self):
        r"""__init__(SoSFVec2f self) -> SoSFVec2f"""
        _coin.SoSFVec2f_swiginit(self, _coin.new_SoSFVec2f())
    __swig_destroy__ = _coin.delete_SoSFVec2f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec2f self) -> SoType"""
        return _coin.SoSFVec2f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec2f self, SoField field)"""
        return _coin.SoSFVec2f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec2f self, SoField field) -> SbBool"""
        return _coin.SoSFVec2f_isSame(self, field)

    def getValue(self) -> "SbVec2f const &":
        r"""getValue(SoSFVec2f self) -> SbVec2f"""
        return _coin.SoSFVec2f_getValue(self)

    def __eq__(self, field: "SoSFVec2f") -> "int":
        r"""__eq__(SoSFVec2f self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___eq__(self, field)

    def __ne__(self, field: "SoSFVec2f") -> "int":
        r"""__ne__(SoSFVec2f self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec2f_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec2f self, SbVec2f newvalue)
        setValue(SoSFVec2f self, float x, float y)
        setValue(SoSFVec2f self, float const [2] xy)
        setValue(SoSFVec2f self, SoSFVec2f other)
        """
        return _coin.SoSFVec2f_setValue(self, *args)

# Register SoSFVec2f in _coin:
_coin.SoSFVec2f_swigregister(SoSFVec2f)

def SoSFVec2f_createInstance() -> "void *":
    r"""SoSFVec2f_createInstance() -> void *"""
    return _coin.SoSFVec2f_createInstance()

def SoSFVec2f_getClassTypeId() -> "SoType":
    r"""SoSFVec2f_getClassTypeId() -> SoType"""
    return _coin.SoSFVec2f_getClassTypeId()

def SoSFVec2f_initClass() -> "void":
    r"""SoSFVec2f_initClass()"""
    return _coin.SoSFVec2f_initClass()

class SoTranslate2Dragger(SoDragger):
    r"""Proxy of C++ SoTranslate2Dragger class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTranslate2Dragger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTranslate2Dragger self) -> SoType"""
        return _coin.SoTranslate2Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoTranslate2Dragger self) -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTranslate2Dragger_initClass()

    def __init__(self):
        r"""__init__(SoTranslate2Dragger self) -> SoTranslate2Dragger"""
        _coin.SoTranslate2Dragger_swiginit(self, _coin.new_SoTranslate2Dragger())
    translation = property(_coin.SoTranslate2Dragger_translation_get, _coin.SoTranslate2Dragger_translation_set, doc=r"""translation : SoSFVec3f""")
    minTranslation = property(_coin.SoTranslate2Dragger_minTranslation_get, _coin.SoTranslate2Dragger_minTranslation_set, doc=r"""minTranslation : SoSFVec2f""")
    maxTranslation = property(_coin.SoTranslate2Dragger_maxTranslation_get, _coin.SoTranslate2Dragger_maxTranslation_set, doc=r"""maxTranslation : SoSFVec2f""")

# Register SoTranslate2Dragger in _coin:
_coin.SoTranslate2Dragger_swigregister(SoTranslate2Dragger)

def SoTranslate2Dragger_getClassTypeId() -> "SoType":
    r"""SoTranslate2Dragger_getClassTypeId() -> SoType"""
    return _coin.SoTranslate2Dragger_getClassTypeId()

def SoTranslate2Dragger_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoTranslate2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoTranslate2Dragger_getClassNodekitCatalog()

def SoTranslate2Dragger_initClass() -> "void":
    r"""SoTranslate2Dragger_initClass()"""
    return _coin.SoTranslate2Dragger_initClass()

class SoAccumulatedElement(SoElement):
    r"""Proxy of C++ SoAccumulatedElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAccumulatedElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoAccumulatedElement_getClassStackIndex()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAccumulatedElement_initClass()

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoAccumulatedElement self, SoElement element) -> SbBool"""
        return _coin.SoAccumulatedElement_matches(self, element)

# Register SoAccumulatedElement in _coin:
_coin.SoAccumulatedElement_swigregister(SoAccumulatedElement)

def SoAccumulatedElement_getClassTypeId() -> "SoType":
    r"""SoAccumulatedElement_getClassTypeId() -> SoType"""
    return _coin.SoAccumulatedElement_getClassTypeId()

def SoAccumulatedElement_getClassStackIndex() -> "int":
    r"""SoAccumulatedElement_getClassStackIndex() -> int"""
    return _coin.SoAccumulatedElement_getClassStackIndex()

def SoAccumulatedElement_initClass() -> "void":
    r"""SoAccumulatedElement_initClass()"""
    return _coin.SoAccumulatedElement_initClass()

class SoAmbientColorElement(SoReplacedElement):
    r"""Proxy of C++ SoAmbientColorElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAmbientColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoAmbientColorElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoAmbientColorElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAmbientColorElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoAmbientColorElement self, SoState state)"""
        return _coin.SoAmbientColorElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numcolors: "int32_t const", colors: "SbColor") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoAmbientColorElement_set(state, node, numcolors, colors)

    @staticmethod
    def getInstance(state: "SoState") -> "SoAmbientColorElement const *":
        r"""getInstance(SoState state) -> SoAmbientColorElement"""
        return _coin.SoAmbientColorElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoAmbientColorElement self) -> int32_t"""
        return _coin.SoAmbientColorElement_getNum(self)

    def get(self, index: "int const") -> "SbColor const &":
        r"""get(SoAmbientColorElement self, int const index) -> SbColor"""
        return _coin.SoAmbientColorElement_get(self, index)

    def getArrayPtr(self) -> "SbColor const *":
        r"""getArrayPtr(SoAmbientColorElement self) -> SbColor"""
        return _coin.SoAmbientColorElement_getArrayPtr(self)

# Register SoAmbientColorElement in _coin:
_coin.SoAmbientColorElement_swigregister(SoAmbientColorElement)

def SoAmbientColorElement_getClassTypeId() -> "SoType":
    r"""SoAmbientColorElement_getClassTypeId() -> SoType"""
    return _coin.SoAmbientColorElement_getClassTypeId()

def SoAmbientColorElement_getClassStackIndex() -> "int":
    r"""SoAmbientColorElement_getClassStackIndex() -> int"""
    return _coin.SoAmbientColorElement_getClassStackIndex()

def SoAmbientColorElement_createInstance() -> "void *":
    r"""SoAmbientColorElement_createInstance() -> void *"""
    return _coin.SoAmbientColorElement_createInstance()

def SoAmbientColorElement_initClass() -> "void":
    r"""SoAmbientColorElement_initClass()"""
    return _coin.SoAmbientColorElement_initClass()

def SoAmbientColorElement_set(state: "SoState", node: "SoNode", numcolors: "int32_t const", colors: "SbColor") -> "void":
    r"""SoAmbientColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
    return _coin.SoAmbientColorElement_set(state, node, numcolors, colors)

def SoAmbientColorElement_getInstance(state: "SoState") -> "SoAmbientColorElement const *":
    r"""SoAmbientColorElement_getInstance(SoState state) -> SoAmbientColorElement"""
    return _coin.SoAmbientColorElement_getInstance(state)

class SoAnnoText3CharOrientElement(SoInt32Element):
    r"""Proxy of C++ SoAnnoText3CharOrientElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3CharOrientElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoAnnoText3CharOrientElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoAnnoText3CharOrientElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAnnoText3CharOrientElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoAnnoText3CharOrientElement self, SoState state)"""
        return _coin.SoAnnoText3CharOrientElement_init(self, state)

    @staticmethod
    def set(state: "SoState", isOriented: "SbBool") -> "void":
        r"""set(SoState state, SbBool isOriented)"""
        return _coin.SoAnnoText3CharOrientElement_set(state, isOriented)

    @staticmethod
    def get(state: "SoState") -> "SbBool":
        r"""get(SoState state) -> SbBool"""
        return _coin.SoAnnoText3CharOrientElement_get(state)

    @staticmethod
    def getDefault() -> "SbBool":
        r"""getDefault() -> SbBool"""
        return _coin.SoAnnoText3CharOrientElement_getDefault()

# Register SoAnnoText3CharOrientElement in _coin:
_coin.SoAnnoText3CharOrientElement_swigregister(SoAnnoText3CharOrientElement)

def SoAnnoText3CharOrientElement_getClassTypeId() -> "SoType":
    r"""SoAnnoText3CharOrientElement_getClassTypeId() -> SoType"""
    return _coin.SoAnnoText3CharOrientElement_getClassTypeId()

def SoAnnoText3CharOrientElement_getClassStackIndex() -> "int":
    r"""SoAnnoText3CharOrientElement_getClassStackIndex() -> int"""
    return _coin.SoAnnoText3CharOrientElement_getClassStackIndex()

def SoAnnoText3CharOrientElement_createInstance() -> "void *":
    r"""SoAnnoText3CharOrientElement_createInstance() -> void *"""
    return _coin.SoAnnoText3CharOrientElement_createInstance()

def SoAnnoText3CharOrientElement_initClass() -> "void":
    r"""SoAnnoText3CharOrientElement_initClass()"""
    return _coin.SoAnnoText3CharOrientElement_initClass()

def SoAnnoText3CharOrientElement_set(state: "SoState", isOriented: "SbBool") -> "void":
    r"""SoAnnoText3CharOrientElement_set(SoState state, SbBool isOriented)"""
    return _coin.SoAnnoText3CharOrientElement_set(state, isOriented)

def SoAnnoText3CharOrientElement_get(state: "SoState") -> "SbBool":
    r"""SoAnnoText3CharOrientElement_get(SoState state) -> SbBool"""
    return _coin.SoAnnoText3CharOrientElement_get(state)

def SoAnnoText3CharOrientElement_getDefault() -> "SbBool":
    r"""SoAnnoText3CharOrientElement_getDefault() -> SbBool"""
    return _coin.SoAnnoText3CharOrientElement_getDefault()

class SoAnnoText3FontSizeHintElement(SoInt32Element):
    r"""Proxy of C++ SoAnnoText3FontSizeHintElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3FontSizeHintElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoAnnoText3FontSizeHintElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoAnnoText3FontSizeHintElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAnnoText3FontSizeHintElement_initClass()
    ANNOTATION = _coin.SoAnnoText3FontSizeHintElement_ANNOTATION
    
    FIT_TEXT_VECTOR = _coin.SoAnnoText3FontSizeHintElement_FIT_TEXT_VECTOR
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoAnnoText3FontSizeHintElement self, SoState state)"""
        return _coin.SoAnnoText3FontSizeHintElement_init(self, state)

    @staticmethod
    def get(state: "SoState") -> "SoAnnoText3FontSizeHintElement::FontSizeHint":
        r"""get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_get(state)

    @staticmethod
    def getDefault() -> "SoAnnoText3FontSizeHintElement::FontSizeHint":
        r"""getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_getDefault()

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
        set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
        """
        return _coin.SoAnnoText3FontSizeHintElement_set(*args)

# Register SoAnnoText3FontSizeHintElement in _coin:
_coin.SoAnnoText3FontSizeHintElement_swigregister(SoAnnoText3FontSizeHintElement)

def SoAnnoText3FontSizeHintElement_getClassTypeId() -> "SoType":
    r"""SoAnnoText3FontSizeHintElement_getClassTypeId() -> SoType"""
    return _coin.SoAnnoText3FontSizeHintElement_getClassTypeId()

def SoAnnoText3FontSizeHintElement_getClassStackIndex() -> "int":
    r"""SoAnnoText3FontSizeHintElement_getClassStackIndex() -> int"""
    return _coin.SoAnnoText3FontSizeHintElement_getClassStackIndex()

def SoAnnoText3FontSizeHintElement_createInstance() -> "void *":
    r"""SoAnnoText3FontSizeHintElement_createInstance() -> void *"""
    return _coin.SoAnnoText3FontSizeHintElement_createInstance()

def SoAnnoText3FontSizeHintElement_initClass() -> "void":
    r"""SoAnnoText3FontSizeHintElement_initClass()"""
    return _coin.SoAnnoText3FontSizeHintElement_initClass()

def SoAnnoText3FontSizeHintElement_get(state: "SoState") -> "SoAnnoText3FontSizeHintElement::FontSizeHint":
    r"""SoAnnoText3FontSizeHintElement_get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
    return _coin.SoAnnoText3FontSizeHintElement_get(state)

def SoAnnoText3FontSizeHintElement_getDefault() -> "SoAnnoText3FontSizeHintElement::FontSizeHint":
    r"""SoAnnoText3FontSizeHintElement_getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
    return _coin.SoAnnoText3FontSizeHintElement_getDefault()

def SoAnnoText3FontSizeHintElement_set(*args) -> "void":
    r"""
    SoAnnoText3FontSizeHintElement_set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
    SoAnnoText3FontSizeHintElement_set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
    """
    return _coin.SoAnnoText3FontSizeHintElement_set(*args)

class SoAnnoText3RenderPrintElement(SoInt32Element):
    r"""Proxy of C++ SoAnnoText3RenderPrintElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3RenderPrintElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoAnnoText3RenderPrintElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoAnnoText3RenderPrintElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAnnoText3RenderPrintElement_initClass()
    RENDER3D_PRINT_VECTOR = _coin.SoAnnoText3RenderPrintElement_RENDER3D_PRINT_VECTOR
    
    RENDER3D_PRINT_RASTER = _coin.SoAnnoText3RenderPrintElement_RENDER3D_PRINT_RASTER
    
    RENDER2D_PRINT_RASTER = _coin.SoAnnoText3RenderPrintElement_RENDER2D_PRINT_RASTER
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoAnnoText3RenderPrintElement self, SoState state)"""
        return _coin.SoAnnoText3RenderPrintElement_init(self, state)

    @staticmethod
    def get(state: "SoState") -> "SoAnnoText3RenderPrintElement::RenderPrintType":
        r"""get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_get(state)

    @staticmethod
    def getDefault() -> "SoAnnoText3RenderPrintElement::RenderPrintType":
        r"""getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_getDefault()

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)
        set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const type)
        """
        return _coin.SoAnnoText3RenderPrintElement_set(*args)

# Register SoAnnoText3RenderPrintElement in _coin:
_coin.SoAnnoText3RenderPrintElement_swigregister(SoAnnoText3RenderPrintElement)

def SoAnnoText3RenderPrintElement_getClassTypeId() -> "SoType":
    r"""SoAnnoText3RenderPrintElement_getClassTypeId() -> SoType"""
    return _coin.SoAnnoText3RenderPrintElement_getClassTypeId()

def SoAnnoText3RenderPrintElement_getClassStackIndex() -> "int":
    r"""SoAnnoText3RenderPrintElement_getClassStackIndex() -> int"""
    return _coin.SoAnnoText3RenderPrintElement_getClassStackIndex()

def SoAnnoText3RenderPrintElement_createInstance() -> "void *":
    r"""SoAnnoText3RenderPrintElement_createInstance() -> void *"""
    return _coin.SoAnnoText3RenderPrintElement_createInstance()

def SoAnnoText3RenderPrintElement_initClass() -> "void":
    r"""SoAnnoText3RenderPrintElement_initClass()"""
    return _coin.SoAnnoText3RenderPrintElement_initClass()

def SoAnnoText3RenderPrintElement_get(state: "SoState") -> "SoAnnoText3RenderPrintElement::RenderPrintType":
    r"""SoAnnoText3RenderPrintElement_get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"""
    return _coin.SoAnnoText3RenderPrintElement_get(state)

def SoAnnoText3RenderPrintElement_getDefault() -> "SoAnnoText3RenderPrintElement::RenderPrintType":
    r"""SoAnnoText3RenderPrintElement_getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"""
    return _coin.SoAnnoText3RenderPrintElement_getDefault()

def SoAnnoText3RenderPrintElement_set(*args) -> "void":
    r"""
    SoAnnoText3RenderPrintElement_set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)
    SoAnnoText3RenderPrintElement_set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const type)
    """
    return _coin.SoAnnoText3RenderPrintElement_set(*args)

class SoModelMatrixElement(SoAccumulatedElement):
    r"""Proxy of C++ SoModelMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoModelMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoModelMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoModelMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoModelMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoModelMatrixElement self, SoState state)"""
        return _coin.SoModelMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoModelMatrixElement self, SoState state)"""
        return _coin.SoModelMatrixElement_push(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoModelMatrixElement self, SoElement element) -> SbBool"""
        return _coin.SoModelMatrixElement_matches(self, element)

    @staticmethod
    def makeIdentity(state: "SoState", node: "SoNode") -> "void":
        r"""makeIdentity(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_makeIdentity(state, node)

    @staticmethod
    def set(state: "SoState", node: "SoNode") -> "SbMatrix &":
        r"""set(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_set(state, node)

    @staticmethod
    def setCullMatrix(state: "SoState", node: "SoNode") -> "SbMatrix &":
        r"""setCullMatrix(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_setCullMatrix(state, node)

    @staticmethod
    def mult(state: "SoState", node: "SoNode") -> "SbMatrix &":
        r"""mult(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_mult(state, node)

    @staticmethod
    def translateBy(state: "SoState", node: "SoNode", translation: "SbVec3f") -> "void":
        r"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoModelMatrixElement_translateBy(state, node, translation)

    @staticmethod
    def rotateBy(state: "SoState", node: "SoNode", rotation: "SbRotation") -> "void":
        r"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoModelMatrixElement_rotateBy(state, node, rotation)

    @staticmethod
    def scaleBy(state: "SoState", node: "SoNode", scaleFactor: "SbVec3f") -> "void":
        r"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoModelMatrixElement_scaleBy(state, node, scaleFactor)

    @staticmethod
    def pushMatrix(state: "SoState") -> "SbMatrix":
        r"""pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_pushMatrix(state)

    @staticmethod
    def popMatrix(state: "SoState") -> "SbMatrix &":
        r"""popMatrix(SoState state)"""
        return _coin.SoModelMatrixElement_popMatrix(state)

    @staticmethod
    def getCombinedCullMatrix(state: "SoState") -> "SbMatrix const &":
        r"""getCombinedCullMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_getCombinedCullMatrix(state)

    @staticmethod
    def get(*args) -> "SbMatrix const &":
        r"""
        get(SoState state) -> SbMatrix
        get(SoState state, SbBool & isIdentity) -> SbMatrix
        """
        return _coin.SoModelMatrixElement_get(*args)

    def getModelMatrix(self) -> "SbMatrix const &":
        r"""getModelMatrix(SoModelMatrixElement self) -> SbMatrix"""
        return _coin.SoModelMatrixElement_getModelMatrix(self)

# Register SoModelMatrixElement in _coin:
_coin.SoModelMatrixElement_swigregister(SoModelMatrixElement)

def SoModelMatrixElement_getClassTypeId() -> "SoType":
    r"""SoModelMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoModelMatrixElement_getClassTypeId()

def SoModelMatrixElement_getClassStackIndex() -> "int":
    r"""SoModelMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoModelMatrixElement_getClassStackIndex()

def SoModelMatrixElement_createInstance() -> "void *":
    r"""SoModelMatrixElement_createInstance() -> void *"""
    return _coin.SoModelMatrixElement_createInstance()

def SoModelMatrixElement_initClass() -> "void":
    r"""SoModelMatrixElement_initClass()"""
    return _coin.SoModelMatrixElement_initClass()

def SoModelMatrixElement_makeIdentity(state: "SoState", node: "SoNode") -> "void":
    r"""SoModelMatrixElement_makeIdentity(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_makeIdentity(state, node)

def SoModelMatrixElement_set(state: "SoState", node: "SoNode") -> "SbMatrix &":
    r"""SoModelMatrixElement_set(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_set(state, node)

def SoModelMatrixElement_setCullMatrix(state: "SoState", node: "SoNode") -> "SbMatrix &":
    r"""SoModelMatrixElement_setCullMatrix(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_setCullMatrix(state, node)

def SoModelMatrixElement_mult(state: "SoState", node: "SoNode") -> "SbMatrix &":
    r"""SoModelMatrixElement_mult(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_mult(state, node)

def SoModelMatrixElement_translateBy(state: "SoState", node: "SoNode", translation: "SbVec3f") -> "void":
    r"""SoModelMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
    return _coin.SoModelMatrixElement_translateBy(state, node, translation)

def SoModelMatrixElement_rotateBy(state: "SoState", node: "SoNode", rotation: "SbRotation") -> "void":
    r"""SoModelMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
    return _coin.SoModelMatrixElement_rotateBy(state, node, rotation)

def SoModelMatrixElement_scaleBy(state: "SoState", node: "SoNode", scaleFactor: "SbVec3f") -> "void":
    r"""SoModelMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
    return _coin.SoModelMatrixElement_scaleBy(state, node, scaleFactor)

def SoModelMatrixElement_pushMatrix(state: "SoState") -> "SbMatrix":
    r"""SoModelMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
    return _coin.SoModelMatrixElement_pushMatrix(state)

def SoModelMatrixElement_popMatrix(state: "SoState") -> "SbMatrix &":
    r"""SoModelMatrixElement_popMatrix(SoState state)"""
    return _coin.SoModelMatrixElement_popMatrix(state)

def SoModelMatrixElement_getCombinedCullMatrix(state: "SoState") -> "SbMatrix const &":
    r"""SoModelMatrixElement_getCombinedCullMatrix(SoState state) -> SbMatrix"""
    return _coin.SoModelMatrixElement_getCombinedCullMatrix(state)

def SoModelMatrixElement_get(*args) -> "SbMatrix const &":
    r"""
    SoModelMatrixElement_get(SoState state) -> SbMatrix
    SoModelMatrixElement_get(SoState state, SbBool & isIdentity) -> SbMatrix
    """
    return _coin.SoModelMatrixElement_get(*args)

class SoBBoxModelMatrixElement(SoModelMatrixElement):
    r"""Proxy of C++ SoBBoxModelMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBBoxModelMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoBBoxModelMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoBBoxModelMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBBoxModelMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoBBoxModelMatrixElement self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoBBoxModelMatrixElement self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_push(self, state)

    @staticmethod
    def reset(state: "SoState", node: "SoNode") -> "void":
        r"""reset(SoState state, SoNode node)"""
        return _coin.SoBBoxModelMatrixElement_reset(state, node)

    @staticmethod
    def pushMatrix(state: "SoState", localmatrix: "SbMatrix") -> "SbMatrix &":
        r"""pushMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_pushMatrix(state, localmatrix)

    @staticmethod
    def popMatrix(state: "SoState", localmatrix: "SbMatrix") -> "SbMatrix &":
        r"""popMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_popMatrix(state, localmatrix)

# Register SoBBoxModelMatrixElement in _coin:
_coin.SoBBoxModelMatrixElement_swigregister(SoBBoxModelMatrixElement)

def SoBBoxModelMatrixElement_getClassTypeId() -> "SoType":
    r"""SoBBoxModelMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoBBoxModelMatrixElement_getClassTypeId()

def SoBBoxModelMatrixElement_getClassStackIndex() -> "int":
    r"""SoBBoxModelMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoBBoxModelMatrixElement_getClassStackIndex()

def SoBBoxModelMatrixElement_createInstance() -> "void *":
    r"""SoBBoxModelMatrixElement_createInstance() -> void *"""
    return _coin.SoBBoxModelMatrixElement_createInstance()

def SoBBoxModelMatrixElement_initClass() -> "void":
    r"""SoBBoxModelMatrixElement_initClass()"""
    return _coin.SoBBoxModelMatrixElement_initClass()

def SoBBoxModelMatrixElement_reset(state: "SoState", node: "SoNode") -> "void":
    r"""SoBBoxModelMatrixElement_reset(SoState state, SoNode node)"""
    return _coin.SoBBoxModelMatrixElement_reset(state, node)

def SoBBoxModelMatrixElement_pushMatrix(state: "SoState", localmatrix: "SbMatrix") -> "SbMatrix &":
    r"""SoBBoxModelMatrixElement_pushMatrix(SoState state, SbMatrix localmatrix)"""
    return _coin.SoBBoxModelMatrixElement_pushMatrix(state, localmatrix)

def SoBBoxModelMatrixElement_popMatrix(state: "SoState", localmatrix: "SbMatrix") -> "SbMatrix &":
    r"""SoBBoxModelMatrixElement_popMatrix(SoState state, SbMatrix localmatrix)"""
    return _coin.SoBBoxModelMatrixElement_popMatrix(state, localmatrix)

class SoBumpMapCoordinateElement(SoReplacedElement):
    r"""Proxy of C++ SoBumpMapCoordinateElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoBumpMapCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoBumpMapCoordinateElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBumpMapCoordinateElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoBumpMapCoordinateElement self, SoState state)"""
        return _coin.SoBumpMapCoordinateElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numcoords: "int32_t const", coords: "SbVec2f") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"""
        return _coin.SoBumpMapCoordinateElement_set(state, node, numcoords, coords)

    @staticmethod
    def getInstance(state: "SoState") -> "SoBumpMapCoordinateElement const *":
        r"""getInstance(SoState state) -> SoBumpMapCoordinateElement"""
        return _coin.SoBumpMapCoordinateElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoBumpMapCoordinateElement self) -> int32_t"""
        return _coin.SoBumpMapCoordinateElement_getNum(self)

    def get(self, index: "int const") -> "SbVec2f const &":
        r"""get(SoBumpMapCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoBumpMapCoordinateElement_get(self, index)

    def getArrayPtr(self) -> "SbVec2f const *":
        r"""getArrayPtr(SoBumpMapCoordinateElement self) -> SbVec2f"""
        return _coin.SoBumpMapCoordinateElement_getArrayPtr(self)

# Register SoBumpMapCoordinateElement in _coin:
_coin.SoBumpMapCoordinateElement_swigregister(SoBumpMapCoordinateElement)

def SoBumpMapCoordinateElement_getClassTypeId() -> "SoType":
    r"""SoBumpMapCoordinateElement_getClassTypeId() -> SoType"""
    return _coin.SoBumpMapCoordinateElement_getClassTypeId()

def SoBumpMapCoordinateElement_getClassStackIndex() -> "int":
    r"""SoBumpMapCoordinateElement_getClassStackIndex() -> int"""
    return _coin.SoBumpMapCoordinateElement_getClassStackIndex()

def SoBumpMapCoordinateElement_createInstance() -> "void *":
    r"""SoBumpMapCoordinateElement_createInstance() -> void *"""
    return _coin.SoBumpMapCoordinateElement_createInstance()

def SoBumpMapCoordinateElement_initClass() -> "void":
    r"""SoBumpMapCoordinateElement_initClass()"""
    return _coin.SoBumpMapCoordinateElement_initClass()

def SoBumpMapCoordinateElement_set(state: "SoState", node: "SoNode", numcoords: "int32_t const", coords: "SbVec2f") -> "void":
    r"""SoBumpMapCoordinateElement_set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"""
    return _coin.SoBumpMapCoordinateElement_set(state, node, numcoords, coords)

def SoBumpMapCoordinateElement_getInstance(state: "SoState") -> "SoBumpMapCoordinateElement const *":
    r"""SoBumpMapCoordinateElement_getInstance(SoState state) -> SoBumpMapCoordinateElement"""
    return _coin.SoBumpMapCoordinateElement_getInstance(state)

class SoBumpMapElement(SoReplacedElement):
    r"""Proxy of C++ SoBumpMapElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoBumpMapElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoBumpMapElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBumpMapElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoBumpMapElement self, SoState state)"""
        return _coin.SoBumpMapElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", image: "SoGLImage") -> "void":
        r"""set(SoState state, SoNode node, SoGLImage image)"""
        return _coin.SoBumpMapElement_set(state, node, image)

    @staticmethod
    def get(state: "SoState") -> "SoGLImage *":
        r"""get(SoState state) -> SoGLImage"""
        return _coin.SoBumpMapElement_get(state)

# Register SoBumpMapElement in _coin:
_coin.SoBumpMapElement_swigregister(SoBumpMapElement)

def SoBumpMapElement_getClassTypeId() -> "SoType":
    r"""SoBumpMapElement_getClassTypeId() -> SoType"""
    return _coin.SoBumpMapElement_getClassTypeId()

def SoBumpMapElement_getClassStackIndex() -> "int":
    r"""SoBumpMapElement_getClassStackIndex() -> int"""
    return _coin.SoBumpMapElement_getClassStackIndex()

def SoBumpMapElement_createInstance() -> "void *":
    r"""SoBumpMapElement_createInstance() -> void *"""
    return _coin.SoBumpMapElement_createInstance()

def SoBumpMapElement_initClass() -> "void":
    r"""SoBumpMapElement_initClass()"""
    return _coin.SoBumpMapElement_initClass()

def SoBumpMapElement_set(state: "SoState", node: "SoNode", image: "SoGLImage") -> "void":
    r"""SoBumpMapElement_set(SoState state, SoNode node, SoGLImage image)"""
    return _coin.SoBumpMapElement_set(state, node, image)

def SoBumpMapElement_get(state: "SoState") -> "SoGLImage *":
    r"""SoBumpMapElement_get(SoState state) -> SoGLImage"""
    return _coin.SoBumpMapElement_get(state)

class SoBumpMapMatrixElement(SoAccumulatedElement):
    r"""Proxy of C++ SoBumpMapMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoBumpMapMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoBumpMapMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBumpMapMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoBumpMapMatrixElement self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoBumpMapMatrixElement self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_push(self, state)

    @staticmethod
    def makeIdentity(state: "SoState", node: "SoNode") -> "void":
        r"""makeIdentity(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_makeIdentity(state, node)

    @staticmethod
    def set(state: "SoState", node: "SoNode") -> "SbMatrix &":
        r"""set(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_set(state, node)

    @staticmethod
    def mult(state: "SoState", node: "SoNode") -> "SbMatrix &":
        r"""mult(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_mult(state, node)

    @staticmethod
    def translateBy(state: "SoState", node: "SoNode", translation: "SbVec3f") -> "void":
        r"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoBumpMapMatrixElement_translateBy(state, node, translation)

    @staticmethod
    def rotateBy(state: "SoState", node: "SoNode", rotation: "SbRotation") -> "void":
        r"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoBumpMapMatrixElement_rotateBy(state, node, rotation)

    @staticmethod
    def scaleBy(state: "SoState", node: "SoNode", scaleFactor: "SbVec3f") -> "void":
        r"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor)

    @staticmethod
    def get(state: "SoState") -> "SbMatrix const &":
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoBumpMapMatrixElement_get(state)

# Register SoBumpMapMatrixElement in _coin:
_coin.SoBumpMapMatrixElement_swigregister(SoBumpMapMatrixElement)

def SoBumpMapMatrixElement_getClassTypeId() -> "SoType":
    r"""SoBumpMapMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoBumpMapMatrixElement_getClassTypeId()

def SoBumpMapMatrixElement_getClassStackIndex() -> "int":
    r"""SoBumpMapMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoBumpMapMatrixElement_getClassStackIndex()

def SoBumpMapMatrixElement_createInstance() -> "void *":
    r"""SoBumpMapMatrixElement_createInstance() -> void *"""
    return _coin.SoBumpMapMatrixElement_createInstance()

def SoBumpMapMatrixElement_initClass() -> "void":
    r"""SoBumpMapMatrixElement_initClass()"""
    return _coin.SoBumpMapMatrixElement_initClass()

def SoBumpMapMatrixElement_makeIdentity(state: "SoState", node: "SoNode") -> "void":
    r"""SoBumpMapMatrixElement_makeIdentity(SoState state, SoNode node)"""
    return _coin.SoBumpMapMatrixElement_makeIdentity(state, node)

def SoBumpMapMatrixElement_set(state: "SoState", node: "SoNode") -> "SbMatrix &":
    r"""SoBumpMapMatrixElement_set(SoState state, SoNode node)"""
    return _coin.SoBumpMapMatrixElement_set(state, node)

def SoBumpMapMatrixElement_mult(state: "SoState", node: "SoNode") -> "SbMatrix &":
    r"""SoBumpMapMatrixElement_mult(SoState state, SoNode node)"""
    return _coin.SoBumpMapMatrixElement_mult(state, node)

def SoBumpMapMatrixElement_translateBy(state: "SoState", node: "SoNode", translation: "SbVec3f") -> "void":
    r"""SoBumpMapMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
    return _coin.SoBumpMapMatrixElement_translateBy(state, node, translation)

def SoBumpMapMatrixElement_rotateBy(state: "SoState", node: "SoNode", rotation: "SbRotation") -> "void":
    r"""SoBumpMapMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
    return _coin.SoBumpMapMatrixElement_rotateBy(state, node, rotation)

def SoBumpMapMatrixElement_scaleBy(state: "SoState", node: "SoNode", scaleFactor: "SbVec3f") -> "void":
    r"""SoBumpMapMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
    return _coin.SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor)

def SoBumpMapMatrixElement_get(state: "SoState") -> "SbMatrix const &":
    r"""SoBumpMapMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoBumpMapMatrixElement_get(state)

class SoCacheElement(SoElement):
    r"""Proxy of C++ SoCacheElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCacheElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoCacheElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoCacheElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCacheElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoCacheElement self, SoState state)"""
        return _coin.SoCacheElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoCacheElement self, SoState state)"""
        return _coin.SoCacheElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoCacheElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoCacheElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(state: "SoState", cache: "SoCache") -> "void":
        r"""set(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_set(state, cache)

    def getCache(self) -> "SoCache *":
        r"""getCache(SoCacheElement self) -> SoCache"""
        return _coin.SoCacheElement_getCache(self)

    @staticmethod
    def anyOpen(state: "SoState") -> "SbBool":
        r"""anyOpen(SoState state) -> SbBool"""
        return _coin.SoCacheElement_anyOpen(state)

    @staticmethod
    def invalidate(state: "SoState") -> "void":
        r"""invalidate(SoState state)"""
        return _coin.SoCacheElement_invalidate(state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoCacheElement self, SoElement element) -> SbBool"""
        return _coin.SoCacheElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoCacheElement self) -> SoElement"""
        return _coin.SoCacheElement_copyMatchInfo(self)

    def getNextCacheElement(self) -> "SoCacheElement *":
        r"""getNextCacheElement(SoCacheElement self) -> SoCacheElement"""
        return _coin.SoCacheElement_getNextCacheElement(self)

    @staticmethod
    def addElement(state: "SoState", element: "SoElement") -> "void":
        r"""addElement(SoState state, SoElement element)"""
        return _coin.SoCacheElement_addElement(state, element)

    @staticmethod
    def addCacheDependency(state: "SoState", cache: "SoCache") -> "void":
        r"""addCacheDependency(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_addCacheDependency(state, cache)

    @staticmethod
    def setInvalid(newvalue: "SbBool const") -> "SbBool":
        r"""setInvalid(SbBool const newvalue) -> SbBool"""
        return _coin.SoCacheElement_setInvalid(newvalue)

    @staticmethod
    def getCurrentCache(state: "SoState") -> "SoCache *":
        r"""getCurrentCache(SoState state) -> SoCache"""
        return _coin.SoCacheElement_getCurrentCache(state)

# Register SoCacheElement in _coin:
_coin.SoCacheElement_swigregister(SoCacheElement)

def SoCacheElement_getClassTypeId() -> "SoType":
    r"""SoCacheElement_getClassTypeId() -> SoType"""
    return _coin.SoCacheElement_getClassTypeId()

def SoCacheElement_getClassStackIndex() -> "int":
    r"""SoCacheElement_getClassStackIndex() -> int"""
    return _coin.SoCacheElement_getClassStackIndex()

def SoCacheElement_createInstance() -> "void *":
    r"""SoCacheElement_createInstance() -> void *"""
    return _coin.SoCacheElement_createInstance()

def SoCacheElement_initClass() -> "void":
    r"""SoCacheElement_initClass()"""
    return _coin.SoCacheElement_initClass()

def SoCacheElement_set(state: "SoState", cache: "SoCache") -> "void":
    r"""SoCacheElement_set(SoState state, SoCache cache)"""
    return _coin.SoCacheElement_set(state, cache)

def SoCacheElement_anyOpen(state: "SoState") -> "SbBool":
    r"""SoCacheElement_anyOpen(SoState state) -> SbBool"""
    return _coin.SoCacheElement_anyOpen(state)

def SoCacheElement_invalidate(state: "SoState") -> "void":
    r"""SoCacheElement_invalidate(SoState state)"""
    return _coin.SoCacheElement_invalidate(state)

def SoCacheElement_addElement(state: "SoState", element: "SoElement") -> "void":
    r"""SoCacheElement_addElement(SoState state, SoElement element)"""
    return _coin.SoCacheElement_addElement(state, element)

def SoCacheElement_addCacheDependency(state: "SoState", cache: "SoCache") -> "void":
    r"""SoCacheElement_addCacheDependency(SoState state, SoCache cache)"""
    return _coin.SoCacheElement_addCacheDependency(state, cache)

def SoCacheElement_setInvalid(newvalue: "SbBool const") -> "SbBool":
    r"""SoCacheElement_setInvalid(SbBool const newvalue) -> SbBool"""
    return _coin.SoCacheElement_setInvalid(newvalue)

def SoCacheElement_getCurrentCache(state: "SoState") -> "SoCache *":
    r"""SoCacheElement_getCurrentCache(SoState state) -> SoCache"""
    return _coin.SoCacheElement_getCurrentCache(state)

class SbPlane(object):
    r"""Proxy of C++ SbPlane class."""

    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):
        r"""
        __init__(SbPlane self) -> SbPlane
        __init__(SbPlane self, SbVec3f normal, float const D) -> SbPlane
        __init__(SbPlane self, SbVec3f p0, SbVec3f p1, SbVec3f p2) -> SbPlane
        __init__(SbPlane self, SbVec3f normal, SbVec3f point) -> SbPlane
        """
        _coin.SbPlane_swiginit(self, _coin.new_SbPlane(*args))

    def offset(self, d: "float const") -> "void":
        r"""offset(SbPlane self, float const d)"""
        return _coin.SbPlane_offset(self, d)

    def transform(self) -> "void":
        r"""transform(SbPlane self)"""
        return _coin.SbPlane_transform(self)

    def isInHalfSpace(self, point: "SbVec3f") -> "SbBool":
        r"""isInHalfSpace(SbPlane self, SbVec3f point) -> SbBool"""
        return _coin.SbPlane_isInHalfSpace(self, point)

    def getDistance(self, point: "SbVec3f") -> "float":
        r"""getDistance(SbPlane self, SbVec3f point) -> float"""
        return _coin.SbPlane_getDistance(self, point)

    def getNormal(self) -> "SbVec3f const &":
        r"""getNormal(SbPlane self) -> SbVec3f"""
        return _coin.SbPlane_getNormal(self)

    def getDistanceFromOrigin(self) -> "float":
        r"""getDistanceFromOrigin(SbPlane self) -> float"""
        return _coin.SbPlane_getDistanceFromOrigin(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbPlane self, FILE * file)"""
        return _coin.SbPlane_output(self, file)

    def __eq__(self, u: "SbPlane") -> "int":
        r"""__eq__(SbPlane self, SbPlane u) -> int"""
        return _coin.SbPlane___eq__(self, u)

    def __ne__(self, u: "SbPlane") -> "int":
        r"""__ne__(SbPlane self, SbPlane u) -> int"""
        return _coin.SbPlane___ne__(self, u)

    def intersect(self, *args) -> "PyObject *":
        r"""intersect(SbPlane) -> SbLineintersect(SbPlane) -> SbLine"""
        return _coin.SbPlane_intersect(self, *args)
    __swig_destroy__ = _coin.delete_SbPlane

# Register SbPlane in _coin:
_coin.SbPlane_swigregister(SbPlane)

class SoClipPlaneElement(SoAccumulatedElement):
    r"""Proxy of C++ SoClipPlaneElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoClipPlaneElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoClipPlaneElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoClipPlaneElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoClipPlaneElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoClipPlaneElement self, SoState state)"""
        return _coin.SoClipPlaneElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoClipPlaneElement self, SoState state)"""
        return _coin.SoClipPlaneElement_push(self, state)

    @staticmethod
    def add(state: "SoState", node: "SoNode", plane: "SbPlane") -> "void":
        r"""add(SoState state, SoNode node, SbPlane plane)"""
        return _coin.SoClipPlaneElement_add(state, node, plane)

    @staticmethod
    def getInstance(state: "SoState") -> "SoClipPlaneElement const *":
        r"""getInstance(SoState state) -> SoClipPlaneElement"""
        return _coin.SoClipPlaneElement_getInstance(state)

    def getNum(self) -> "int":
        r"""getNum(SoClipPlaneElement self) -> int"""
        return _coin.SoClipPlaneElement_getNum(self)

    def get(self, index: "int const", inworldspace: "SbBool const"=1) -> "SbPlane const &":
        r"""get(SoClipPlaneElement self, int const index, SbBool const inworldspace=1) -> SbPlane"""
        return _coin.SoClipPlaneElement_get(self, index, inworldspace)

# Register SoClipPlaneElement in _coin:
_coin.SoClipPlaneElement_swigregister(SoClipPlaneElement)

def SoClipPlaneElement_getClassTypeId() -> "SoType":
    r"""SoClipPlaneElement_getClassTypeId() -> SoType"""
    return _coin.SoClipPlaneElement_getClassTypeId()

def SoClipPlaneElement_getClassStackIndex() -> "int":
    r"""SoClipPlaneElement_getClassStackIndex() -> int"""
    return _coin.SoClipPlaneElement_getClassStackIndex()

def SoClipPlaneElement_createInstance() -> "void *":
    r"""SoClipPlaneElement_createInstance() -> void *"""
    return _coin.SoClipPlaneElement_createInstance()

def SoClipPlaneElement_initClass() -> "void":
    r"""SoClipPlaneElement_initClass()"""
    return _coin.SoClipPlaneElement_initClass()

def SoClipPlaneElement_add(state: "SoState", node: "SoNode", plane: "SbPlane") -> "void":
    r"""SoClipPlaneElement_add(SoState state, SoNode node, SbPlane plane)"""
    return _coin.SoClipPlaneElement_add(state, node, plane)

def SoClipPlaneElement_getInstance(state: "SoState") -> "SoClipPlaneElement const *":
    r"""SoClipPlaneElement_getInstance(SoState state) -> SoClipPlaneElement"""
    return _coin.SoClipPlaneElement_getInstance(state)

class SoFloatElement(SoElement):
    r"""Proxy of C++ SoFloatElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFloatElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoFloatElement_getClassStackIndex()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFloatElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoFloatElement self, SoState state)"""
        return _coin.SoFloatElement_init(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoFloatElement self, SoElement element) -> SbBool"""
        return _coin.SoFloatElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoFloatElement self) -> SoElement"""
        return _coin.SoFloatElement_copyMatchInfo(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoFloatElement self, FILE * file)"""
        return _coin.SoFloatElement_output(self, file)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(int const stackIndex, SoState state, SoNode node, float const value)
        set(int const stackIndex, SoState state, float const value)
        """
        return _coin.SoFloatElement_set(*args)

    @staticmethod
    def get(stackIndex: "int const", state: "SoState") -> "float":
        r"""get(int const stackIndex, SoState state) -> float"""
        return _coin.SoFloatElement_get(stackIndex, state)

    def setElt(self, value: "float") -> "void":
        r"""setElt(SoFloatElement self, float value)"""
        return _coin.SoFloatElement_setElt(self, value)

# Register SoFloatElement in _coin:
_coin.SoFloatElement_swigregister(SoFloatElement)

def SoFloatElement_getClassTypeId() -> "SoType":
    r"""SoFloatElement_getClassTypeId() -> SoType"""
    return _coin.SoFloatElement_getClassTypeId()

def SoFloatElement_getClassStackIndex() -> "int":
    r"""SoFloatElement_getClassStackIndex() -> int"""
    return _coin.SoFloatElement_getClassStackIndex()

def SoFloatElement_initClass() -> "void":
    r"""SoFloatElement_initClass()"""
    return _coin.SoFloatElement_initClass()

def SoFloatElement_set(*args) -> "void":
    r"""
    SoFloatElement_set(int const stackIndex, SoState state, SoNode node, float const value)
    SoFloatElement_set(int const stackIndex, SoState state, float const value)
    """
    return _coin.SoFloatElement_set(*args)

def SoFloatElement_get(stackIndex: "int const", state: "SoState") -> "float":
    r"""SoFloatElement_get(int const stackIndex, SoState state) -> float"""
    return _coin.SoFloatElement_get(stackIndex, state)

class SoComplexityElement(SoFloatElement):
    r"""Proxy of C++ SoComplexityElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComplexityElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoComplexityElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComplexityElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComplexityElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoComplexityElement self, SoState state)"""
        return _coin.SoComplexityElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoComplexityElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoComplexityElement_get(state)

    @staticmethod
    def getDefault() -> "float":
        r"""getDefault() -> float"""
        return _coin.SoComplexityElement_getDefault()

# Register SoComplexityElement in _coin:
_coin.SoComplexityElement_swigregister(SoComplexityElement)

def SoComplexityElement_getClassTypeId() -> "SoType":
    r"""SoComplexityElement_getClassTypeId() -> SoType"""
    return _coin.SoComplexityElement_getClassTypeId()

def SoComplexityElement_getClassStackIndex() -> "int":
    r"""SoComplexityElement_getClassStackIndex() -> int"""
    return _coin.SoComplexityElement_getClassStackIndex()

def SoComplexityElement_createInstance() -> "void *":
    r"""SoComplexityElement_createInstance() -> void *"""
    return _coin.SoComplexityElement_createInstance()

def SoComplexityElement_initClass() -> "void":
    r"""SoComplexityElement_initClass()"""
    return _coin.SoComplexityElement_initClass()

def SoComplexityElement_set(*args) -> "void":
    r"""
    SoComplexityElement_set(SoState state, SoNode node, float const complexity)
    SoComplexityElement_set(SoState state, float const complexity)
    """
    return _coin.SoComplexityElement_set(*args)

def SoComplexityElement_get(state: "SoState") -> "float":
    r"""SoComplexityElement_get(SoState state) -> float"""
    return _coin.SoComplexityElement_get(state)

def SoComplexityElement_getDefault() -> "float":
    r"""SoComplexityElement_getDefault() -> float"""
    return _coin.SoComplexityElement_getDefault()

class SoCoordinateElement(SoReplacedElement):
    r"""Proxy of C++ SoCoordinateElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoCoordinateElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCoordinateElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoCoordinateElement self, SoState state)"""
        return _coin.SoCoordinateElement_init(self, state)

    @staticmethod
    def set3(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec3f") -> "void":
        r"""set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoCoordinateElement_set3(state, node, numCoords, coords)

    @staticmethod
    def set4(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec4f") -> "void":
        r"""set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
        return _coin.SoCoordinateElement_set4(state, node, numCoords, coords)

    @staticmethod
    def getInstance(state: "SoState") -> "SoCoordinateElement const *":
        r"""getInstance(SoState state) -> SoCoordinateElement"""
        return _coin.SoCoordinateElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoCoordinateElement self) -> int32_t"""
        return _coin.SoCoordinateElement_getNum(self)

    def is3D(self) -> "SbBool":
        r"""is3D(SoCoordinateElement self) -> SbBool"""
        return _coin.SoCoordinateElement_is3D(self)

    def get3(self, index: "int const") -> "SbVec3f const &":
        r"""get3(SoCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoCoordinateElement_get3(self, index)

    def get4(self, index: "int const") -> "SbVec4f const &":
        r"""get4(SoCoordinateElement self, int const index) -> SbVec4f"""
        return _coin.SoCoordinateElement_get4(self, index)

    def getArrayPtr3(self) -> "SbVec3f const *":
        r"""getArrayPtr3(SoCoordinateElement self) -> SbVec3f"""
        return _coin.SoCoordinateElement_getArrayPtr3(self)

    def getArrayPtr4(self) -> "SbVec4f const *":
        r"""getArrayPtr4(SoCoordinateElement self) -> SbVec4f"""
        return _coin.SoCoordinateElement_getArrayPtr4(self)

    @staticmethod
    def getDefault3() -> "SbVec3f":
        r"""getDefault3() -> SbVec3f"""
        return _coin.SoCoordinateElement_getDefault3()

    @staticmethod
    def getDefault4() -> "SbVec4f":
        r"""getDefault4() -> SbVec4f"""
        return _coin.SoCoordinateElement_getDefault4()

    def output(self, file: "FILE *") -> "void":
        r"""output(SoCoordinateElement self, FILE * file)"""
        return _coin.SoCoordinateElement_output(self, file)

# Register SoCoordinateElement in _coin:
_coin.SoCoordinateElement_swigregister(SoCoordinateElement)

def SoCoordinateElement_getClassTypeId() -> "SoType":
    r"""SoCoordinateElement_getClassTypeId() -> SoType"""
    return _coin.SoCoordinateElement_getClassTypeId()

def SoCoordinateElement_getClassStackIndex() -> "int":
    r"""SoCoordinateElement_getClassStackIndex() -> int"""
    return _coin.SoCoordinateElement_getClassStackIndex()

def SoCoordinateElement_createInstance() -> "void *":
    r"""SoCoordinateElement_createInstance() -> void *"""
    return _coin.SoCoordinateElement_createInstance()

def SoCoordinateElement_initClass() -> "void":
    r"""SoCoordinateElement_initClass()"""
    return _coin.SoCoordinateElement_initClass()

def SoCoordinateElement_set3(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec3f") -> "void":
    r"""SoCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
    return _coin.SoCoordinateElement_set3(state, node, numCoords, coords)

def SoCoordinateElement_set4(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec4f") -> "void":
    r"""SoCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
    return _coin.SoCoordinateElement_set4(state, node, numCoords, coords)

def SoCoordinateElement_getInstance(state: "SoState") -> "SoCoordinateElement const *":
    r"""SoCoordinateElement_getInstance(SoState state) -> SoCoordinateElement"""
    return _coin.SoCoordinateElement_getInstance(state)

def SoCoordinateElement_getDefault3() -> "SbVec3f":
    r"""SoCoordinateElement_getDefault3() -> SbVec3f"""
    return _coin.SoCoordinateElement_getDefault3()

def SoCoordinateElement_getDefault4() -> "SbVec4f":
    r"""SoCoordinateElement_getDefault4() -> SbVec4f"""
    return _coin.SoCoordinateElement_getDefault4()

class SoCreaseAngleElement(SoFloatElement):
    r"""Proxy of C++ SoCreaseAngleElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCreaseAngleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoCreaseAngleElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoCreaseAngleElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCreaseAngleElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoCreaseAngleElement self, SoState state)"""
        return _coin.SoCreaseAngleElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoCreaseAngleElement_set(*args)

    @staticmethod
    def get(*args) -> "float":
        r"""
        get(SoState state) -> float
        get(SoState state, SbBool const isvrml1) -> float
        """
        return _coin.SoCreaseAngleElement_get(*args)

    @staticmethod
    def getDefault(*args) -> "float":
        r"""
        getDefault() -> float
        getDefault(SbBool const isvrml1) -> float
        """
        return _coin.SoCreaseAngleElement_getDefault(*args)

# Register SoCreaseAngleElement in _coin:
_coin.SoCreaseAngleElement_swigregister(SoCreaseAngleElement)

def SoCreaseAngleElement_getClassTypeId() -> "SoType":
    r"""SoCreaseAngleElement_getClassTypeId() -> SoType"""
    return _coin.SoCreaseAngleElement_getClassTypeId()

def SoCreaseAngleElement_getClassStackIndex() -> "int":
    r"""SoCreaseAngleElement_getClassStackIndex() -> int"""
    return _coin.SoCreaseAngleElement_getClassStackIndex()

def SoCreaseAngleElement_createInstance() -> "void *":
    r"""SoCreaseAngleElement_createInstance() -> void *"""
    return _coin.SoCreaseAngleElement_createInstance()

def SoCreaseAngleElement_initClass() -> "void":
    r"""SoCreaseAngleElement_initClass()"""
    return _coin.SoCreaseAngleElement_initClass()

def SoCreaseAngleElement_set(*args) -> "void":
    r"""
    SoCreaseAngleElement_set(SoState state, SoNode node, float const complexity)
    SoCreaseAngleElement_set(SoState state, float const complexity)
    """
    return _coin.SoCreaseAngleElement_set(*args)

def SoCreaseAngleElement_get(*args) -> "float":
    r"""
    SoCreaseAngleElement_get(SoState state) -> float
    SoCreaseAngleElement_get(SoState state, SbBool const isvrml1) -> float
    """
    return _coin.SoCreaseAngleElement_get(*args)

def SoCreaseAngleElement_getDefault(*args) -> "float":
    r"""
    SoCreaseAngleElement_getDefault() -> float
    SoCreaseAngleElement_getDefault(SbBool const isvrml1) -> float
    """
    return _coin.SoCreaseAngleElement_getDefault(*args)

class SoCullElement(SoElement):
    r"""Proxy of C++ SoCullElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCullElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoCullElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoCullElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCullElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoCullElement self, SoState state)"""
        return _coin.SoCullElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoCullElement self, SoState state)"""
        return _coin.SoCullElement_push(self, state)

    @staticmethod
    def setViewVolume(state: "SoState", vv: "SbViewVolume") -> "void":
        r"""setViewVolume(SoState state, SbViewVolume vv)"""
        return _coin.SoCullElement_setViewVolume(state, vv)

    @staticmethod
    def addPlane(state: "SoState", newplane: "SbPlane") -> "void":
        r"""addPlane(SoState state, SbPlane newplane)"""
        return _coin.SoCullElement_addPlane(state, newplane)

    @staticmethod
    def cullBox(state: "SoState", box: "SbBox3f", transform: "SbBool const"=1) -> "SbBool":
        r"""cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"""
        return _coin.SoCullElement_cullBox(state, box, transform)

    @staticmethod
    def cullTest(state: "SoState", box: "SbBox3f", transform: "SbBool const"=1) -> "SbBool":
        r"""cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"""
        return _coin.SoCullElement_cullTest(state, box, transform)

    @staticmethod
    def completelyInside(state: "SoState") -> "SbBool":
        r"""completelyInside(SoState state) -> SbBool"""
        return _coin.SoCullElement_completelyInside(state)

    def matches(self, elt: "SoElement") -> "SbBool":
        r"""matches(SoCullElement self, SoElement elt) -> SbBool"""
        return _coin.SoCullElement_matches(self, elt)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoCullElement self) -> SoElement"""
        return _coin.SoCullElement_copyMatchInfo(self)

# Register SoCullElement in _coin:
_coin.SoCullElement_swigregister(SoCullElement)

def SoCullElement_getClassTypeId() -> "SoType":
    r"""SoCullElement_getClassTypeId() -> SoType"""
    return _coin.SoCullElement_getClassTypeId()

def SoCullElement_getClassStackIndex() -> "int":
    r"""SoCullElement_getClassStackIndex() -> int"""
    return _coin.SoCullElement_getClassStackIndex()

def SoCullElement_createInstance() -> "void *":
    r"""SoCullElement_createInstance() -> void *"""
    return _coin.SoCullElement_createInstance()

def SoCullElement_initClass() -> "void":
    r"""SoCullElement_initClass()"""
    return _coin.SoCullElement_initClass()

def SoCullElement_setViewVolume(state: "SoState", vv: "SbViewVolume") -> "void":
    r"""SoCullElement_setViewVolume(SoState state, SbViewVolume vv)"""
    return _coin.SoCullElement_setViewVolume(state, vv)

def SoCullElement_addPlane(state: "SoState", newplane: "SbPlane") -> "void":
    r"""SoCullElement_addPlane(SoState state, SbPlane newplane)"""
    return _coin.SoCullElement_addPlane(state, newplane)

def SoCullElement_cullBox(state: "SoState", box: "SbBox3f", transform: "SbBool const"=1) -> "SbBool":
    r"""SoCullElement_cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"""
    return _coin.SoCullElement_cullBox(state, box, transform)

def SoCullElement_cullTest(state: "SoState", box: "SbBox3f", transform: "SbBool const"=1) -> "SbBool":
    r"""SoCullElement_cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"""
    return _coin.SoCullElement_cullTest(state, box, transform)

def SoCullElement_completelyInside(state: "SoState") -> "SbBool":
    r"""SoCullElement_completelyInside(SoState state) -> SbBool"""
    return _coin.SoCullElement_completelyInside(state)

class SoDecimationPercentageElement(SoFloatElement):
    r"""Proxy of C++ SoDecimationPercentageElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecimationPercentageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoDecimationPercentageElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDecimationPercentageElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDecimationPercentageElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoDecimationPercentageElement self, SoState state)"""
        return _coin.SoDecimationPercentageElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoDecimationPercentageElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoDecimationPercentageElement_get(state)

    @staticmethod
    def getDefault() -> "float":
        r"""getDefault() -> float"""
        return _coin.SoDecimationPercentageElement_getDefault()

# Register SoDecimationPercentageElement in _coin:
_coin.SoDecimationPercentageElement_swigregister(SoDecimationPercentageElement)

def SoDecimationPercentageElement_getClassTypeId() -> "SoType":
    r"""SoDecimationPercentageElement_getClassTypeId() -> SoType"""
    return _coin.SoDecimationPercentageElement_getClassTypeId()

def SoDecimationPercentageElement_getClassStackIndex() -> "int":
    r"""SoDecimationPercentageElement_getClassStackIndex() -> int"""
    return _coin.SoDecimationPercentageElement_getClassStackIndex()

def SoDecimationPercentageElement_createInstance() -> "void *":
    r"""SoDecimationPercentageElement_createInstance() -> void *"""
    return _coin.SoDecimationPercentageElement_createInstance()

def SoDecimationPercentageElement_initClass() -> "void":
    r"""SoDecimationPercentageElement_initClass()"""
    return _coin.SoDecimationPercentageElement_initClass()

def SoDecimationPercentageElement_set(*args) -> "void":
    r"""
    SoDecimationPercentageElement_set(SoState state, SoNode node, float const complexity)
    SoDecimationPercentageElement_set(SoState state, float const complexity)
    """
    return _coin.SoDecimationPercentageElement_set(*args)

def SoDecimationPercentageElement_get(state: "SoState") -> "float":
    r"""SoDecimationPercentageElement_get(SoState state) -> float"""
    return _coin.SoDecimationPercentageElement_get(state)

def SoDecimationPercentageElement_getDefault() -> "float":
    r"""SoDecimationPercentageElement_getDefault() -> float"""
    return _coin.SoDecimationPercentageElement_getDefault()

class SoDiffuseColorElement(SoReplacedElement):
    r"""Proxy of C++ SoDiffuseColorElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDiffuseColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoDiffuseColorElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDiffuseColorElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDiffuseColorElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoDiffuseColorElement self, SoState state)"""
        return _coin.SoDiffuseColorElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numcolors: "int32_t const", colors: "SbColor") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoDiffuseColorElement_set(state, node, numcolors, colors)

    @staticmethod
    def getInstance(state: "SoState") -> "SoDiffuseColorElement const *":
        r"""getInstance(SoState state) -> SoDiffuseColorElement"""
        return _coin.SoDiffuseColorElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoDiffuseColorElement self) -> int32_t"""
        return _coin.SoDiffuseColorElement_getNum(self)

    def get(self, index: "int const") -> "SbColor const &":
        r"""get(SoDiffuseColorElement self, int const index) -> SbColor"""
        return _coin.SoDiffuseColorElement_get(self, index)

    def isPacked(self) -> "SbBool":
        r"""isPacked(SoDiffuseColorElement self) -> SbBool"""
        return _coin.SoDiffuseColorElement_isPacked(self)

    def hasPackedTransparency(self) -> "SbBool":
        r"""hasPackedTransparency(SoDiffuseColorElement self) -> SbBool"""
        return _coin.SoDiffuseColorElement_hasPackedTransparency(self)

    def getColorArrayPtr(self) -> "SbColor const *":
        r"""getColorArrayPtr(SoDiffuseColorElement self) -> SbColor"""
        return _coin.SoDiffuseColorElement_getColorArrayPtr(self)

    def getPackedArrayPtr(self) -> "uint32_t const *":
        r"""getPackedArrayPtr(SoDiffuseColorElement self) -> uint32_t const *"""
        return _coin.SoDiffuseColorElement_getPackedArrayPtr(self)

# Register SoDiffuseColorElement in _coin:
_coin.SoDiffuseColorElement_swigregister(SoDiffuseColorElement)

def SoDiffuseColorElement_getClassTypeId() -> "SoType":
    r"""SoDiffuseColorElement_getClassTypeId() -> SoType"""
    return _coin.SoDiffuseColorElement_getClassTypeId()

def SoDiffuseColorElement_getClassStackIndex() -> "int":
    r"""SoDiffuseColorElement_getClassStackIndex() -> int"""
    return _coin.SoDiffuseColorElement_getClassStackIndex()

def SoDiffuseColorElement_createInstance() -> "void *":
    r"""SoDiffuseColorElement_createInstance() -> void *"""
    return _coin.SoDiffuseColorElement_createInstance()

def SoDiffuseColorElement_initClass() -> "void":
    r"""SoDiffuseColorElement_initClass()"""
    return _coin.SoDiffuseColorElement_initClass()

def SoDiffuseColorElement_set(state: "SoState", node: "SoNode", numcolors: "int32_t const", colors: "SbColor") -> "void":
    r"""SoDiffuseColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
    return _coin.SoDiffuseColorElement_set(state, node, numcolors, colors)

def SoDiffuseColorElement_getInstance(state: "SoState") -> "SoDiffuseColorElement const *":
    r"""SoDiffuseColorElement_getInstance(SoState state) -> SoDiffuseColorElement"""
    return _coin.SoDiffuseColorElement_getInstance(state)

class SoGLClipPlaneElement(SoClipPlaneElement):
    r"""Proxy of C++ SoGLClipPlaneElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLClipPlaneElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLClipPlaneElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLClipPlaneElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLClipPlaneElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLClipPlaneElement self, SoState state)"""
        return _coin.SoGLClipPlaneElement_init(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLClipPlaneElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLClipPlaneElement_pop(self, state, prevTopElement)

    @staticmethod
    def getMaxGLPlanes() -> "int":
        r"""getMaxGLPlanes() -> int"""
        return _coin.SoGLClipPlaneElement_getMaxGLPlanes()

# Register SoGLClipPlaneElement in _coin:
_coin.SoGLClipPlaneElement_swigregister(SoGLClipPlaneElement)

def SoGLClipPlaneElement_getClassTypeId() -> "SoType":
    r"""SoGLClipPlaneElement_getClassTypeId() -> SoType"""
    return _coin.SoGLClipPlaneElement_getClassTypeId()

def SoGLClipPlaneElement_getClassStackIndex() -> "int":
    r"""SoGLClipPlaneElement_getClassStackIndex() -> int"""
    return _coin.SoGLClipPlaneElement_getClassStackIndex()

def SoGLClipPlaneElement_createInstance() -> "void *":
    r"""SoGLClipPlaneElement_createInstance() -> void *"""
    return _coin.SoGLClipPlaneElement_createInstance()

def SoGLClipPlaneElement_initClass() -> "void":
    r"""SoGLClipPlaneElement_initClass()"""
    return _coin.SoGLClipPlaneElement_initClass()

def SoGLClipPlaneElement_getMaxGLPlanes() -> "int":
    r"""SoGLClipPlaneElement_getMaxGLPlanes() -> int"""
    return _coin.SoGLClipPlaneElement_getMaxGLPlanes()

class SoLightElement(SoAccumulatedElement):
    r"""Proxy of C++ SoLightElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoLightElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoLightElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLightElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoLightElement self, SoState state)"""
        return _coin.SoLightElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoLightElement self, SoState state)"""
        return _coin.SoLightElement_push(self, state)

    @staticmethod
    def add(state: "SoState", light: "SoLight") -> "SbMatrix &":
        r"""add(SoState state, SoLight light)"""
        return _coin.SoLightElement_add(state, light)

    @staticmethod
    def getLights(state: "SoState") -> "SoNodeList const &":
        r"""getLights(SoState state) -> SoNodeList"""
        return _coin.SoLightElement_getLights(state)

    @staticmethod
    def getMatrix(state: "SoState", index: "int const") -> "SbMatrix const &":
        r"""getMatrix(SoState state, int const index) -> SbMatrix"""
        return _coin.SoLightElement_getMatrix(state, index)

# Register SoLightElement in _coin:
_coin.SoLightElement_swigregister(SoLightElement)

def SoLightElement_getClassTypeId() -> "SoType":
    r"""SoLightElement_getClassTypeId() -> SoType"""
    return _coin.SoLightElement_getClassTypeId()

def SoLightElement_getClassStackIndex() -> "int":
    r"""SoLightElement_getClassStackIndex() -> int"""
    return _coin.SoLightElement_getClassStackIndex()

def SoLightElement_createInstance() -> "void *":
    r"""SoLightElement_createInstance() -> void *"""
    return _coin.SoLightElement_createInstance()

def SoLightElement_initClass() -> "void":
    r"""SoLightElement_initClass()"""
    return _coin.SoLightElement_initClass()

def SoLightElement_add(state: "SoState", light: "SoLight") -> "SbMatrix &":
    r"""SoLightElement_add(SoState state, SoLight light)"""
    return _coin.SoLightElement_add(state, light)

def SoLightElement_getLights(state: "SoState") -> "SoNodeList const &":
    r"""SoLightElement_getLights(SoState state) -> SoNodeList"""
    return _coin.SoLightElement_getLights(state)

def SoLightElement_getMatrix(state: "SoState", index: "int const") -> "SbMatrix const &":
    r"""SoLightElement_getMatrix(SoState state, int const index) -> SbMatrix"""
    return _coin.SoLightElement_getMatrix(state, index)

class SoGLModelMatrixElement(SoModelMatrixElement):
    r"""Proxy of C++ SoGLModelMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLModelMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLModelMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLModelMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLModelMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLModelMatrixElement self, SoState state)"""
        return _coin.SoGLModelMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLModelMatrixElement self, SoState state)"""
        return _coin.SoGLModelMatrixElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLModelMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLModelMatrixElement_pop(self, state, prevTopElement)

# Register SoGLModelMatrixElement in _coin:
_coin.SoGLModelMatrixElement_swigregister(SoGLModelMatrixElement)

def SoGLModelMatrixElement_getClassTypeId() -> "SoType":
    r"""SoGLModelMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoGLModelMatrixElement_getClassTypeId()

def SoGLModelMatrixElement_getClassStackIndex() -> "int":
    r"""SoGLModelMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoGLModelMatrixElement_getClassStackIndex()

def SoGLModelMatrixElement_createInstance() -> "void *":
    r"""SoGLModelMatrixElement_createInstance() -> void *"""
    return _coin.SoGLModelMatrixElement_createInstance()

def SoGLModelMatrixElement_initClass() -> "void":
    r"""SoGLModelMatrixElement_initClass()"""
    return _coin.SoGLModelMatrixElement_initClass()

class SoProfileElement(SoAccumulatedElement):
    r"""Proxy of C++ SoProfileElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoProfileElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoProfileElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProfileElement_initClass()
    START_FIRST = _coin.SoProfileElement_START_FIRST
    
    START_NEW = _coin.SoProfileElement_START_NEW
    
    ADD_TO_CURRENT = _coin.SoProfileElement_ADD_TO_CURRENT
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoProfileElement self, SoState state)"""
        return _coin.SoProfileElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoProfileElement self, SoState state)"""
        return _coin.SoProfileElement_push(self, state)

    @staticmethod
    def add(state: "SoState", profile: "SoProfile") -> "void":
        r"""add(SoState state, SoProfile profile)"""
        return _coin.SoProfileElement_add(state, profile)

    @staticmethod
    def get(state: "SoState") -> "SoNodeList const &":
        r"""get(SoState state) -> SoNodeList"""
        return _coin.SoProfileElement_get(state)

# Register SoProfileElement in _coin:
_coin.SoProfileElement_swigregister(SoProfileElement)

def SoProfileElement_getClassTypeId() -> "SoType":
    r"""SoProfileElement_getClassTypeId() -> SoType"""
    return _coin.SoProfileElement_getClassTypeId()

def SoProfileElement_getClassStackIndex() -> "int":
    r"""SoProfileElement_getClassStackIndex() -> int"""
    return _coin.SoProfileElement_getClassStackIndex()

def SoProfileElement_createInstance() -> "void *":
    r"""SoProfileElement_createInstance() -> void *"""
    return _coin.SoProfileElement_createInstance()

def SoProfileElement_initClass() -> "void":
    r"""SoProfileElement_initClass()"""
    return _coin.SoProfileElement_initClass()

def SoProfileElement_add(state: "SoState", profile: "SoProfile") -> "void":
    r"""SoProfileElement_add(SoState state, SoProfile profile)"""
    return _coin.SoProfileElement_add(state, profile)

def SoProfileElement_get(state: "SoState") -> "SoNodeList const &":
    r"""SoProfileElement_get(SoState state) -> SoNodeList"""
    return _coin.SoProfileElement_get(state)

class SoMultiTextureMatrixElement(SoAccumulatedElement):
    r"""Proxy of C++ SoMultiTextureMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMultiTextureMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_push(self, state)

    @staticmethod
    def get(state: "SoState", unit: "int const"=0) -> "SbMatrix const &":
        r"""get(SoState state, int const unit=0) -> SbMatrix"""
        return _coin.SoMultiTextureMatrixElement_get(state, unit)

    @staticmethod
    def makeIdentity(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
        r"""makeIdentity(SoState state, SoNode node, int const unit=0)"""
        return _coin.SoMultiTextureMatrixElement_makeIdentity(state, node, unit)

    @staticmethod
    def set(*args) -> "SbMatrix &":
        r"""
        set(SoState state, SoNode node, int const unit)
        set(SoState state, SoNode node)
        """
        return _coin.SoMultiTextureMatrixElement_set(*args)

    @staticmethod
    def mult(*args) -> "SbMatrix &":
        r"""
        mult(SoState state, SoNode node, int const unit)
        mult(SoState state, SoNode node)
        """
        return _coin.SoMultiTextureMatrixElement_mult(*args)

    @staticmethod
    def translateBy(state: "SoState", node: "SoNode", translation: "SbVec3f") -> "void":
        r"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoMultiTextureMatrixElement_translateBy(state, node, translation)

    @staticmethod
    def rotateBy(state: "SoState", node: "SoNode", rotation: "SbRotation") -> "void":
        r"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoMultiTextureMatrixElement_rotateBy(state, node, rotation)

    @staticmethod
    def scaleBy(state: "SoState", node: "SoNode", scaleFactor: "SbVec3f") -> "void":
        r"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoMultiTextureMatrixElement_scaleBy(state, node, scaleFactor)

# Register SoMultiTextureMatrixElement in _coin:
_coin.SoMultiTextureMatrixElement_swigregister(SoMultiTextureMatrixElement)

def SoMultiTextureMatrixElement_getClassTypeId() -> "SoType":
    r"""SoMultiTextureMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoMultiTextureMatrixElement_getClassTypeId()

def SoMultiTextureMatrixElement_getClassStackIndex() -> "int":
    r"""SoMultiTextureMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoMultiTextureMatrixElement_getClassStackIndex()

def SoMultiTextureMatrixElement_createInstance() -> "void *":
    r"""SoMultiTextureMatrixElement_createInstance() -> void *"""
    return _coin.SoMultiTextureMatrixElement_createInstance()

def SoMultiTextureMatrixElement_initClass() -> "void":
    r"""SoMultiTextureMatrixElement_initClass()"""
    return _coin.SoMultiTextureMatrixElement_initClass()

def SoMultiTextureMatrixElement_get(state: "SoState", unit: "int const"=0) -> "SbMatrix const &":
    r"""SoMultiTextureMatrixElement_get(SoState state, int const unit=0) -> SbMatrix"""
    return _coin.SoMultiTextureMatrixElement_get(state, unit)

def SoMultiTextureMatrixElement_makeIdentity(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
    r"""SoMultiTextureMatrixElement_makeIdentity(SoState state, SoNode node, int const unit=0)"""
    return _coin.SoMultiTextureMatrixElement_makeIdentity(state, node, unit)

def SoMultiTextureMatrixElement_set(*args) -> "SbMatrix &":
    r"""
    SoMultiTextureMatrixElement_set(SoState state, SoNode node, int const unit)
    SoMultiTextureMatrixElement_set(SoState state, SoNode node)
    """
    return _coin.SoMultiTextureMatrixElement_set(*args)

def SoMultiTextureMatrixElement_mult(*args) -> "SbMatrix &":
    r"""
    SoMultiTextureMatrixElement_mult(SoState state, SoNode node, int const unit)
    SoMultiTextureMatrixElement_mult(SoState state, SoNode node)
    """
    return _coin.SoMultiTextureMatrixElement_mult(*args)

def SoMultiTextureMatrixElement_translateBy(state: "SoState", node: "SoNode", translation: "SbVec3f") -> "void":
    r"""SoMultiTextureMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
    return _coin.SoMultiTextureMatrixElement_translateBy(state, node, translation)

def SoMultiTextureMatrixElement_rotateBy(state: "SoState", node: "SoNode", rotation: "SbRotation") -> "void":
    r"""SoMultiTextureMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
    return _coin.SoMultiTextureMatrixElement_rotateBy(state, node, rotation)

def SoMultiTextureMatrixElement_scaleBy(state: "SoState", node: "SoNode", scaleFactor: "SbVec3f") -> "void":
    r"""SoMultiTextureMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
    return _coin.SoMultiTextureMatrixElement_scaleBy(state, node, scaleFactor)

class SoGLMultiTextureMatrixElement(SoMultiTextureMatrixElement):
    r"""Proxy of C++ SoGLMultiTextureMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLMultiTextureMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLMultiTextureMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureMatrixElement_pop(self, state, prevTopElement)

    def multElt(self, unit: "int const") -> "void":
        r"""multElt(SoGLMultiTextureMatrixElement self, int const unit)"""
        return _coin.SoGLMultiTextureMatrixElement_multElt(self, unit)

    def setElt(self, unit: "int const") -> "void":
        r"""setElt(SoGLMultiTextureMatrixElement self, int const unit)"""
        return _coin.SoGLMultiTextureMatrixElement_setElt(self, unit)

# Register SoGLMultiTextureMatrixElement in _coin:
_coin.SoGLMultiTextureMatrixElement_swigregister(SoGLMultiTextureMatrixElement)

def SoGLMultiTextureMatrixElement_getClassTypeId() -> "SoType":
    r"""SoGLMultiTextureMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoGLMultiTextureMatrixElement_getClassTypeId()

def SoGLMultiTextureMatrixElement_getClassStackIndex() -> "int":
    r"""SoGLMultiTextureMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoGLMultiTextureMatrixElement_getClassStackIndex()

def SoGLMultiTextureMatrixElement_createInstance() -> "void *":
    r"""SoGLMultiTextureMatrixElement_createInstance() -> void *"""
    return _coin.SoGLMultiTextureMatrixElement_createInstance()

def SoGLMultiTextureMatrixElement_initClass() -> "void":
    r"""SoGLMultiTextureMatrixElement_initClass()"""
    return _coin.SoGLMultiTextureMatrixElement_initClass()

class SoGLDrawStyleElement(SoDrawStyleElement):
    r"""Proxy of C++ SoGLDrawStyleElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLDrawStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLDrawStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLDrawStyleElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLDrawStyleElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLDrawStyleElement self, SoState state)"""
        return _coin.SoGLDrawStyleElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLDrawStyleElement self, SoState state)"""
        return _coin.SoGLDrawStyleElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLDrawStyleElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDrawStyleElement_pop(self, state, prevTopElement)

# Register SoGLDrawStyleElement in _coin:
_coin.SoGLDrawStyleElement_swigregister(SoGLDrawStyleElement)

def SoGLDrawStyleElement_getClassTypeId() -> "SoType":
    r"""SoGLDrawStyleElement_getClassTypeId() -> SoType"""
    return _coin.SoGLDrawStyleElement_getClassTypeId()

def SoGLDrawStyleElement_getClassStackIndex() -> "int":
    r"""SoGLDrawStyleElement_getClassStackIndex() -> int"""
    return _coin.SoGLDrawStyleElement_getClassStackIndex()

def SoGLDrawStyleElement_createInstance() -> "void *":
    r"""SoGLDrawStyleElement_createInstance() -> void *"""
    return _coin.SoGLDrawStyleElement_createInstance()

def SoGLDrawStyleElement_initClass() -> "void":
    r"""SoGLDrawStyleElement_initClass()"""
    return _coin.SoGLDrawStyleElement_initClass()

class SoGLLightIdElement(SoInt32Element):
    r"""Proxy of C++ SoGLLightIdElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLightIdElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLightIdElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLLightIdElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLLightIdElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLLightIdElement self, SoState state)"""
        return _coin.SoGLLightIdElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLLightIdElement self, SoState state)"""
        return _coin.SoGLLightIdElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLLightIdElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLightIdElement_pop(self, state, prevTopElement)

    @staticmethod
    def increment(*args) -> "int32_t":
        r"""
        increment(SoState state, SoNode node) -> int32_t
        increment(SoState state) -> int32_t
        """
        return _coin.SoGLLightIdElement_increment(*args)

    @staticmethod
    def get(state: "SoState") -> "int32_t":
        r"""get(SoState state) -> int32_t"""
        return _coin.SoGLLightIdElement_get(state)

    @staticmethod
    def getDefault() -> "int32_t":
        r"""getDefault() -> int32_t"""
        return _coin.SoGLLightIdElement_getDefault()

    @staticmethod
    def getMaxGLSources() -> "int32_t":
        r"""getMaxGLSources() -> int32_t"""
        return _coin.SoGLLightIdElement_getMaxGLSources()

# Register SoGLLightIdElement in _coin:
_coin.SoGLLightIdElement_swigregister(SoGLLightIdElement)

def SoGLLightIdElement_getClassTypeId() -> "SoType":
    r"""SoGLLightIdElement_getClassTypeId() -> SoType"""
    return _coin.SoGLLightIdElement_getClassTypeId()

def SoGLLightIdElement_getClassStackIndex() -> "int":
    r"""SoGLLightIdElement_getClassStackIndex() -> int"""
    return _coin.SoGLLightIdElement_getClassStackIndex()

def SoGLLightIdElement_createInstance() -> "void *":
    r"""SoGLLightIdElement_createInstance() -> void *"""
    return _coin.SoGLLightIdElement_createInstance()

def SoGLLightIdElement_initClass() -> "void":
    r"""SoGLLightIdElement_initClass()"""
    return _coin.SoGLLightIdElement_initClass()

def SoGLLightIdElement_increment(*args) -> "int32_t":
    r"""
    SoGLLightIdElement_increment(SoState state, SoNode node) -> int32_t
    SoGLLightIdElement_increment(SoState state) -> int32_t
    """
    return _coin.SoGLLightIdElement_increment(*args)

def SoGLLightIdElement_get(state: "SoState") -> "int32_t":
    r"""SoGLLightIdElement_get(SoState state) -> int32_t"""
    return _coin.SoGLLightIdElement_get(state)

def SoGLLightIdElement_getDefault() -> "int32_t":
    r"""SoGLLightIdElement_getDefault() -> int32_t"""
    return _coin.SoGLLightIdElement_getDefault()

def SoGLLightIdElement_getMaxGLSources() -> "int32_t":
    r"""SoGLLightIdElement_getMaxGLSources() -> int32_t"""
    return _coin.SoGLLightIdElement_getMaxGLSources()

class SoMultiTextureEnabledElement(SoElement):
    r"""Proxy of C++ SoMultiTextureEnabledElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureEnabledElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMultiTextureEnabledElement_initClass()
    DISABLED = _coin.SoMultiTextureEnabledElement_DISABLED
    
    TEXTURE2D = _coin.SoMultiTextureEnabledElement_TEXTURE2D
    
    RECTANGLE = _coin.SoMultiTextureEnabledElement_RECTANGLE
    
    CUBEMAP = _coin.SoMultiTextureEnabledElement_CUBEMAP
    
    TEXTURE3D = _coin.SoMultiTextureEnabledElement_TEXTURE3D
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_init(self, state)

    @staticmethod
    def get(state: "SoState", unit: "int const"=0) -> "SbBool":
        r"""get(SoState state, int const unit=0) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_get(state, unit)

    def setElt(self, unit: "int const", mode: "int const") -> "void":
        r"""setElt(SoMultiTextureEnabledElement self, int const unit, int const mode)"""
        return _coin.SoMultiTextureEnabledElement_setElt(self, unit, mode)

    def push(self, state: "SoState") -> "void":
        r"""push(SoMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_push(self, state)

    def matches(self, elem: "SoElement") -> "SbBool":
        r"""matches(SoMultiTextureEnabledElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_matches(self, elem)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoMultiTextureEnabledElement self) -> SoElement"""
        return _coin.SoMultiTextureEnabledElement_copyMatchInfo(self)

    @staticmethod
    def getEnabledUnits(state: "SoState", lastenabled: "int &") -> "SbBool const *":
        r"""getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"""
        return _coin.SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled)

    @staticmethod
    def getActiveUnits(state: "SoState", lastenabled: "int &") -> "SoMultiTextureEnabledElement::Mode const *":
        r"""getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"""
        return _coin.SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled)

    @staticmethod
    def enableRectangle(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
        r"""enableRectangle(SoState state, SoNode node, int const unit=0)"""
        return _coin.SoMultiTextureEnabledElement_enableRectangle(state, node, unit)

    @staticmethod
    def enableCubeMap(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
        r"""enableCubeMap(SoState state, SoNode node, int const unit=0)"""
        return _coin.SoMultiTextureEnabledElement_enableCubeMap(state, node, unit)

    @staticmethod
    def enableTexture3(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
        r"""enableTexture3(SoState state, SoNode node, int const unit=0)"""
        return _coin.SoMultiTextureEnabledElement_enableTexture3(state, node, unit)

    @staticmethod
    def getMode(state: "SoState", unit: "int const"=0) -> "SoMultiTextureEnabledElement::Mode":
        r"""getMode(SoState state, int const unit=0) -> SoMultiTextureEnabledElement::Mode"""
        return _coin.SoMultiTextureEnabledElement_getMode(state, unit)

    @staticmethod
    def disableAll(state: "SoState") -> "void":
        r"""disableAll(SoState state)"""
        return _coin.SoMultiTextureEnabledElement_disableAll(state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, int const unit, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        set(SoState state, SoNode node, SbBool const enabled)
        """
        return _coin.SoMultiTextureEnabledElement_set(*args)

# Register SoMultiTextureEnabledElement in _coin:
_coin.SoMultiTextureEnabledElement_swigregister(SoMultiTextureEnabledElement)

def SoMultiTextureEnabledElement_getClassTypeId() -> "SoType":
    r"""SoMultiTextureEnabledElement_getClassTypeId() -> SoType"""
    return _coin.SoMultiTextureEnabledElement_getClassTypeId()

def SoMultiTextureEnabledElement_getClassStackIndex() -> "int":
    r"""SoMultiTextureEnabledElement_getClassStackIndex() -> int"""
    return _coin.SoMultiTextureEnabledElement_getClassStackIndex()

def SoMultiTextureEnabledElement_createInstance() -> "void *":
    r"""SoMultiTextureEnabledElement_createInstance() -> void *"""
    return _coin.SoMultiTextureEnabledElement_createInstance()

def SoMultiTextureEnabledElement_initClass() -> "void":
    r"""SoMultiTextureEnabledElement_initClass()"""
    return _coin.SoMultiTextureEnabledElement_initClass()

def SoMultiTextureEnabledElement_get(state: "SoState", unit: "int const"=0) -> "SbBool":
    r"""SoMultiTextureEnabledElement_get(SoState state, int const unit=0) -> SbBool"""
    return _coin.SoMultiTextureEnabledElement_get(state, unit)

def SoMultiTextureEnabledElement_getEnabledUnits(state: "SoState", lastenabled: "int &") -> "SbBool const *":
    r"""SoMultiTextureEnabledElement_getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"""
    return _coin.SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled)

def SoMultiTextureEnabledElement_getActiveUnits(state: "SoState", lastenabled: "int &") -> "SoMultiTextureEnabledElement::Mode const *":
    r"""SoMultiTextureEnabledElement_getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"""
    return _coin.SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled)

def SoMultiTextureEnabledElement_enableRectangle(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
    r"""SoMultiTextureEnabledElement_enableRectangle(SoState state, SoNode node, int const unit=0)"""
    return _coin.SoMultiTextureEnabledElement_enableRectangle(state, node, unit)

def SoMultiTextureEnabledElement_enableCubeMap(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
    r"""SoMultiTextureEnabledElement_enableCubeMap(SoState state, SoNode node, int const unit=0)"""
    return _coin.SoMultiTextureEnabledElement_enableCubeMap(state, node, unit)

def SoMultiTextureEnabledElement_enableTexture3(state: "SoState", node: "SoNode", unit: "int const"=0) -> "void":
    r"""SoMultiTextureEnabledElement_enableTexture3(SoState state, SoNode node, int const unit=0)"""
    return _coin.SoMultiTextureEnabledElement_enableTexture3(state, node, unit)

def SoMultiTextureEnabledElement_getMode(state: "SoState", unit: "int const"=0) -> "SoMultiTextureEnabledElement::Mode":
    r"""SoMultiTextureEnabledElement_getMode(SoState state, int const unit=0) -> SoMultiTextureEnabledElement::Mode"""
    return _coin.SoMultiTextureEnabledElement_getMode(state, unit)

def SoMultiTextureEnabledElement_disableAll(state: "SoState") -> "void":
    r"""SoMultiTextureEnabledElement_disableAll(SoState state)"""
    return _coin.SoMultiTextureEnabledElement_disableAll(state)

def SoMultiTextureEnabledElement_set(*args) -> "void":
    r"""
    SoMultiTextureEnabledElement_set(SoState state, SoNode node, int const unit, SbBool const enabled)
    SoMultiTextureEnabledElement_set(SoState state, SbBool const enabled)
    SoMultiTextureEnabledElement_set(SoState state, SoNode node, SbBool const enabled)
    """
    return _coin.SoMultiTextureEnabledElement_set(*args)

class SoGLMultiTextureEnabledElement(SoMultiTextureEnabledElement):
    r"""Proxy of C++ SoGLMultiTextureEnabledElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureEnabledElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLMultiTextureEnabledElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLMultiTextureEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureEnabledElement_pop(self, state, prevTopElement)

    def setElt(self, unit: "int const", mode: "int const") -> "void":
        r"""setElt(SoGLMultiTextureEnabledElement self, int const unit, int const mode)"""
        return _coin.SoGLMultiTextureEnabledElement_setElt(self, unit, mode)

# Register SoGLMultiTextureEnabledElement in _coin:
_coin.SoGLMultiTextureEnabledElement_swigregister(SoGLMultiTextureEnabledElement)

def SoGLMultiTextureEnabledElement_getClassTypeId() -> "SoType":
    r"""SoGLMultiTextureEnabledElement_getClassTypeId() -> SoType"""
    return _coin.SoGLMultiTextureEnabledElement_getClassTypeId()

def SoGLMultiTextureEnabledElement_getClassStackIndex() -> "int":
    r"""SoGLMultiTextureEnabledElement_getClassStackIndex() -> int"""
    return _coin.SoGLMultiTextureEnabledElement_getClassStackIndex()

def SoGLMultiTextureEnabledElement_createInstance() -> "void *":
    r"""SoGLMultiTextureEnabledElement_createInstance() -> void *"""
    return _coin.SoGLMultiTextureEnabledElement_createInstance()

def SoGLMultiTextureEnabledElement_initClass() -> "void":
    r"""SoGLMultiTextureEnabledElement_initClass()"""
    return _coin.SoGLMultiTextureEnabledElement_initClass()

class SoLinePatternElement(SoInt32Element):
    r"""Proxy of C++ SoLinePatternElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLinePatternElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoLinePatternElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoLinePatternElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLinePatternElement_initClass()
    CONTINUOUS = _coin.SoLinePatternElement_CONTINUOUS
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoLinePatternElement self, SoState state)"""
        return _coin.SoLinePatternElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, int32_t const pattern, int32_t const factor=1)
        set(SoState state, int32_t const pattern, int32_t const factor=1)
        """
        return _coin.SoLinePatternElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "int32_t":
        r"""get(SoState state) -> int32_t"""
        return _coin.SoLinePatternElement_get(state)

    @staticmethod
    def getDefault() -> "int32_t":
        r"""getDefault() -> int32_t"""
        return _coin.SoLinePatternElement_getDefault()

    @staticmethod
    def getScaleFactor(state: "SoState") -> "int32_t":
        r"""getScaleFactor(SoState state) -> int32_t"""
        return _coin.SoLinePatternElement_getScaleFactor(state)

    @staticmethod
    def getDefaultScaleFactor() -> "int32_t":
        r"""getDefaultScaleFactor() -> int32_t"""
        return _coin.SoLinePatternElement_getDefaultScaleFactor()

# Register SoLinePatternElement in _coin:
_coin.SoLinePatternElement_swigregister(SoLinePatternElement)

def SoLinePatternElement_getClassTypeId() -> "SoType":
    r"""SoLinePatternElement_getClassTypeId() -> SoType"""
    return _coin.SoLinePatternElement_getClassTypeId()

def SoLinePatternElement_getClassStackIndex() -> "int":
    r"""SoLinePatternElement_getClassStackIndex() -> int"""
    return _coin.SoLinePatternElement_getClassStackIndex()

def SoLinePatternElement_createInstance() -> "void *":
    r"""SoLinePatternElement_createInstance() -> void *"""
    return _coin.SoLinePatternElement_createInstance()

def SoLinePatternElement_initClass() -> "void":
    r"""SoLinePatternElement_initClass()"""
    return _coin.SoLinePatternElement_initClass()

def SoLinePatternElement_set(*args) -> "void":
    r"""
    SoLinePatternElement_set(SoState state, SoNode node, int32_t const pattern, int32_t const factor=1)
    SoLinePatternElement_set(SoState state, int32_t const pattern, int32_t const factor=1)
    """
    return _coin.SoLinePatternElement_set(*args)

def SoLinePatternElement_get(state: "SoState") -> "int32_t":
    r"""SoLinePatternElement_get(SoState state) -> int32_t"""
    return _coin.SoLinePatternElement_get(state)

def SoLinePatternElement_getDefault() -> "int32_t":
    r"""SoLinePatternElement_getDefault() -> int32_t"""
    return _coin.SoLinePatternElement_getDefault()

def SoLinePatternElement_getScaleFactor(state: "SoState") -> "int32_t":
    r"""SoLinePatternElement_getScaleFactor(SoState state) -> int32_t"""
    return _coin.SoLinePatternElement_getScaleFactor(state)

def SoLinePatternElement_getDefaultScaleFactor() -> "int32_t":
    r"""SoLinePatternElement_getDefaultScaleFactor() -> int32_t"""
    return _coin.SoLinePatternElement_getDefaultScaleFactor()

class SoGLLinePatternElement(SoLinePatternElement):
    r"""Proxy of C++ SoGLLinePatternElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLinePatternElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLinePatternElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLLinePatternElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLLinePatternElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLLinePatternElement self, SoState state)"""
        return _coin.SoGLLinePatternElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLLinePatternElement self, SoState state)"""
        return _coin.SoGLLinePatternElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLLinePatternElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLinePatternElement_pop(self, state, prevTopElement)

# Register SoGLLinePatternElement in _coin:
_coin.SoGLLinePatternElement_swigregister(SoGLLinePatternElement)

def SoGLLinePatternElement_getClassTypeId() -> "SoType":
    r"""SoGLLinePatternElement_getClassTypeId() -> SoType"""
    return _coin.SoGLLinePatternElement_getClassTypeId()

def SoGLLinePatternElement_getClassStackIndex() -> "int":
    r"""SoGLLinePatternElement_getClassStackIndex() -> int"""
    return _coin.SoGLLinePatternElement_getClassStackIndex()

def SoGLLinePatternElement_createInstance() -> "void *":
    r"""SoGLLinePatternElement_createInstance() -> void *"""
    return _coin.SoGLLinePatternElement_createInstance()

def SoGLLinePatternElement_initClass() -> "void":
    r"""SoGLLinePatternElement_initClass()"""
    return _coin.SoGLLinePatternElement_initClass()

class SoSwitchElement(SoInt32Element):
    r"""Proxy of C++ SoSwitchElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSwitchElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoSwitchElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSwitchElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSwitchElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoSwitchElement self, SoState state)"""
        return _coin.SoSwitchElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, int32_t const index)
        set(SoState state, int32_t const index)
        """
        return _coin.SoSwitchElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "int32_t":
        r"""get(SoState state) -> int32_t"""
        return _coin.SoSwitchElement_get(state)

    @staticmethod
    def getDefault() -> "int32_t":
        r"""getDefault() -> int32_t"""
        return _coin.SoSwitchElement_getDefault()

# Register SoSwitchElement in _coin:
_coin.SoSwitchElement_swigregister(SoSwitchElement)

def SoSwitchElement_getClassTypeId() -> "SoType":
    r"""SoSwitchElement_getClassTypeId() -> SoType"""
    return _coin.SoSwitchElement_getClassTypeId()

def SoSwitchElement_getClassStackIndex() -> "int":
    r"""SoSwitchElement_getClassStackIndex() -> int"""
    return _coin.SoSwitchElement_getClassStackIndex()

def SoSwitchElement_createInstance() -> "void *":
    r"""SoSwitchElement_createInstance() -> void *"""
    return _coin.SoSwitchElement_createInstance()

def SoSwitchElement_initClass() -> "void":
    r"""SoSwitchElement_initClass()"""
    return _coin.SoSwitchElement_initClass()

def SoSwitchElement_set(*args) -> "void":
    r"""
    SoSwitchElement_set(SoState state, SoNode node, int32_t const index)
    SoSwitchElement_set(SoState state, int32_t const index)
    """
    return _coin.SoSwitchElement_set(*args)

def SoSwitchElement_get(state: "SoState") -> "int32_t":
    r"""SoSwitchElement_get(SoState state) -> int32_t"""
    return _coin.SoSwitchElement_get(state)

def SoSwitchElement_getDefault() -> "int32_t":
    r"""SoSwitchElement_getDefault() -> int32_t"""
    return _coin.SoSwitchElement_getDefault()

class SoTextOutlineEnabledElement(SoInt32Element):
    r"""Proxy of C++ SoTextOutlineEnabledElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextOutlineEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextOutlineEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTextOutlineEnabledElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextOutlineEnabledElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoTextOutlineEnabledElement self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoTextOutlineEnabledElement self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoTextOutlineEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoTextOutlineEnabledElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        """
        return _coin.SoTextOutlineEnabledElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SbBool":
        r"""get(SoState state) -> SbBool"""
        return _coin.SoTextOutlineEnabledElement_get(state)

    @staticmethod
    def getDefault() -> "SbBool":
        r"""getDefault() -> SbBool"""
        return _coin.SoTextOutlineEnabledElement_getDefault()

# Register SoTextOutlineEnabledElement in _coin:
_coin.SoTextOutlineEnabledElement_swigregister(SoTextOutlineEnabledElement)

def SoTextOutlineEnabledElement_getClassTypeId() -> "SoType":
    r"""SoTextOutlineEnabledElement_getClassTypeId() -> SoType"""
    return _coin.SoTextOutlineEnabledElement_getClassTypeId()

def SoTextOutlineEnabledElement_getClassStackIndex() -> "int":
    r"""SoTextOutlineEnabledElement_getClassStackIndex() -> int"""
    return _coin.SoTextOutlineEnabledElement_getClassStackIndex()

def SoTextOutlineEnabledElement_createInstance() -> "void *":
    r"""SoTextOutlineEnabledElement_createInstance() -> void *"""
    return _coin.SoTextOutlineEnabledElement_createInstance()

def SoTextOutlineEnabledElement_initClass() -> "void":
    r"""SoTextOutlineEnabledElement_initClass()"""
    return _coin.SoTextOutlineEnabledElement_initClass()

def SoTextOutlineEnabledElement_set(*args) -> "void":
    r"""
    SoTextOutlineEnabledElement_set(SoState state, SoNode node, SbBool const enabled)
    SoTextOutlineEnabledElement_set(SoState state, SbBool const enabled)
    """
    return _coin.SoTextOutlineEnabledElement_set(*args)

def SoTextOutlineEnabledElement_get(state: "SoState") -> "SbBool":
    r"""SoTextOutlineEnabledElement_get(SoState state) -> SbBool"""
    return _coin.SoTextOutlineEnabledElement_get(state)

def SoTextOutlineEnabledElement_getDefault() -> "SbBool":
    r"""SoTextOutlineEnabledElement_getDefault() -> SbBool"""
    return _coin.SoTextOutlineEnabledElement_getDefault()

class SoUnitsElement(SoInt32Element):
    r"""Proxy of C++ SoUnitsElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoUnitsElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoUnitsElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoUnitsElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoUnitsElement_initClass()
    METERS = _coin.SoUnitsElement_METERS
    
    CENTIMETERS = _coin.SoUnitsElement_CENTIMETERS
    
    MILLIMETERS = _coin.SoUnitsElement_MILLIMETERS
    
    MICROMETERS = _coin.SoUnitsElement_MICROMETERS
    
    MICRONS = _coin.SoUnitsElement_MICRONS
    
    NANOMETERS = _coin.SoUnitsElement_NANOMETERS
    
    ANGSTROMS = _coin.SoUnitsElement_ANGSTROMS
    
    KILOMETERS = _coin.SoUnitsElement_KILOMETERS
    
    FEET = _coin.SoUnitsElement_FEET
    
    INCHES = _coin.SoUnitsElement_INCHES
    
    POINTS = _coin.SoUnitsElement_POINTS
    
    YARDS = _coin.SoUnitsElement_YARDS
    
    MILES = _coin.SoUnitsElement_MILES
    
    NAUTICAL_MILES = _coin.SoUnitsElement_NAUTICAL_MILES
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoUnitsElement self, SoState state)"""
        return _coin.SoUnitsElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoUnitsElement::Units const units)
        set(SoState state, SoUnitsElement::Units const units)
        """
        return _coin.SoUnitsElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoUnitsElement::Units":
        r"""get(SoState state) -> SoUnitsElement::Units"""
        return _coin.SoUnitsElement_get(state)

    @staticmethod
    def getDefault() -> "SoUnitsElement::Units":
        r"""getDefault() -> SoUnitsElement::Units"""
        return _coin.SoUnitsElement_getDefault()

# Register SoUnitsElement in _coin:
_coin.SoUnitsElement_swigregister(SoUnitsElement)

def SoUnitsElement_getClassTypeId() -> "SoType":
    r"""SoUnitsElement_getClassTypeId() -> SoType"""
    return _coin.SoUnitsElement_getClassTypeId()

def SoUnitsElement_getClassStackIndex() -> "int":
    r"""SoUnitsElement_getClassStackIndex() -> int"""
    return _coin.SoUnitsElement_getClassStackIndex()

def SoUnitsElement_createInstance() -> "void *":
    r"""SoUnitsElement_createInstance() -> void *"""
    return _coin.SoUnitsElement_createInstance()

def SoUnitsElement_initClass() -> "void":
    r"""SoUnitsElement_initClass()"""
    return _coin.SoUnitsElement_initClass()

def SoUnitsElement_set(*args) -> "void":
    r"""
    SoUnitsElement_set(SoState state, SoNode node, SoUnitsElement::Units const units)
    SoUnitsElement_set(SoState state, SoUnitsElement::Units const units)
    """
    return _coin.SoUnitsElement_set(*args)

def SoUnitsElement_get(state: "SoState") -> "SoUnitsElement::Units":
    r"""SoUnitsElement_get(SoState state) -> SoUnitsElement::Units"""
    return _coin.SoUnitsElement_get(state)

def SoUnitsElement_getDefault() -> "SoUnitsElement::Units":
    r"""SoUnitsElement_getDefault() -> SoUnitsElement::Units"""
    return _coin.SoUnitsElement_getDefault()

class SoFocalDistanceElement(SoFloatElement):
    r"""Proxy of C++ SoFocalDistanceElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFocalDistanceElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoFocalDistanceElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoFocalDistanceElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFocalDistanceElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoFocalDistanceElement self, SoState state)"""
        return _coin.SoFocalDistanceElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const distance)
        set(SoState state, float const distance)
        """
        return _coin.SoFocalDistanceElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoFocalDistanceElement_get(state)

    @staticmethod
    def getDefault() -> "float":
        r"""getDefault() -> float"""
        return _coin.SoFocalDistanceElement_getDefault()

# Register SoFocalDistanceElement in _coin:
_coin.SoFocalDistanceElement_swigregister(SoFocalDistanceElement)

def SoFocalDistanceElement_getClassTypeId() -> "SoType":
    r"""SoFocalDistanceElement_getClassTypeId() -> SoType"""
    return _coin.SoFocalDistanceElement_getClassTypeId()

def SoFocalDistanceElement_getClassStackIndex() -> "int":
    r"""SoFocalDistanceElement_getClassStackIndex() -> int"""
    return _coin.SoFocalDistanceElement_getClassStackIndex()

def SoFocalDistanceElement_createInstance() -> "void *":
    r"""SoFocalDistanceElement_createInstance() -> void *"""
    return _coin.SoFocalDistanceElement_createInstance()

def SoFocalDistanceElement_initClass() -> "void":
    r"""SoFocalDistanceElement_initClass()"""
    return _coin.SoFocalDistanceElement_initClass()

def SoFocalDistanceElement_set(*args) -> "void":
    r"""
    SoFocalDistanceElement_set(SoState state, SoNode node, float const distance)
    SoFocalDistanceElement_set(SoState state, float const distance)
    """
    return _coin.SoFocalDistanceElement_set(*args)

def SoFocalDistanceElement_get(state: "SoState") -> "float":
    r"""SoFocalDistanceElement_get(SoState state) -> float"""
    return _coin.SoFocalDistanceElement_get(state)

def SoFocalDistanceElement_getDefault() -> "float":
    r"""SoFocalDistanceElement_getDefault() -> float"""
    return _coin.SoFocalDistanceElement_getDefault()

class SoFontSizeElement(SoFloatElement):
    r"""Proxy of C++ SoFontSizeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFontSizeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoFontSizeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoFontSizeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFontSizeElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoFontSizeElement self, SoState state)"""
        return _coin.SoFontSizeElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const fontSize)
        set(SoState state, float const fontSize)
        """
        return _coin.SoFontSizeElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoFontSizeElement_get(state)

    @staticmethod
    def getDefault() -> "float":
        r"""getDefault() -> float"""
        return _coin.SoFontSizeElement_getDefault()

# Register SoFontSizeElement in _coin:
_coin.SoFontSizeElement_swigregister(SoFontSizeElement)

def SoFontSizeElement_getClassTypeId() -> "SoType":
    r"""SoFontSizeElement_getClassTypeId() -> SoType"""
    return _coin.SoFontSizeElement_getClassTypeId()

def SoFontSizeElement_getClassStackIndex() -> "int":
    r"""SoFontSizeElement_getClassStackIndex() -> int"""
    return _coin.SoFontSizeElement_getClassStackIndex()

def SoFontSizeElement_createInstance() -> "void *":
    r"""SoFontSizeElement_createInstance() -> void *"""
    return _coin.SoFontSizeElement_createInstance()

def SoFontSizeElement_initClass() -> "void":
    r"""SoFontSizeElement_initClass()"""
    return _coin.SoFontSizeElement_initClass()

def SoFontSizeElement_set(*args) -> "void":
    r"""
    SoFontSizeElement_set(SoState state, SoNode node, float const fontSize)
    SoFontSizeElement_set(SoState state, float const fontSize)
    """
    return _coin.SoFontSizeElement_set(*args)

def SoFontSizeElement_get(state: "SoState") -> "float":
    r"""SoFontSizeElement_get(SoState state) -> float"""
    return _coin.SoFontSizeElement_get(state)

def SoFontSizeElement_getDefault() -> "float":
    r"""SoFontSizeElement_getDefault() -> float"""
    return _coin.SoFontSizeElement_getDefault()

class SoLineWidthElement(SoFloatElement):
    r"""Proxy of C++ SoLineWidthElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineWidthElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoLineWidthElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoLineWidthElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLineWidthElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoLineWidthElement self, SoState state)"""
        return _coin.SoLineWidthElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const lineWidth)
        set(SoState state, float const lineWidth)
        """
        return _coin.SoLineWidthElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoLineWidthElement_get(state)

    @staticmethod
    def getDefault() -> "float":
        r"""getDefault() -> float"""
        return _coin.SoLineWidthElement_getDefault()

# Register SoLineWidthElement in _coin:
_coin.SoLineWidthElement_swigregister(SoLineWidthElement)

def SoLineWidthElement_getClassTypeId() -> "SoType":
    r"""SoLineWidthElement_getClassTypeId() -> SoType"""
    return _coin.SoLineWidthElement_getClassTypeId()

def SoLineWidthElement_getClassStackIndex() -> "int":
    r"""SoLineWidthElement_getClassStackIndex() -> int"""
    return _coin.SoLineWidthElement_getClassStackIndex()

def SoLineWidthElement_createInstance() -> "void *":
    r"""SoLineWidthElement_createInstance() -> void *"""
    return _coin.SoLineWidthElement_createInstance()

def SoLineWidthElement_initClass() -> "void":
    r"""SoLineWidthElement_initClass()"""
    return _coin.SoLineWidthElement_initClass()

def SoLineWidthElement_set(*args) -> "void":
    r"""
    SoLineWidthElement_set(SoState state, SoNode node, float const lineWidth)
    SoLineWidthElement_set(SoState state, float const lineWidth)
    """
    return _coin.SoLineWidthElement_set(*args)

def SoLineWidthElement_get(state: "SoState") -> "float":
    r"""SoLineWidthElement_get(SoState state) -> float"""
    return _coin.SoLineWidthElement_get(state)

def SoLineWidthElement_getDefault() -> "float":
    r"""SoLineWidthElement_getDefault() -> float"""
    return _coin.SoLineWidthElement_getDefault()

class SoGLLineWidthElement(SoLineWidthElement):
    r"""Proxy of C++ SoGLLineWidthElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLineWidthElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLineWidthElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLLineWidthElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLLineWidthElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLLineWidthElement self, SoState state)"""
        return _coin.SoGLLineWidthElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLLineWidthElement self, SoState state)"""
        return _coin.SoGLLineWidthElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLLineWidthElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLineWidthElement_pop(self, state, prevTopElement)

# Register SoGLLineWidthElement in _coin:
_coin.SoGLLineWidthElement_swigregister(SoGLLineWidthElement)

def SoGLLineWidthElement_getClassTypeId() -> "SoType":
    r"""SoGLLineWidthElement_getClassTypeId() -> SoType"""
    return _coin.SoGLLineWidthElement_getClassTypeId()

def SoGLLineWidthElement_getClassStackIndex() -> "int":
    r"""SoGLLineWidthElement_getClassStackIndex() -> int"""
    return _coin.SoGLLineWidthElement_getClassStackIndex()

def SoGLLineWidthElement_createInstance() -> "void *":
    r"""SoGLLineWidthElement_createInstance() -> void *"""
    return _coin.SoGLLineWidthElement_createInstance()

def SoGLLineWidthElement_initClass() -> "void":
    r"""SoGLLineWidthElement_initClass()"""
    return _coin.SoGLLineWidthElement_initClass()

class SoPointSizeElement(SoFloatElement):
    r"""Proxy of C++ SoPointSizeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointSizeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoPointSizeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoPointSizeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPointSizeElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoPointSizeElement self, SoState state)"""
        return _coin.SoPointSizeElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const pointSize)
        set(SoState state, float const pointSize)
        """
        return _coin.SoPointSizeElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoPointSizeElement_get(state)

    @staticmethod
    def getDefault() -> "float":
        r"""getDefault() -> float"""
        return _coin.SoPointSizeElement_getDefault()

# Register SoPointSizeElement in _coin:
_coin.SoPointSizeElement_swigregister(SoPointSizeElement)

def SoPointSizeElement_getClassTypeId() -> "SoType":
    r"""SoPointSizeElement_getClassTypeId() -> SoType"""
    return _coin.SoPointSizeElement_getClassTypeId()

def SoPointSizeElement_getClassStackIndex() -> "int":
    r"""SoPointSizeElement_getClassStackIndex() -> int"""
    return _coin.SoPointSizeElement_getClassStackIndex()

def SoPointSizeElement_createInstance() -> "void *":
    r"""SoPointSizeElement_createInstance() -> void *"""
    return _coin.SoPointSizeElement_createInstance()

def SoPointSizeElement_initClass() -> "void":
    r"""SoPointSizeElement_initClass()"""
    return _coin.SoPointSizeElement_initClass()

def SoPointSizeElement_set(*args) -> "void":
    r"""
    SoPointSizeElement_set(SoState state, SoNode node, float const pointSize)
    SoPointSizeElement_set(SoState state, float const pointSize)
    """
    return _coin.SoPointSizeElement_set(*args)

def SoPointSizeElement_get(state: "SoState") -> "float":
    r"""SoPointSizeElement_get(SoState state) -> float"""
    return _coin.SoPointSizeElement_get(state)

def SoPointSizeElement_getDefault() -> "float":
    r"""SoPointSizeElement_getDefault() -> float"""
    return _coin.SoPointSizeElement_getDefault()

class SoGLPointSizeElement(SoPointSizeElement):
    r"""Proxy of C++ SoGLPointSizeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLPointSizeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLPointSizeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLPointSizeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLPointSizeElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLPointSizeElement self, SoState state)"""
        return _coin.SoGLPointSizeElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLPointSizeElement self, SoState state)"""
        return _coin.SoGLPointSizeElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLPointSizeElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPointSizeElement_pop(self, state, prevTopElement)

# Register SoGLPointSizeElement in _coin:
_coin.SoGLPointSizeElement_swigregister(SoGLPointSizeElement)

def SoGLPointSizeElement_getClassTypeId() -> "SoType":
    r"""SoGLPointSizeElement_getClassTypeId() -> SoType"""
    return _coin.SoGLPointSizeElement_getClassTypeId()

def SoGLPointSizeElement_getClassStackIndex() -> "int":
    r"""SoGLPointSizeElement_getClassStackIndex() -> int"""
    return _coin.SoGLPointSizeElement_getClassStackIndex()

def SoGLPointSizeElement_createInstance() -> "void *":
    r"""SoGLPointSizeElement_createInstance() -> void *"""
    return _coin.SoGLPointSizeElement_createInstance()

def SoGLPointSizeElement_initClass() -> "void":
    r"""SoGLPointSizeElement_initClass()"""
    return _coin.SoGLPointSizeElement_initClass()

class SoTextureQualityElement(SoFloatElement):
    r"""Proxy of C++ SoTextureQualityElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureQualityElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureQualityElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTextureQualityElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureQualityElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoTextureQualityElement self, SoState state)"""
        return _coin.SoTextureQualityElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const quality)
        set(SoState state, float const quality)
        """
        return _coin.SoTextureQualityElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoTextureQualityElement_get(state)

    @staticmethod
    def getDefault() -> "float":
        r"""getDefault() -> float"""
        return _coin.SoTextureQualityElement_getDefault()

# Register SoTextureQualityElement in _coin:
_coin.SoTextureQualityElement_swigregister(SoTextureQualityElement)

def SoTextureQualityElement_getClassTypeId() -> "SoType":
    r"""SoTextureQualityElement_getClassTypeId() -> SoType"""
    return _coin.SoTextureQualityElement_getClassTypeId()

def SoTextureQualityElement_getClassStackIndex() -> "int":
    r"""SoTextureQualityElement_getClassStackIndex() -> int"""
    return _coin.SoTextureQualityElement_getClassStackIndex()

def SoTextureQualityElement_createInstance() -> "void *":
    r"""SoTextureQualityElement_createInstance() -> void *"""
    return _coin.SoTextureQualityElement_createInstance()

def SoTextureQualityElement_initClass() -> "void":
    r"""SoTextureQualityElement_initClass()"""
    return _coin.SoTextureQualityElement_initClass()

def SoTextureQualityElement_set(*args) -> "void":
    r"""
    SoTextureQualityElement_set(SoState state, SoNode node, float const quality)
    SoTextureQualityElement_set(SoState state, float const quality)
    """
    return _coin.SoTextureQualityElement_set(*args)

def SoTextureQualityElement_get(state: "SoState") -> "float":
    r"""SoTextureQualityElement_get(SoState state) -> float"""
    return _coin.SoTextureQualityElement_get(state)

def SoTextureQualityElement_getDefault() -> "float":
    r"""SoTextureQualityElement_getDefault() -> float"""
    return _coin.SoTextureQualityElement_getDefault()

class SoTextureOverrideElement(SoElement):
    r"""Proxy of C++ SoTextureOverrideElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureOverrideElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureOverrideElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTextureOverrideElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureOverrideElement_initClass()

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoTextureOverrideElement self, SoElement element) -> SbBool"""
        return _coin.SoTextureOverrideElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoTextureOverrideElement self) -> SoElement"""
        return _coin.SoTextureOverrideElement_copyMatchInfo(self)

    def init(self, state: "SoState") -> "void":
        r"""init(SoTextureOverrideElement self, SoState state)"""
        return _coin.SoTextureOverrideElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoTextureOverrideElement self, SoState state)"""
        return _coin.SoTextureOverrideElement_push(self, state)

    @staticmethod
    def getQualityOverride(state: "SoState") -> "SbBool":
        r"""getQualityOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getQualityOverride(state)

    @staticmethod
    def getImageOverride(state: "SoState") -> "SbBool":
        r"""getImageOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getImageOverride(state)

    @staticmethod
    def getBumpMapOverride(state: "SoState") -> "SbBool":
        r"""getBumpMapOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getBumpMapOverride(state)

    @staticmethod
    def setQualityOverride(state: "SoState", value: "SbBool const") -> "void":
        r"""setQualityOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setQualityOverride(state, value)

    @staticmethod
    def setImageOverride(state: "SoState", value: "SbBool const") -> "void":
        r"""setImageOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setImageOverride(state, value)

    @staticmethod
    def setBumpMapOverride(state: "SoState", value: "SbBool const") -> "void":
        r"""setBumpMapOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setBumpMapOverride(state, value)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SoTextureOverrideElement self, FILE * fp)"""
        return _coin.SoTextureOverrideElement_output(self, fp)

# Register SoTextureOverrideElement in _coin:
_coin.SoTextureOverrideElement_swigregister(SoTextureOverrideElement)

def SoTextureOverrideElement_getClassTypeId() -> "SoType":
    r"""SoTextureOverrideElement_getClassTypeId() -> SoType"""
    return _coin.SoTextureOverrideElement_getClassTypeId()

def SoTextureOverrideElement_getClassStackIndex() -> "int":
    r"""SoTextureOverrideElement_getClassStackIndex() -> int"""
    return _coin.SoTextureOverrideElement_getClassStackIndex()

def SoTextureOverrideElement_createInstance() -> "void *":
    r"""SoTextureOverrideElement_createInstance() -> void *"""
    return _coin.SoTextureOverrideElement_createInstance()

def SoTextureOverrideElement_initClass() -> "void":
    r"""SoTextureOverrideElement_initClass()"""
    return _coin.SoTextureOverrideElement_initClass()

def SoTextureOverrideElement_getQualityOverride(state: "SoState") -> "SbBool":
    r"""SoTextureOverrideElement_getQualityOverride(SoState state) -> SbBool"""
    return _coin.SoTextureOverrideElement_getQualityOverride(state)

def SoTextureOverrideElement_getImageOverride(state: "SoState") -> "SbBool":
    r"""SoTextureOverrideElement_getImageOverride(SoState state) -> SbBool"""
    return _coin.SoTextureOverrideElement_getImageOverride(state)

def SoTextureOverrideElement_getBumpMapOverride(state: "SoState") -> "SbBool":
    r"""SoTextureOverrideElement_getBumpMapOverride(SoState state) -> SbBool"""
    return _coin.SoTextureOverrideElement_getBumpMapOverride(state)

def SoTextureOverrideElement_setQualityOverride(state: "SoState", value: "SbBool const") -> "void":
    r"""SoTextureOverrideElement_setQualityOverride(SoState state, SbBool const value)"""
    return _coin.SoTextureOverrideElement_setQualityOverride(state, value)

def SoTextureOverrideElement_setImageOverride(state: "SoState", value: "SbBool const") -> "void":
    r"""SoTextureOverrideElement_setImageOverride(SoState state, SbBool const value)"""
    return _coin.SoTextureOverrideElement_setImageOverride(state, value)

def SoTextureOverrideElement_setBumpMapOverride(state: "SoState", value: "SbBool const") -> "void":
    r"""SoTextureOverrideElement_setBumpMapOverride(SoState state, SbBool const value)"""
    return _coin.SoTextureOverrideElement_setBumpMapOverride(state, value)

class SoGLRenderPassElement(SoElement):
    r"""Proxy of C++ SoGLRenderPassElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLRenderPassElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLRenderPassElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLRenderPassElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLRenderPassElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLRenderPassElement self, SoState state)"""
        return _coin.SoGLRenderPassElement_init(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoGLRenderPassElement self, SoElement element) -> SbBool"""
        return _coin.SoGLRenderPassElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoGLRenderPassElement self) -> SoElement"""
        return _coin.SoGLRenderPassElement_copyMatchInfo(self)

    @staticmethod
    def set(state: "SoState", passNumber: "int const") -> "void":
        r"""set(SoState state, int const passNumber)"""
        return _coin.SoGLRenderPassElement_set(state, passNumber)

    @staticmethod
    def get(state: "SoState") -> "int":
        r"""get(SoState state) -> int"""
        return _coin.SoGLRenderPassElement_get(state)

# Register SoGLRenderPassElement in _coin:
_coin.SoGLRenderPassElement_swigregister(SoGLRenderPassElement)

def SoGLRenderPassElement_getClassTypeId() -> "SoType":
    r"""SoGLRenderPassElement_getClassTypeId() -> SoType"""
    return _coin.SoGLRenderPassElement_getClassTypeId()

def SoGLRenderPassElement_getClassStackIndex() -> "int":
    r"""SoGLRenderPassElement_getClassStackIndex() -> int"""
    return _coin.SoGLRenderPassElement_getClassStackIndex()

def SoGLRenderPassElement_createInstance() -> "void *":
    r"""SoGLRenderPassElement_createInstance() -> void *"""
    return _coin.SoGLRenderPassElement_createInstance()

def SoGLRenderPassElement_initClass() -> "void":
    r"""SoGLRenderPassElement_initClass()"""
    return _coin.SoGLRenderPassElement_initClass()

def SoGLRenderPassElement_set(state: "SoState", passNumber: "int const") -> "void":
    r"""SoGLRenderPassElement_set(SoState state, int const passNumber)"""
    return _coin.SoGLRenderPassElement_set(state, passNumber)

def SoGLRenderPassElement_get(state: "SoState") -> "int":
    r"""SoGLRenderPassElement_get(SoState state) -> int"""
    return _coin.SoGLRenderPassElement_get(state)

class SoGLUpdateAreaElement(SoElement):
    r"""Proxy of C++ SoGLUpdateAreaElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLUpdateAreaElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLUpdateAreaElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLUpdateAreaElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLUpdateAreaElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLUpdateAreaElement self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLUpdateAreaElement self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLUpdateAreaElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLUpdateAreaElement_pop(self, state, prevTopElement)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoGLUpdateAreaElement self, SoElement element) -> SbBool"""
        return _coin.SoGLUpdateAreaElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoGLUpdateAreaElement self) -> SoElement"""
        return _coin.SoGLUpdateAreaElement_copyMatchInfo(self)

    @staticmethod
    def set(state: "SoState", origin: "SbVec2f", size: "SbVec2f") -> "void":
        r"""set(SoState state, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLUpdateAreaElement_set(state, origin, size)

    @staticmethod
    def get(state: "SoState", origin: "SbVec2f", size: "SbVec2f") -> "SbBool":
        r"""get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
        return _coin.SoGLUpdateAreaElement_get(state, origin, size)

    @staticmethod
    def getDefaultOrigin() -> "SbVec2f":
        r"""getDefaultOrigin() -> SbVec2f"""
        return _coin.SoGLUpdateAreaElement_getDefaultOrigin()

    @staticmethod
    def getDefaultSize() -> "SbVec2f":
        r"""getDefaultSize() -> SbVec2f"""
        return _coin.SoGLUpdateAreaElement_getDefaultSize()

# Register SoGLUpdateAreaElement in _coin:
_coin.SoGLUpdateAreaElement_swigregister(SoGLUpdateAreaElement)

def SoGLUpdateAreaElement_getClassTypeId() -> "SoType":
    r"""SoGLUpdateAreaElement_getClassTypeId() -> SoType"""
    return _coin.SoGLUpdateAreaElement_getClassTypeId()

def SoGLUpdateAreaElement_getClassStackIndex() -> "int":
    r"""SoGLUpdateAreaElement_getClassStackIndex() -> int"""
    return _coin.SoGLUpdateAreaElement_getClassStackIndex()

def SoGLUpdateAreaElement_createInstance() -> "void *":
    r"""SoGLUpdateAreaElement_createInstance() -> void *"""
    return _coin.SoGLUpdateAreaElement_createInstance()

def SoGLUpdateAreaElement_initClass() -> "void":
    r"""SoGLUpdateAreaElement_initClass()"""
    return _coin.SoGLUpdateAreaElement_initClass()

def SoGLUpdateAreaElement_set(state: "SoState", origin: "SbVec2f", size: "SbVec2f") -> "void":
    r"""SoGLUpdateAreaElement_set(SoState state, SbVec2f origin, SbVec2f size)"""
    return _coin.SoGLUpdateAreaElement_set(state, origin, size)

def SoGLUpdateAreaElement_get(state: "SoState", origin: "SbVec2f", size: "SbVec2f") -> "SbBool":
    r"""SoGLUpdateAreaElement_get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
    return _coin.SoGLUpdateAreaElement_get(state, origin, size)

def SoGLUpdateAreaElement_getDefaultOrigin() -> "SbVec2f":
    r"""SoGLUpdateAreaElement_getDefaultOrigin() -> SbVec2f"""
    return _coin.SoGLUpdateAreaElement_getDefaultOrigin()

def SoGLUpdateAreaElement_getDefaultSize() -> "SbVec2f":
    r"""SoGLUpdateAreaElement_getDefaultSize() -> SbVec2f"""
    return _coin.SoGLUpdateAreaElement_getDefaultSize()

class SoLocalBBoxMatrixElement(SoElement):
    r"""Proxy of C++ SoLocalBBoxMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLocalBBoxMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoLocalBBoxMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoLocalBBoxMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLocalBBoxMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoLocalBBoxMatrixElement self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoLocalBBoxMatrixElement self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_push(self, state)

    @staticmethod
    def makeIdentity(state: "SoState") -> "void":
        r"""makeIdentity(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_makeIdentity(state)

    @staticmethod
    def set(state: "SoState") -> "SbMatrix &":
        r"""set(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_set(state)

    @staticmethod
    def mult(state: "SoState") -> "SbMatrix &":
        r"""mult(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_mult(state)

    @staticmethod
    def translateBy(state: "SoState", translation: "SbVec3f") -> "void":
        r"""translateBy(SoState state, SbVec3f translation)"""
        return _coin.SoLocalBBoxMatrixElement_translateBy(state, translation)

    @staticmethod
    def rotateBy(state: "SoState", rotation: "SbRotation") -> "void":
        r"""rotateBy(SoState state, SbRotation rotation)"""
        return _coin.SoLocalBBoxMatrixElement_rotateBy(state, rotation)

    @staticmethod
    def scaleBy(state: "SoState", scaleFactor: "SbVec3f") -> "void":
        r"""scaleBy(SoState state, SbVec3f scaleFactor)"""
        return _coin.SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor)

    @staticmethod
    def pushMatrix(state: "SoState") -> "SbMatrix":
        r"""pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_pushMatrix(state)

    @staticmethod
    def popMatrix(state: "SoState") -> "SbMatrix &":
        r"""popMatrix(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_popMatrix(state)

    @staticmethod
    def resetAll(state: "SoState") -> "void":
        r"""resetAll(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_resetAll(state)

    @staticmethod
    def get(state: "SoState") -> "SbMatrix const &":
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_get(state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoLocalBBoxMatrixElement self, SoElement element) -> SbBool"""
        return _coin.SoLocalBBoxMatrixElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoLocalBBoxMatrixElement self) -> SoElement"""
        return _coin.SoLocalBBoxMatrixElement_copyMatchInfo(self)

# Register SoLocalBBoxMatrixElement in _coin:
_coin.SoLocalBBoxMatrixElement_swigregister(SoLocalBBoxMatrixElement)

def SoLocalBBoxMatrixElement_getClassTypeId() -> "SoType":
    r"""SoLocalBBoxMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoLocalBBoxMatrixElement_getClassTypeId()

def SoLocalBBoxMatrixElement_getClassStackIndex() -> "int":
    r"""SoLocalBBoxMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoLocalBBoxMatrixElement_getClassStackIndex()

def SoLocalBBoxMatrixElement_createInstance() -> "void *":
    r"""SoLocalBBoxMatrixElement_createInstance() -> void *"""
    return _coin.SoLocalBBoxMatrixElement_createInstance()

def SoLocalBBoxMatrixElement_initClass() -> "void":
    r"""SoLocalBBoxMatrixElement_initClass()"""
    return _coin.SoLocalBBoxMatrixElement_initClass()

def SoLocalBBoxMatrixElement_makeIdentity(state: "SoState") -> "void":
    r"""SoLocalBBoxMatrixElement_makeIdentity(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_makeIdentity(state)

def SoLocalBBoxMatrixElement_set(state: "SoState") -> "SbMatrix &":
    r"""SoLocalBBoxMatrixElement_set(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_set(state)

def SoLocalBBoxMatrixElement_mult(state: "SoState") -> "SbMatrix &":
    r"""SoLocalBBoxMatrixElement_mult(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_mult(state)

def SoLocalBBoxMatrixElement_translateBy(state: "SoState", translation: "SbVec3f") -> "void":
    r"""SoLocalBBoxMatrixElement_translateBy(SoState state, SbVec3f translation)"""
    return _coin.SoLocalBBoxMatrixElement_translateBy(state, translation)

def SoLocalBBoxMatrixElement_rotateBy(state: "SoState", rotation: "SbRotation") -> "void":
    r"""SoLocalBBoxMatrixElement_rotateBy(SoState state, SbRotation rotation)"""
    return _coin.SoLocalBBoxMatrixElement_rotateBy(state, rotation)

def SoLocalBBoxMatrixElement_scaleBy(state: "SoState", scaleFactor: "SbVec3f") -> "void":
    r"""SoLocalBBoxMatrixElement_scaleBy(SoState state, SbVec3f scaleFactor)"""
    return _coin.SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor)

def SoLocalBBoxMatrixElement_pushMatrix(state: "SoState") -> "SbMatrix":
    r"""SoLocalBBoxMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
    return _coin.SoLocalBBoxMatrixElement_pushMatrix(state)

def SoLocalBBoxMatrixElement_popMatrix(state: "SoState") -> "SbMatrix &":
    r"""SoLocalBBoxMatrixElement_popMatrix(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_popMatrix(state)

def SoLocalBBoxMatrixElement_resetAll(state: "SoState") -> "void":
    r"""SoLocalBBoxMatrixElement_resetAll(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_resetAll(state)

def SoLocalBBoxMatrixElement_get(state: "SoState") -> "SbMatrix const &":
    r"""SoLocalBBoxMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoLocalBBoxMatrixElement_get(state)

class SoOverrideElement(SoElement):
    r"""Proxy of C++ SoOverrideElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOverrideElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoOverrideElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoOverrideElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoOverrideElement_initClass()
    AMBIENT_COLOR = _coin.SoOverrideElement_AMBIENT_COLOR
    
    COLOR_INDEX = _coin.SoOverrideElement_COLOR_INDEX
    
    COMPLEXITY = _coin.SoOverrideElement_COMPLEXITY
    
    COMPLEXITY_TYPE = _coin.SoOverrideElement_COMPLEXITY_TYPE
    
    CREASE_ANGLE = _coin.SoOverrideElement_CREASE_ANGLE
    
    DIFFUSE_COLOR = _coin.SoOverrideElement_DIFFUSE_COLOR
    
    DRAW_STYLE = _coin.SoOverrideElement_DRAW_STYLE
    
    EMISSIVE_COLOR = _coin.SoOverrideElement_EMISSIVE_COLOR
    
    FONT_NAME = _coin.SoOverrideElement_FONT_NAME
    
    FONT_SIZE = _coin.SoOverrideElement_FONT_SIZE
    
    LIGHT_MODEL = _coin.SoOverrideElement_LIGHT_MODEL
    
    LINE_PATTERN = _coin.SoOverrideElement_LINE_PATTERN
    
    LINE_WIDTH = _coin.SoOverrideElement_LINE_WIDTH
    
    MATERIAL_BINDING = _coin.SoOverrideElement_MATERIAL_BINDING
    
    POINT_SIZE = _coin.SoOverrideElement_POINT_SIZE
    
    PICK_STYLE = _coin.SoOverrideElement_PICK_STYLE
    
    SHAPE_HINTS = _coin.SoOverrideElement_SHAPE_HINTS
    
    SHININESS = _coin.SoOverrideElement_SHININESS
    
    SPECULAR_COLOR = _coin.SoOverrideElement_SPECULAR_COLOR
    
    POLYGON_OFFSET = _coin.SoOverrideElement_POLYGON_OFFSET
    
    TRANSPARENCY = _coin.SoOverrideElement_TRANSPARENCY
    
    TRANSPARENCY_TYPE = _coin.SoOverrideElement_TRANSPARENCY_TYPE
    
    NORMAL_VECTOR = _coin.SoOverrideElement_NORMAL_VECTOR
    
    NORMAL_BINDING = _coin.SoOverrideElement_NORMAL_BINDING
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoOverrideElement self, SoState state)"""
        return _coin.SoOverrideElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoOverrideElement self, SoState state)"""
        return _coin.SoOverrideElement_push(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoOverrideElement self, SoElement element) -> SbBool"""
        return _coin.SoOverrideElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoOverrideElement self) -> SoElement"""
        return _coin.SoOverrideElement_copyMatchInfo(self)

    @staticmethod
    def getFlags(state: "SoState") -> "uint32_t":
        r"""getFlags(SoState state) -> uint32_t"""
        return _coin.SoOverrideElement_getFlags(state)

    @staticmethod
    def getAmbientColorOverride(state: "SoState") -> "SbBool":
        r"""getAmbientColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getAmbientColorOverride(state)

    @staticmethod
    def getColorIndexOverride(state: "SoState") -> "SbBool":
        r"""getColorIndexOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getColorIndexOverride(state)

    @staticmethod
    def getComplexityOverride(state: "SoState") -> "SbBool":
        r"""getComplexityOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityOverride(state)

    @staticmethod
    def getComplexityTypeOverride(state: "SoState") -> "SbBool":
        r"""getComplexityTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityTypeOverride(state)

    @staticmethod
    def getCreaseAngleOverride(state: "SoState") -> "SbBool":
        r"""getCreaseAngleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getCreaseAngleOverride(state)

    @staticmethod
    def getDiffuseColorOverride(state: "SoState") -> "SbBool":
        r"""getDiffuseColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDiffuseColorOverride(state)

    @staticmethod
    def getDrawStyleOverride(state: "SoState") -> "SbBool":
        r"""getDrawStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDrawStyleOverride(state)

    @staticmethod
    def getEmissiveColorOverride(state: "SoState") -> "SbBool":
        r"""getEmissiveColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getEmissiveColorOverride(state)

    @staticmethod
    def getFontNameOverride(state: "SoState") -> "SbBool":
        r"""getFontNameOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontNameOverride(state)

    @staticmethod
    def getFontSizeOverride(state: "SoState") -> "SbBool":
        r"""getFontSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontSizeOverride(state)

    @staticmethod
    def getLightModelOverride(state: "SoState") -> "SbBool":
        r"""getLightModelOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLightModelOverride(state)

    @staticmethod
    def getLinePatternOverride(state: "SoState") -> "SbBool":
        r"""getLinePatternOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLinePatternOverride(state)

    @staticmethod
    def getLineWidthOverride(state: "SoState") -> "SbBool":
        r"""getLineWidthOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLineWidthOverride(state)

    @staticmethod
    def getMaterialBindingOverride(state: "SoState") -> "SbBool":
        r"""getMaterialBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getMaterialBindingOverride(state)

    @staticmethod
    def getPickStyleOverride(state: "SoState") -> "SbBool":
        r"""getPickStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPickStyleOverride(state)

    @staticmethod
    def getPointSizeOverride(state: "SoState") -> "SbBool":
        r"""getPointSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPointSizeOverride(state)

    @staticmethod
    def getPolygonOffsetOverride(state: "SoState") -> "SbBool":
        r"""getPolygonOffsetOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPolygonOffsetOverride(state)

    @staticmethod
    def getShapeHintsOverride(state: "SoState") -> "SbBool":
        r"""getShapeHintsOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShapeHintsOverride(state)

    @staticmethod
    def getShininessOverride(state: "SoState") -> "SbBool":
        r"""getShininessOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShininessOverride(state)

    @staticmethod
    def getSpecularColorOverride(state: "SoState") -> "SbBool":
        r"""getSpecularColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getSpecularColorOverride(state)

    @staticmethod
    def getTransparencyOverride(state: "SoState") -> "SbBool":
        r"""getTransparencyOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyOverride(state)

    @staticmethod
    def getTransparencyTypeOverride(state: "SoState") -> "SbBool":
        r"""getTransparencyTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyTypeOverride(state)

    @staticmethod
    def getNormalVectorOverride(state: "SoState") -> "SbBool":
        r"""getNormalVectorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalVectorOverride(state)

    @staticmethod
    def getNormalBindingOverride(state: "SoState") -> "SbBool":
        r"""getNormalBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalBindingOverride(state)

    @staticmethod
    def setAmbientColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setAmbientColorOverride(state, node, override)

    @staticmethod
    def setColorIndexOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setColorIndexOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setColorIndexOverride(state, node, override)

    @staticmethod
    def setComplexityOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setComplexityOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setComplexityOverride(state, node, override)

    @staticmethod
    def setComplexityTypeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setComplexityTypeOverride(state, node, override)

    @staticmethod
    def setCreaseAngleOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setCreaseAngleOverride(state, node, override)

    @staticmethod
    def setDiffuseColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setDiffuseColorOverride(state, node, override)

    @staticmethod
    def setDrawStyleOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setDrawStyleOverride(state, node, override)

    @staticmethod
    def setEmissiveColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setEmissiveColorOverride(state, node, override)

    @staticmethod
    def setFontNameOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setFontNameOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setFontNameOverride(state, node, override)

    @staticmethod
    def setFontSizeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setFontSizeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setFontSizeOverride(state, node, override)

    @staticmethod
    def setLightModelOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setLightModelOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLightModelOverride(state, node, override)

    @staticmethod
    def setLinePatternOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setLinePatternOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLinePatternOverride(state, node, override)

    @staticmethod
    def setLineWidthOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setLineWidthOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLineWidthOverride(state, node, override)

    @staticmethod
    def setMaterialBindingOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setMaterialBindingOverride(state, node, override)

    @staticmethod
    def setPickStyleOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setPickStyleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPickStyleOverride(state, node, override)

    @staticmethod
    def setPointSizeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setPointSizeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPointSizeOverride(state, node, override)

    @staticmethod
    def setPolygonOffsetOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPolygonOffsetOverride(state, node, override)

    @staticmethod
    def setShapeHintsOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setShapeHintsOverride(state, node, override)

    @staticmethod
    def setShininessOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setShininessOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setShininessOverride(state, node, override)

    @staticmethod
    def setSpecularColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setSpecularColorOverride(state, node, override)

    @staticmethod
    def setTransparencyOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setTransparencyOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setTransparencyOverride(state, node, override)

    @staticmethod
    def setTransparencyTypeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setTransparencyTypeOverride(state, node, override)

    @staticmethod
    def setNormalVectorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setNormalVectorOverride(state, node, override)

    @staticmethod
    def setNormalBindingOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
        r"""setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setNormalBindingOverride(state, node, override)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoOverrideElement self, FILE * file)"""
        return _coin.SoOverrideElement_output(self, file)

# Register SoOverrideElement in _coin:
_coin.SoOverrideElement_swigregister(SoOverrideElement)

def SoOverrideElement_getClassTypeId() -> "SoType":
    r"""SoOverrideElement_getClassTypeId() -> SoType"""
    return _coin.SoOverrideElement_getClassTypeId()

def SoOverrideElement_getClassStackIndex() -> "int":
    r"""SoOverrideElement_getClassStackIndex() -> int"""
    return _coin.SoOverrideElement_getClassStackIndex()

def SoOverrideElement_createInstance() -> "void *":
    r"""SoOverrideElement_createInstance() -> void *"""
    return _coin.SoOverrideElement_createInstance()

def SoOverrideElement_initClass() -> "void":
    r"""SoOverrideElement_initClass()"""
    return _coin.SoOverrideElement_initClass()

def SoOverrideElement_getFlags(state: "SoState") -> "uint32_t":
    r"""SoOverrideElement_getFlags(SoState state) -> uint32_t"""
    return _coin.SoOverrideElement_getFlags(state)

def SoOverrideElement_getAmbientColorOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getAmbientColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getAmbientColorOverride(state)

def SoOverrideElement_getColorIndexOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getColorIndexOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getColorIndexOverride(state)

def SoOverrideElement_getComplexityOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getComplexityOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getComplexityOverride(state)

def SoOverrideElement_getComplexityTypeOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getComplexityTypeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getComplexityTypeOverride(state)

def SoOverrideElement_getCreaseAngleOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getCreaseAngleOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getCreaseAngleOverride(state)

def SoOverrideElement_getDiffuseColorOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getDiffuseColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getDiffuseColorOverride(state)

def SoOverrideElement_getDrawStyleOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getDrawStyleOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getDrawStyleOverride(state)

def SoOverrideElement_getEmissiveColorOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getEmissiveColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getEmissiveColorOverride(state)

def SoOverrideElement_getFontNameOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getFontNameOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getFontNameOverride(state)

def SoOverrideElement_getFontSizeOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getFontSizeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getFontSizeOverride(state)

def SoOverrideElement_getLightModelOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getLightModelOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getLightModelOverride(state)

def SoOverrideElement_getLinePatternOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getLinePatternOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getLinePatternOverride(state)

def SoOverrideElement_getLineWidthOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getLineWidthOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getLineWidthOverride(state)

def SoOverrideElement_getMaterialBindingOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getMaterialBindingOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getMaterialBindingOverride(state)

def SoOverrideElement_getPickStyleOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getPickStyleOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getPickStyleOverride(state)

def SoOverrideElement_getPointSizeOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getPointSizeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getPointSizeOverride(state)

def SoOverrideElement_getPolygonOffsetOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getPolygonOffsetOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getPolygonOffsetOverride(state)

def SoOverrideElement_getShapeHintsOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getShapeHintsOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getShapeHintsOverride(state)

def SoOverrideElement_getShininessOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getShininessOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getShininessOverride(state)

def SoOverrideElement_getSpecularColorOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getSpecularColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getSpecularColorOverride(state)

def SoOverrideElement_getTransparencyOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getTransparencyOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getTransparencyOverride(state)

def SoOverrideElement_getTransparencyTypeOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getTransparencyTypeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getTransparencyTypeOverride(state)

def SoOverrideElement_getNormalVectorOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getNormalVectorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getNormalVectorOverride(state)

def SoOverrideElement_getNormalBindingOverride(state: "SoState") -> "SbBool":
    r"""SoOverrideElement_getNormalBindingOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getNormalBindingOverride(state)

def SoOverrideElement_setAmbientColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setAmbientColorOverride(state, node, override)

def SoOverrideElement_setColorIndexOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setColorIndexOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setColorIndexOverride(state, node, override)

def SoOverrideElement_setComplexityOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setComplexityOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setComplexityOverride(state, node, override)

def SoOverrideElement_setComplexityTypeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setComplexityTypeOverride(state, node, override)

def SoOverrideElement_setCreaseAngleOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setCreaseAngleOverride(state, node, override)

def SoOverrideElement_setDiffuseColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setDiffuseColorOverride(state, node, override)

def SoOverrideElement_setDrawStyleOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setDrawStyleOverride(state, node, override)

def SoOverrideElement_setEmissiveColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setEmissiveColorOverride(state, node, override)

def SoOverrideElement_setFontNameOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setFontNameOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setFontNameOverride(state, node, override)

def SoOverrideElement_setFontSizeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setFontSizeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setFontSizeOverride(state, node, override)

def SoOverrideElement_setLightModelOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setLightModelOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setLightModelOverride(state, node, override)

def SoOverrideElement_setLinePatternOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setLinePatternOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setLinePatternOverride(state, node, override)

def SoOverrideElement_setLineWidthOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setLineWidthOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setLineWidthOverride(state, node, override)

def SoOverrideElement_setMaterialBindingOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setMaterialBindingOverride(state, node, override)

def SoOverrideElement_setPickStyleOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setPickStyleOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setPickStyleOverride(state, node, override)

def SoOverrideElement_setPointSizeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setPointSizeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setPointSizeOverride(state, node, override)

def SoOverrideElement_setPolygonOffsetOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setPolygonOffsetOverride(state, node, override)

def SoOverrideElement_setShapeHintsOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setShapeHintsOverride(state, node, override)

def SoOverrideElement_setShininessOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setShininessOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setShininessOverride(state, node, override)

def SoOverrideElement_setSpecularColorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setSpecularColorOverride(state, node, override)

def SoOverrideElement_setTransparencyOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setTransparencyOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setTransparencyOverride(state, node, override)

def SoOverrideElement_setTransparencyTypeOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setTransparencyTypeOverride(state, node, override)

def SoOverrideElement_setNormalVectorOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setNormalVectorOverride(state, node, override)

def SoOverrideElement_setNormalBindingOverride(state: "SoState", node: "SoNode", override: "SbBool const") -> "void":
    r"""SoOverrideElement_setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setNormalBindingOverride(state, node, override)

class SoPickRayElement(SoElement):
    r"""Proxy of C++ SoPickRayElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickRayElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoPickRayElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoPickRayElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPickRayElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoPickRayElement self, SoState state)"""
        return _coin.SoPickRayElement_init(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoPickRayElement self, SoElement element) -> SbBool"""
        return _coin.SoPickRayElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoPickRayElement self) -> SoElement"""
        return _coin.SoPickRayElement_copyMatchInfo(self)

    @staticmethod
    def set(state: "SoState", volume: "SbViewVolume") -> "void":
        r"""set(SoState state, SbViewVolume volume)"""
        return _coin.SoPickRayElement_set(state, volume)

    @staticmethod
    def get(state: "SoState") -> "SbViewVolume const &":
        r"""get(SoState state) -> SbViewVolume"""
        return _coin.SoPickRayElement_get(state)

# Register SoPickRayElement in _coin:
_coin.SoPickRayElement_swigregister(SoPickRayElement)

def SoPickRayElement_getClassTypeId() -> "SoType":
    r"""SoPickRayElement_getClassTypeId() -> SoType"""
    return _coin.SoPickRayElement_getClassTypeId()

def SoPickRayElement_getClassStackIndex() -> "int":
    r"""SoPickRayElement_getClassStackIndex() -> int"""
    return _coin.SoPickRayElement_getClassStackIndex()

def SoPickRayElement_createInstance() -> "void *":
    r"""SoPickRayElement_createInstance() -> void *"""
    return _coin.SoPickRayElement_createInstance()

def SoPickRayElement_initClass() -> "void":
    r"""SoPickRayElement_initClass()"""
    return _coin.SoPickRayElement_initClass()

def SoPickRayElement_set(state: "SoState", volume: "SbViewVolume") -> "void":
    r"""SoPickRayElement_set(SoState state, SbViewVolume volume)"""
    return _coin.SoPickRayElement_set(state, volume)

def SoPickRayElement_get(state: "SoState") -> "SbViewVolume const &":
    r"""SoPickRayElement_get(SoState state) -> SbViewVolume"""
    return _coin.SoPickRayElement_get(state)

class SoGLCoordinateElement(SoCoordinateElement):
    r"""Proxy of C++ SoGLCoordinateElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLCoordinateElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLCoordinateElement_initClass()

    def getPtr3(self) -> "SbVec3f const *":
        r"""getPtr3(SoGLCoordinateElement self) -> SbVec3f"""
        return _coin.SoGLCoordinateElement_getPtr3(self)

    def getPtr4(self) -> "SbVec4f const *":
        r"""getPtr4(SoGLCoordinateElement self) -> SbVec4f"""
        return _coin.SoGLCoordinateElement_getPtr4(self)

    def send(self, index: "int const") -> "void":
        r"""send(SoGLCoordinateElement self, int const index)"""
        return _coin.SoGLCoordinateElement_send(self, index)

# Register SoGLCoordinateElement in _coin:
_coin.SoGLCoordinateElement_swigregister(SoGLCoordinateElement)

def SoGLCoordinateElement_getClassTypeId() -> "SoType":
    r"""SoGLCoordinateElement_getClassTypeId() -> SoType"""
    return _coin.SoGLCoordinateElement_getClassTypeId()

def SoGLCoordinateElement_getClassStackIndex() -> "int":
    r"""SoGLCoordinateElement_getClassStackIndex() -> int"""
    return _coin.SoGLCoordinateElement_getClassStackIndex()

def SoGLCoordinateElement_createInstance() -> "void *":
    r"""SoGLCoordinateElement_createInstance() -> void *"""
    return _coin.SoGLCoordinateElement_createInstance()

def SoGLCoordinateElement_initClass() -> "void":
    r"""SoGLCoordinateElement_initClass()"""
    return _coin.SoGLCoordinateElement_initClass()

class SoEnvironmentElement(SoReplacedElement):
    r"""Proxy of C++ SoEnvironmentElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEnvironmentElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoEnvironmentElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoEnvironmentElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoEnvironmentElement_initClass()
    NONE = _coin.SoEnvironmentElement_NONE
    
    HAZE = _coin.SoEnvironmentElement_HAZE
    
    FOG = _coin.SoEnvironmentElement_FOG
    
    SMOKE = _coin.SoEnvironmentElement_SMOKE
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoEnvironmentElement self, SoState state)"""
        return _coin.SoEnvironmentElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", ambientIntensity: "float const", ambientColor: "SbColor", attenuation: "SbVec3f", fogType: "int32_t const", fogColor: "SbColor", fogVisibility: "float const", fogStart: "float const"=0.0) -> "void":
        r"""set(SoState state, SoNode node, float const ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t const fogType, SbColor fogColor, float const fogVisibility, float const fogStart=0.0)"""
        return _coin.SoEnvironmentElement_set(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

    @staticmethod
    def get(state: "SoState", ambientIntensity: "float &", ambientColor: "SbColor", attenuation: "SbVec3f", fogType: "int32_t &", fogColor: "SbColor", fogVisibility: "float &", fogStart: "float &") -> "void":
        r"""get(SoState state, float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogStart)"""
        return _coin.SoEnvironmentElement_get(state, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

    @staticmethod
    def getAmbientIntensity(state: "SoState") -> "float":
        r"""getAmbientIntensity(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getAmbientIntensity(state)

    @staticmethod
    def getFogVisibility(state: "SoState") -> "float":
        r"""getFogVisibility(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getFogVisibility(state)

    @staticmethod
    def getLightAttenuation(state: "SoState") -> "SbVec3f const &":
        r"""getLightAttenuation(SoState state) -> SbVec3f"""
        return _coin.SoEnvironmentElement_getLightAttenuation(state)

    @staticmethod
    def getAmbientColor(state: "SoState") -> "SbColor const &":
        r"""getAmbientColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getAmbientColor(state)

    @staticmethod
    def getFogColor(state: "SoState") -> "SbColor const &":
        r"""getFogColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getFogColor(state)

    @staticmethod
    def getFogType(state: "SoState") -> "int32_t":
        r"""getFogType(SoState state) -> int32_t"""
        return _coin.SoEnvironmentElement_getFogType(state)

    @staticmethod
    def getDefault(ambientIntensity: "float &", ambientColor: "SbColor", attenuation: "SbVec3f", fogType: "int32_t &", fogColor: "SbColor", fogVisibility: "float &", fogNear: "float &") -> "void":
        r"""getDefault(float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogNear)"""
        return _coin.SoEnvironmentElement_getDefault(ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogNear)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoEnvironmentElement self, FILE * file)"""
        return _coin.SoEnvironmentElement_output(self, file)

# Register SoEnvironmentElement in _coin:
_coin.SoEnvironmentElement_swigregister(SoEnvironmentElement)

def SoEnvironmentElement_getClassTypeId() -> "SoType":
    r"""SoEnvironmentElement_getClassTypeId() -> SoType"""
    return _coin.SoEnvironmentElement_getClassTypeId()

def SoEnvironmentElement_getClassStackIndex() -> "int":
    r"""SoEnvironmentElement_getClassStackIndex() -> int"""
    return _coin.SoEnvironmentElement_getClassStackIndex()

def SoEnvironmentElement_createInstance() -> "void *":
    r"""SoEnvironmentElement_createInstance() -> void *"""
    return _coin.SoEnvironmentElement_createInstance()

def SoEnvironmentElement_initClass() -> "void":
    r"""SoEnvironmentElement_initClass()"""
    return _coin.SoEnvironmentElement_initClass()

def SoEnvironmentElement_set(state: "SoState", node: "SoNode", ambientIntensity: "float const", ambientColor: "SbColor", attenuation: "SbVec3f", fogType: "int32_t const", fogColor: "SbColor", fogVisibility: "float const", fogStart: "float const"=0.0) -> "void":
    r"""SoEnvironmentElement_set(SoState state, SoNode node, float const ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t const fogType, SbColor fogColor, float const fogVisibility, float const fogStart=0.0)"""
    return _coin.SoEnvironmentElement_set(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

def SoEnvironmentElement_get(state: "SoState", ambientIntensity: "float &", ambientColor: "SbColor", attenuation: "SbVec3f", fogType: "int32_t &", fogColor: "SbColor", fogVisibility: "float &", fogStart: "float &") -> "void":
    r"""SoEnvironmentElement_get(SoState state, float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogStart)"""
    return _coin.SoEnvironmentElement_get(state, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

def SoEnvironmentElement_getAmbientIntensity(state: "SoState") -> "float":
    r"""SoEnvironmentElement_getAmbientIntensity(SoState state) -> float"""
    return _coin.SoEnvironmentElement_getAmbientIntensity(state)

def SoEnvironmentElement_getFogVisibility(state: "SoState") -> "float":
    r"""SoEnvironmentElement_getFogVisibility(SoState state) -> float"""
    return _coin.SoEnvironmentElement_getFogVisibility(state)

def SoEnvironmentElement_getLightAttenuation(state: "SoState") -> "SbVec3f const &":
    r"""SoEnvironmentElement_getLightAttenuation(SoState state) -> SbVec3f"""
    return _coin.SoEnvironmentElement_getLightAttenuation(state)

def SoEnvironmentElement_getAmbientColor(state: "SoState") -> "SbColor const &":
    r"""SoEnvironmentElement_getAmbientColor(SoState state) -> SbColor"""
    return _coin.SoEnvironmentElement_getAmbientColor(state)

def SoEnvironmentElement_getFogColor(state: "SoState") -> "SbColor const &":
    r"""SoEnvironmentElement_getFogColor(SoState state) -> SbColor"""
    return _coin.SoEnvironmentElement_getFogColor(state)

def SoEnvironmentElement_getFogType(state: "SoState") -> "int32_t":
    r"""SoEnvironmentElement_getFogType(SoState state) -> int32_t"""
    return _coin.SoEnvironmentElement_getFogType(state)

def SoEnvironmentElement_getDefault(ambientIntensity: "float &", ambientColor: "SbColor", attenuation: "SbVec3f", fogType: "int32_t &", fogColor: "SbColor", fogVisibility: "float &", fogNear: "float &") -> "void":
    r"""SoEnvironmentElement_getDefault(float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogNear)"""
    return _coin.SoEnvironmentElement_getDefault(ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogNear)

class SoGLEnvironmentElement(SoEnvironmentElement):
    r"""Proxy of C++ SoGLEnvironmentElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLEnvironmentElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLEnvironmentElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLEnvironmentElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLEnvironmentElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLEnvironmentElement self, SoState state)"""
        return _coin.SoGLEnvironmentElement_init(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLEnvironmentElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLEnvironmentElement_pop(self, state, prevTopElement)

# Register SoGLEnvironmentElement in _coin:
_coin.SoGLEnvironmentElement_swigregister(SoGLEnvironmentElement)

def SoGLEnvironmentElement_getClassTypeId() -> "SoType":
    r"""SoGLEnvironmentElement_getClassTypeId() -> SoType"""
    return _coin.SoGLEnvironmentElement_getClassTypeId()

def SoGLEnvironmentElement_getClassStackIndex() -> "int":
    r"""SoGLEnvironmentElement_getClassStackIndex() -> int"""
    return _coin.SoGLEnvironmentElement_getClassStackIndex()

def SoGLEnvironmentElement_createInstance() -> "void *":
    r"""SoGLEnvironmentElement_createInstance() -> void *"""
    return _coin.SoGLEnvironmentElement_createInstance()

def SoGLEnvironmentElement_initClass() -> "void":
    r"""SoGLEnvironmentElement_initClass()"""
    return _coin.SoGLEnvironmentElement_initClass()

class SoFontNameElement(SoReplacedElement):
    r"""Proxy of C++ SoFontNameElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFontNameElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoFontNameElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoFontNameElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFontNameElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoFontNameElement self, SoState state)"""
        return _coin.SoFontNameElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", fontName: "SbName") -> "void":
        r"""set(SoState state, SoNode node, SbName fontName)"""
        return _coin.SoFontNameElement_set(state, node, fontName)

    @staticmethod
    def get(state: "SoState") -> "SbName const &":
        r"""get(SoState state) -> SbName"""
        return _coin.SoFontNameElement_get(state)

    @staticmethod
    def getDefault() -> "SbName":
        r"""getDefault() -> SbName"""
        return _coin.SoFontNameElement_getDefault()

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoFontNameElement self, SoElement element) -> SbBool"""
        return _coin.SoFontNameElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoFontNameElement self) -> SoElement"""
        return _coin.SoFontNameElement_copyMatchInfo(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoFontNameElement self, FILE * file)"""
        return _coin.SoFontNameElement_output(self, file)

# Register SoFontNameElement in _coin:
_coin.SoFontNameElement_swigregister(SoFontNameElement)

def SoFontNameElement_getClassTypeId() -> "SoType":
    r"""SoFontNameElement_getClassTypeId() -> SoType"""
    return _coin.SoFontNameElement_getClassTypeId()

def SoFontNameElement_getClassStackIndex() -> "int":
    r"""SoFontNameElement_getClassStackIndex() -> int"""
    return _coin.SoFontNameElement_getClassStackIndex()

def SoFontNameElement_createInstance() -> "void *":
    r"""SoFontNameElement_createInstance() -> void *"""
    return _coin.SoFontNameElement_createInstance()

def SoFontNameElement_initClass() -> "void":
    r"""SoFontNameElement_initClass()"""
    return _coin.SoFontNameElement_initClass()

def SoFontNameElement_set(state: "SoState", node: "SoNode", fontName: "SbName") -> "void":
    r"""SoFontNameElement_set(SoState state, SoNode node, SbName fontName)"""
    return _coin.SoFontNameElement_set(state, node, fontName)

def SoFontNameElement_get(state: "SoState") -> "SbName const &":
    r"""SoFontNameElement_get(SoState state) -> SbName"""
    return _coin.SoFontNameElement_get(state)

def SoFontNameElement_getDefault() -> "SbName":
    r"""SoFontNameElement_getDefault() -> SbName"""
    return _coin.SoFontNameElement_getDefault()

class SoLightAttenuationElement(SoReplacedElement):
    r"""Proxy of C++ SoLightAttenuationElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightAttenuationElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoLightAttenuationElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoLightAttenuationElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLightAttenuationElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoLightAttenuationElement self, SoState state)"""
        return _coin.SoLightAttenuationElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", lightAttenuation: "SbVec3f") -> "void":
        r"""set(SoState state, SoNode node, SbVec3f lightAttenuation)"""
        return _coin.SoLightAttenuationElement_set(state, node, lightAttenuation)

    @staticmethod
    def get(state: "SoState") -> "SbVec3f const &":
        r"""get(SoState state) -> SbVec3f"""
        return _coin.SoLightAttenuationElement_get(state)

    @staticmethod
    def getDefault() -> "SbVec3f const &":
        r"""getDefault() -> SbVec3f"""
        return _coin.SoLightAttenuationElement_getDefault()

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoLightAttenuationElement self, SoElement element) -> SbBool"""
        return _coin.SoLightAttenuationElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoLightAttenuationElement self) -> SoElement"""
        return _coin.SoLightAttenuationElement_copyMatchInfo(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoLightAttenuationElement self, FILE * file)"""
        return _coin.SoLightAttenuationElement_output(self, file)

# Register SoLightAttenuationElement in _coin:
_coin.SoLightAttenuationElement_swigregister(SoLightAttenuationElement)

def SoLightAttenuationElement_getClassTypeId() -> "SoType":
    r"""SoLightAttenuationElement_getClassTypeId() -> SoType"""
    return _coin.SoLightAttenuationElement_getClassTypeId()

def SoLightAttenuationElement_getClassStackIndex() -> "int":
    r"""SoLightAttenuationElement_getClassStackIndex() -> int"""
    return _coin.SoLightAttenuationElement_getClassStackIndex()

def SoLightAttenuationElement_createInstance() -> "void *":
    r"""SoLightAttenuationElement_createInstance() -> void *"""
    return _coin.SoLightAttenuationElement_createInstance()

def SoLightAttenuationElement_initClass() -> "void":
    r"""SoLightAttenuationElement_initClass()"""
    return _coin.SoLightAttenuationElement_initClass()

def SoLightAttenuationElement_set(state: "SoState", node: "SoNode", lightAttenuation: "SbVec3f") -> "void":
    r"""SoLightAttenuationElement_set(SoState state, SoNode node, SbVec3f lightAttenuation)"""
    return _coin.SoLightAttenuationElement_set(state, node, lightAttenuation)

def SoLightAttenuationElement_get(state: "SoState") -> "SbVec3f const &":
    r"""SoLightAttenuationElement_get(SoState state) -> SbVec3f"""
    return _coin.SoLightAttenuationElement_get(state)

def SoLightAttenuationElement_getDefault() -> "SbVec3f const &":
    r"""SoLightAttenuationElement_getDefault() -> SbVec3f"""
    return _coin.SoLightAttenuationElement_getDefault()

class SoPolygonOffsetElement(SoReplacedElement):
    r"""Proxy of C++ SoPolygonOffsetElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPolygonOffsetElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoPolygonOffsetElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoPolygonOffsetElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPolygonOffsetElement_initClass()
    FILLED = _coin.SoPolygonOffsetElement_FILLED
    
    LINES = _coin.SoPolygonOffsetElement_LINES
    
    POINTS = _coin.SoPolygonOffsetElement_POINTS
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoPolygonOffsetElement self, SoState state)"""
        return _coin.SoPolygonOffsetElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", factor: "float", units: "float", styles: "SoPolygonOffsetElement::Style", on: "SbBool") -> "void":
        r"""set(SoState state, SoNode node, float factor, float units, SoPolygonOffsetElement::Style styles, SbBool on)"""
        return _coin.SoPolygonOffsetElement_set(state, node, factor, units, styles, on)

    @staticmethod
    def get(state: "SoState", factor: "float &", units: "float &", styles: "SoPolygonOffsetElement::Style &", on: "SbBool &") -> "void":
        r"""get(SoState state, float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
        return _coin.SoPolygonOffsetElement_get(state, factor, units, styles, on)

    @staticmethod
    def getDefault(factor: "float &", units: "float &", styles: "SoPolygonOffsetElement::Style &", on: "SbBool &") -> "void":
        r"""getDefault(float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
        return _coin.SoPolygonOffsetElement_getDefault(factor, units, styles, on)

# Register SoPolygonOffsetElement in _coin:
_coin.SoPolygonOffsetElement_swigregister(SoPolygonOffsetElement)

def SoPolygonOffsetElement_getClassTypeId() -> "SoType":
    r"""SoPolygonOffsetElement_getClassTypeId() -> SoType"""
    return _coin.SoPolygonOffsetElement_getClassTypeId()

def SoPolygonOffsetElement_getClassStackIndex() -> "int":
    r"""SoPolygonOffsetElement_getClassStackIndex() -> int"""
    return _coin.SoPolygonOffsetElement_getClassStackIndex()

def SoPolygonOffsetElement_createInstance() -> "void *":
    r"""SoPolygonOffsetElement_createInstance() -> void *"""
    return _coin.SoPolygonOffsetElement_createInstance()

def SoPolygonOffsetElement_initClass() -> "void":
    r"""SoPolygonOffsetElement_initClass()"""
    return _coin.SoPolygonOffsetElement_initClass()

def SoPolygonOffsetElement_set(state: "SoState", node: "SoNode", factor: "float", units: "float", styles: "SoPolygonOffsetElement::Style", on: "SbBool") -> "void":
    r"""SoPolygonOffsetElement_set(SoState state, SoNode node, float factor, float units, SoPolygonOffsetElement::Style styles, SbBool on)"""
    return _coin.SoPolygonOffsetElement_set(state, node, factor, units, styles, on)

def SoPolygonOffsetElement_get(state: "SoState", factor: "float &", units: "float &", styles: "SoPolygonOffsetElement::Style &", on: "SbBool &") -> "void":
    r"""SoPolygonOffsetElement_get(SoState state, float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
    return _coin.SoPolygonOffsetElement_get(state, factor, units, styles, on)

def SoPolygonOffsetElement_getDefault(factor: "float &", units: "float &", styles: "SoPolygonOffsetElement::Style &", on: "SbBool &") -> "void":
    r"""SoPolygonOffsetElement_getDefault(float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
    return _coin.SoPolygonOffsetElement_getDefault(factor, units, styles, on)

class SoGLPolygonOffsetElement(SoPolygonOffsetElement):
    r"""Proxy of C++ SoGLPolygonOffsetElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLPolygonOffsetElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLPolygonOffsetElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLPolygonOffsetElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLPolygonOffsetElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLPolygonOffsetElement self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLPolygonOffsetElement self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLPolygonOffsetElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPolygonOffsetElement_pop(self, state, prevTopElement)

# Register SoGLPolygonOffsetElement in _coin:
_coin.SoGLPolygonOffsetElement_swigregister(SoGLPolygonOffsetElement)

def SoGLPolygonOffsetElement_getClassTypeId() -> "SoType":
    r"""SoGLPolygonOffsetElement_getClassTypeId() -> SoType"""
    return _coin.SoGLPolygonOffsetElement_getClassTypeId()

def SoGLPolygonOffsetElement_getClassStackIndex() -> "int":
    r"""SoGLPolygonOffsetElement_getClassStackIndex() -> int"""
    return _coin.SoGLPolygonOffsetElement_getClassStackIndex()

def SoGLPolygonOffsetElement_createInstance() -> "void *":
    r"""SoGLPolygonOffsetElement_createInstance() -> void *"""
    return _coin.SoGLPolygonOffsetElement_createInstance()

def SoGLPolygonOffsetElement_initClass() -> "void":
    r"""SoGLPolygonOffsetElement_initClass()"""
    return _coin.SoGLPolygonOffsetElement_initClass()

class SoProjectionMatrixElement(SoReplacedElement):
    r"""Proxy of C++ SoProjectionMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProjectionMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoProjectionMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoProjectionMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProjectionMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoProjectionMatrixElement self, SoState state)"""
        return _coin.SoProjectionMatrixElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode") -> "SbMatrix &":
        r"""set(SoState state, SoNode node)"""
        return _coin.SoProjectionMatrixElement_set(state, node)

    @staticmethod
    def get(state: "SoState") -> "SbMatrix const &":
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoProjectionMatrixElement_get(state)

# Register SoProjectionMatrixElement in _coin:
_coin.SoProjectionMatrixElement_swigregister(SoProjectionMatrixElement)

def SoProjectionMatrixElement_getClassTypeId() -> "SoType":
    r"""SoProjectionMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoProjectionMatrixElement_getClassTypeId()

def SoProjectionMatrixElement_getClassStackIndex() -> "int":
    r"""SoProjectionMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoProjectionMatrixElement_getClassStackIndex()

def SoProjectionMatrixElement_createInstance() -> "void *":
    r"""SoProjectionMatrixElement_createInstance() -> void *"""
    return _coin.SoProjectionMatrixElement_createInstance()

def SoProjectionMatrixElement_initClass() -> "void":
    r"""SoProjectionMatrixElement_initClass()"""
    return _coin.SoProjectionMatrixElement_initClass()

def SoProjectionMatrixElement_set(state: "SoState", node: "SoNode") -> "SbMatrix &":
    r"""SoProjectionMatrixElement_set(SoState state, SoNode node)"""
    return _coin.SoProjectionMatrixElement_set(state, node)

def SoProjectionMatrixElement_get(state: "SoState") -> "SbMatrix const &":
    r"""SoProjectionMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoProjectionMatrixElement_get(state)

class SoGLProjectionMatrixElement(SoProjectionMatrixElement):
    r"""Proxy of C++ SoGLProjectionMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLProjectionMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLProjectionMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLProjectionMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLProjectionMatrixElement_initClass()

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLProjectionMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLProjectionMatrixElement_pop(self, state, prevTopElement)

# Register SoGLProjectionMatrixElement in _coin:
_coin.SoGLProjectionMatrixElement_swigregister(SoGLProjectionMatrixElement)

def SoGLProjectionMatrixElement_getClassTypeId() -> "SoType":
    r"""SoGLProjectionMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoGLProjectionMatrixElement_getClassTypeId()

def SoGLProjectionMatrixElement_getClassStackIndex() -> "int":
    r"""SoGLProjectionMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoGLProjectionMatrixElement_getClassStackIndex()

def SoGLProjectionMatrixElement_createInstance() -> "void *":
    r"""SoGLProjectionMatrixElement_createInstance() -> void *"""
    return _coin.SoGLProjectionMatrixElement_createInstance()

def SoGLProjectionMatrixElement_initClass() -> "void":
    r"""SoGLProjectionMatrixElement_initClass()"""
    return _coin.SoGLProjectionMatrixElement_initClass()

class SoProfileCoordinateElement(SoReplacedElement):
    r"""Proxy of C++ SoProfileCoordinateElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoProfileCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoProfileCoordinateElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProfileCoordinateElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoProfileCoordinateElement self, SoState state)"""
        return _coin.SoProfileCoordinateElement_init(self, state)

    @staticmethod
    def set2(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec2f") -> "void":
        r"""set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
        return _coin.SoProfileCoordinateElement_set2(state, node, numCoords, coords)

    @staticmethod
    def set3(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec3f") -> "void":
        r"""set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoProfileCoordinateElement_set3(state, node, numCoords, coords)

    @staticmethod
    def getInstance(state: "SoState") -> "SoProfileCoordinateElement const *":
        r"""getInstance(SoState state) -> SoProfileCoordinateElement"""
        return _coin.SoProfileCoordinateElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoProfileCoordinateElement self) -> int32_t"""
        return _coin.SoProfileCoordinateElement_getNum(self)

    def get2(self, index: "int const") -> "SbVec2f const &":
        r"""get2(SoProfileCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_get2(self, index)

    def get3(self, index: "int const") -> "SbVec3f const &":
        r"""get3(SoProfileCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_get3(self, index)

    def is2D(self) -> "SbBool":
        r"""is2D(SoProfileCoordinateElement self) -> SbBool"""
        return _coin.SoProfileCoordinateElement_is2D(self)

    @staticmethod
    def getDefault2() -> "SbVec2f":
        r"""getDefault2() -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_getDefault2()

    @staticmethod
    def getDefault3() -> "SbVec3f":
        r"""getDefault3() -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_getDefault3()

    def getArrayPtr2(self) -> "SbVec2f const *":
        r"""getArrayPtr2(SoProfileCoordinateElement self) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_getArrayPtr2(self)

    def getArrayPtr3(self) -> "SbVec3f const *":
        r"""getArrayPtr3(SoProfileCoordinateElement self) -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_getArrayPtr3(self)

# Register SoProfileCoordinateElement in _coin:
_coin.SoProfileCoordinateElement_swigregister(SoProfileCoordinateElement)

def SoProfileCoordinateElement_getClassTypeId() -> "SoType":
    r"""SoProfileCoordinateElement_getClassTypeId() -> SoType"""
    return _coin.SoProfileCoordinateElement_getClassTypeId()

def SoProfileCoordinateElement_getClassStackIndex() -> "int":
    r"""SoProfileCoordinateElement_getClassStackIndex() -> int"""
    return _coin.SoProfileCoordinateElement_getClassStackIndex()

def SoProfileCoordinateElement_createInstance() -> "void *":
    r"""SoProfileCoordinateElement_createInstance() -> void *"""
    return _coin.SoProfileCoordinateElement_createInstance()

def SoProfileCoordinateElement_initClass() -> "void":
    r"""SoProfileCoordinateElement_initClass()"""
    return _coin.SoProfileCoordinateElement_initClass()

def SoProfileCoordinateElement_set2(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec2f") -> "void":
    r"""SoProfileCoordinateElement_set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
    return _coin.SoProfileCoordinateElement_set2(state, node, numCoords, coords)

def SoProfileCoordinateElement_set3(state: "SoState", node: "SoNode", numCoords: "int32_t const", coords: "SbVec3f") -> "void":
    r"""SoProfileCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
    return _coin.SoProfileCoordinateElement_set3(state, node, numCoords, coords)

def SoProfileCoordinateElement_getInstance(state: "SoState") -> "SoProfileCoordinateElement const *":
    r"""SoProfileCoordinateElement_getInstance(SoState state) -> SoProfileCoordinateElement"""
    return _coin.SoProfileCoordinateElement_getInstance(state)

def SoProfileCoordinateElement_getDefault2() -> "SbVec2f":
    r"""SoProfileCoordinateElement_getDefault2() -> SbVec2f"""
    return _coin.SoProfileCoordinateElement_getDefault2()

def SoProfileCoordinateElement_getDefault3() -> "SbVec3f":
    r"""SoProfileCoordinateElement_getDefault3() -> SbVec3f"""
    return _coin.SoProfileCoordinateElement_getDefault3()

class SoGLMultiTextureImageElement(SoMultiTextureImageElement):
    r"""Proxy of C++ SoGLMultiTextureImageElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureImageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureImageElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureImageElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLMultiTextureImageElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLMultiTextureImageElement self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLMultiTextureImageElement self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLMultiTextureImageElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureImageElement_pop(self, state, prevTopElement)

    @staticmethod
    def restore(state: "SoState", unit: "int const") -> "void":
        r"""restore(SoState state, int const unit)"""
        return _coin.SoGLMultiTextureImageElement_restore(state, unit)

    @staticmethod
    def hasTransparency(state: "SoState") -> "SbBool":
        r"""hasTransparency(SoState state) -> SbBool"""
        return _coin.SoGLMultiTextureImageElement_hasTransparency(state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, int const unit, SoGLImage image, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        set(SoState state, SoNode node, SoGLImage image, SoMultiTextureImageElement::Model const model, SbColor blendColor)
        """
        return _coin.SoGLMultiTextureImageElement_set(*args)

    @staticmethod
    def get(*args) -> "SoGLImage *":
        r"""
        get(SoState state, int const unit, SoMultiTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage
        get(SoState state, SoMultiTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage
        """
        return _coin.SoGLMultiTextureImageElement_get(*args)

    @staticmethod
    def getMaxGLTextureSize() -> "int32_t":
        r"""getMaxGLTextureSize() -> int32_t"""
        return _coin.SoGLMultiTextureImageElement_getMaxGLTextureSize()

# Register SoGLMultiTextureImageElement in _coin:
_coin.SoGLMultiTextureImageElement_swigregister(SoGLMultiTextureImageElement)

def SoGLMultiTextureImageElement_getClassTypeId() -> "SoType":
    r"""SoGLMultiTextureImageElement_getClassTypeId() -> SoType"""
    return _coin.SoGLMultiTextureImageElement_getClassTypeId()

def SoGLMultiTextureImageElement_getClassStackIndex() -> "int":
    r"""SoGLMultiTextureImageElement_getClassStackIndex() -> int"""
    return _coin.SoGLMultiTextureImageElement_getClassStackIndex()

def SoGLMultiTextureImageElement_createInstance() -> "void *":
    r"""SoGLMultiTextureImageElement_createInstance() -> void *"""
    return _coin.SoGLMultiTextureImageElement_createInstance()

def SoGLMultiTextureImageElement_initClass() -> "void":
    r"""SoGLMultiTextureImageElement_initClass()"""
    return _coin.SoGLMultiTextureImageElement_initClass()

def SoGLMultiTextureImageElement_restore(state: "SoState", unit: "int const") -> "void":
    r"""SoGLMultiTextureImageElement_restore(SoState state, int const unit)"""
    return _coin.SoGLMultiTextureImageElement_restore(state, unit)

def SoGLMultiTextureImageElement_hasTransparency(state: "SoState") -> "SbBool":
    r"""SoGLMultiTextureImageElement_hasTransparency(SoState state) -> SbBool"""
    return _coin.SoGLMultiTextureImageElement_hasTransparency(state)

def SoGLMultiTextureImageElement_set(*args) -> "void":
    r"""
    SoGLMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SoGLImage image, SoMultiTextureImageElement::Model const model, SbColor blendColor)
    SoGLMultiTextureImageElement_set(SoState state, SoNode node, SoGLImage image, SoMultiTextureImageElement::Model const model, SbColor blendColor)
    """
    return _coin.SoGLMultiTextureImageElement_set(*args)

def SoGLMultiTextureImageElement_get(*args) -> "SoGLImage *":
    r"""
    SoGLMultiTextureImageElement_get(SoState state, int const unit, SoMultiTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage
    SoGLMultiTextureImageElement_get(SoState state, SoMultiTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage
    """
    return _coin.SoGLMultiTextureImageElement_get(*args)

def SoGLMultiTextureImageElement_getMaxGLTextureSize() -> "int32_t":
    r"""SoGLMultiTextureImageElement_getMaxGLTextureSize() -> int32_t"""
    return _coin.SoGLMultiTextureImageElement_getMaxGLTextureSize()

class SoViewingMatrixElement(SoReplacedElement):
    r"""Proxy of C++ SoViewingMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoViewingMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoViewingMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoViewingMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoViewingMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoViewingMatrixElement self, SoState state)"""
        return _coin.SoViewingMatrixElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", ViewingMatrix: "SbMatrix") -> "void":
        r"""set(SoState state, SoNode node, SbMatrix ViewingMatrix)"""
        return _coin.SoViewingMatrixElement_set(state, node, ViewingMatrix)

    @staticmethod
    def get(state: "SoState") -> "SbMatrix const &":
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoViewingMatrixElement_get(state)

# Register SoViewingMatrixElement in _coin:
_coin.SoViewingMatrixElement_swigregister(SoViewingMatrixElement)

def SoViewingMatrixElement_getClassTypeId() -> "SoType":
    r"""SoViewingMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoViewingMatrixElement_getClassTypeId()

def SoViewingMatrixElement_getClassStackIndex() -> "int":
    r"""SoViewingMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoViewingMatrixElement_getClassStackIndex()

def SoViewingMatrixElement_createInstance() -> "void *":
    r"""SoViewingMatrixElement_createInstance() -> void *"""
    return _coin.SoViewingMatrixElement_createInstance()

def SoViewingMatrixElement_initClass() -> "void":
    r"""SoViewingMatrixElement_initClass()"""
    return _coin.SoViewingMatrixElement_initClass()

def SoViewingMatrixElement_set(state: "SoState", node: "SoNode", ViewingMatrix: "SbMatrix") -> "void":
    r"""SoViewingMatrixElement_set(SoState state, SoNode node, SbMatrix ViewingMatrix)"""
    return _coin.SoViewingMatrixElement_set(state, node, ViewingMatrix)

def SoViewingMatrixElement_get(state: "SoState") -> "SbMatrix const &":
    r"""SoViewingMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoViewingMatrixElement_get(state)

class SoGLViewingMatrixElement(SoViewingMatrixElement):
    r"""Proxy of C++ SoGLViewingMatrixElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLViewingMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLViewingMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLViewingMatrixElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLViewingMatrixElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLViewingMatrixElement self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLViewingMatrixElement self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLViewingMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewingMatrixElement_pop(self, state, prevTopElement)

    @staticmethod
    def getNodeId(state: "SoState") -> "SbUniqueId":
        r"""getNodeId(SoState state) -> SbUniqueId"""
        return _coin.SoGLViewingMatrixElement_getNodeId(state)

    @staticmethod
    def getResetMatrix(state: "SoState") -> "SbMatrix":
        r"""getResetMatrix(SoState state) -> SbMatrix"""
        return _coin.SoGLViewingMatrixElement_getResetMatrix(state)

# Register SoGLViewingMatrixElement in _coin:
_coin.SoGLViewingMatrixElement_swigregister(SoGLViewingMatrixElement)

def SoGLViewingMatrixElement_getClassTypeId() -> "SoType":
    r"""SoGLViewingMatrixElement_getClassTypeId() -> SoType"""
    return _coin.SoGLViewingMatrixElement_getClassTypeId()

def SoGLViewingMatrixElement_getClassStackIndex() -> "int":
    r"""SoGLViewingMatrixElement_getClassStackIndex() -> int"""
    return _coin.SoGLViewingMatrixElement_getClassStackIndex()

def SoGLViewingMatrixElement_createInstance() -> "void *":
    r"""SoGLViewingMatrixElement_createInstance() -> void *"""
    return _coin.SoGLViewingMatrixElement_createInstance()

def SoGLViewingMatrixElement_initClass() -> "void":
    r"""SoGLViewingMatrixElement_initClass()"""
    return _coin.SoGLViewingMatrixElement_initClass()

def SoGLViewingMatrixElement_getNodeId(state: "SoState") -> "SbUniqueId":
    r"""SoGLViewingMatrixElement_getNodeId(SoState state) -> SbUniqueId"""
    return _coin.SoGLViewingMatrixElement_getNodeId(state)

def SoGLViewingMatrixElement_getResetMatrix(state: "SoState") -> "SbMatrix":
    r"""SoGLViewingMatrixElement_getResetMatrix(SoState state) -> SbMatrix"""
    return _coin.SoGLViewingMatrixElement_getResetMatrix(state)

class SoViewVolumeElement(SoReplacedElement):
    r"""Proxy of C++ SoViewVolumeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoViewVolumeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoViewVolumeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoViewVolumeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoViewVolumeElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoViewVolumeElement self, SoState state)"""
        return _coin.SoViewVolumeElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", viewVolume: "SbViewVolume") -> "void":
        r"""set(SoState state, SoNode node, SbViewVolume viewVolume)"""
        return _coin.SoViewVolumeElement_set(state, node, viewVolume)

    @staticmethod
    def get(state: "SoState") -> "SbViewVolume const &":
        r"""get(SoState state) -> SbViewVolume"""
        return _coin.SoViewVolumeElement_get(state)

# Register SoViewVolumeElement in _coin:
_coin.SoViewVolumeElement_swigregister(SoViewVolumeElement)

def SoViewVolumeElement_getClassTypeId() -> "SoType":
    r"""SoViewVolumeElement_getClassTypeId() -> SoType"""
    return _coin.SoViewVolumeElement_getClassTypeId()

def SoViewVolumeElement_getClassStackIndex() -> "int":
    r"""SoViewVolumeElement_getClassStackIndex() -> int"""
    return _coin.SoViewVolumeElement_getClassStackIndex()

def SoViewVolumeElement_createInstance() -> "void *":
    r"""SoViewVolumeElement_createInstance() -> void *"""
    return _coin.SoViewVolumeElement_createInstance()

def SoViewVolumeElement_initClass() -> "void":
    r"""SoViewVolumeElement_initClass()"""
    return _coin.SoViewVolumeElement_initClass()

def SoViewVolumeElement_set(state: "SoState", node: "SoNode", viewVolume: "SbViewVolume") -> "void":
    r"""SoViewVolumeElement_set(SoState state, SoNode node, SbViewVolume viewVolume)"""
    return _coin.SoViewVolumeElement_set(state, node, viewVolume)

def SoViewVolumeElement_get(state: "SoState") -> "SbViewVolume const &":
    r"""SoViewVolumeElement_get(SoState state) -> SbViewVolume"""
    return _coin.SoViewVolumeElement_get(state)

class SoGLShapeHintsElement(SoShapeHintsElement):
    r"""Proxy of C++ SoGLShapeHintsElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLShapeHintsElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLShapeHintsElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLShapeHintsElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLShapeHintsElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLShapeHintsElement self, SoState state)"""
        return _coin.SoGLShapeHintsElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLShapeHintsElement self, SoState state)"""
        return _coin.SoGLShapeHintsElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLShapeHintsElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLShapeHintsElement_pop(self, state, prevTopElement)

    @staticmethod
    def forceSend(*args) -> "void":
        r"""
        forceSend(SoState state, SbBool const twoside)
        forceSend(SoState state, SbBool const ccw, SbBool const cull)
        forceSend(SoState state, SbBool const ccw, SbBool const cull, SbBool const twoside)
        """
        return _coin.SoGLShapeHintsElement_forceSend(*args)

# Register SoGLShapeHintsElement in _coin:
_coin.SoGLShapeHintsElement_swigregister(SoGLShapeHintsElement)

def SoGLShapeHintsElement_getClassTypeId() -> "SoType":
    r"""SoGLShapeHintsElement_getClassTypeId() -> SoType"""
    return _coin.SoGLShapeHintsElement_getClassTypeId()

def SoGLShapeHintsElement_getClassStackIndex() -> "int":
    r"""SoGLShapeHintsElement_getClassStackIndex() -> int"""
    return _coin.SoGLShapeHintsElement_getClassStackIndex()

def SoGLShapeHintsElement_createInstance() -> "void *":
    r"""SoGLShapeHintsElement_createInstance() -> void *"""
    return _coin.SoGLShapeHintsElement_createInstance()

def SoGLShapeHintsElement_initClass() -> "void":
    r"""SoGLShapeHintsElement_initClass()"""
    return _coin.SoGLShapeHintsElement_initClass()

def SoGLShapeHintsElement_forceSend(*args) -> "void":
    r"""
    SoGLShapeHintsElement_forceSend(SoState state, SbBool const twoside)
    SoGLShapeHintsElement_forceSend(SoState state, SbBool const ccw, SbBool const cull)
    SoGLShapeHintsElement_forceSend(SoState state, SbBool const ccw, SbBool const cull, SbBool const twoside)
    """
    return _coin.SoGLShapeHintsElement_forceSend(*args)

class SoShapeStyleElement(SoElement):
    r"""Proxy of C++ SoShapeStyleElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoShapeStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoShapeStyleElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShapeStyleElement_initClass()
    LIGHTING = _coin.SoShapeStyleElement_LIGHTING
    
    TEXENABLED = _coin.SoShapeStyleElement_TEXENABLED
    
    TEXFUNC = _coin.SoShapeStyleElement_TEXFUNC
    
    BBOXCMPLX = _coin.SoShapeStyleElement_BBOXCMPLX
    
    INVISIBLE = _coin.SoShapeStyleElement_INVISIBLE
    
    ABORTCB = _coin.SoShapeStyleElement_ABORTCB
    
    OVERRIDE = _coin.SoShapeStyleElement_OVERRIDE
    
    TEX3ENABLED = _coin.SoShapeStyleElement_TEX3ENABLED
    
    BIGIMAGE = _coin.SoShapeStyleElement_BIGIMAGE
    
    BUMPMAP = _coin.SoShapeStyleElement_BUMPMAP
    
    VERTEXARRAY = _coin.SoShapeStyleElement_VERTEXARRAY
    
    TRANSP_TEXTURE = _coin.SoShapeStyleElement_TRANSP_TEXTURE
    
    TRANSP_MATERIAL = _coin.SoShapeStyleElement_TRANSP_MATERIAL
    
    TRANSP_SORTED_TRIANGLES = _coin.SoShapeStyleElement_TRANSP_SORTED_TRIANGLES
    
    SHADOWMAP = _coin.SoShapeStyleElement_SHADOWMAP
    
    SHADOWS = _coin.SoShapeStyleElement_SHADOWS
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoShapeStyleElement self, SoState state)"""
        return _coin.SoShapeStyleElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoShapeStyleElement self, SoState state)"""
        return _coin.SoShapeStyleElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoShapeStyleElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoShapeStyleElement_pop(self, state, prevTopElement)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoShapeStyleElement self, SoElement element) -> SbBool"""
        return _coin.SoShapeStyleElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoShapeStyleElement self) -> SoElement"""
        return _coin.SoShapeStyleElement_copyMatchInfo(self)

    @staticmethod
    def get(state: "SoState") -> "SoShapeStyleElement const *":
        r"""get(SoState state) -> SoShapeStyleElement"""
        return _coin.SoShapeStyleElement_get(state)

    def getFlags(self) -> "unsigned int":
        r"""getFlags(SoShapeStyleElement self) -> unsigned int"""
        return _coin.SoShapeStyleElement_getFlags(self)

    def mightNotRender(self) -> "SbBool":
        r"""mightNotRender(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_mightNotRender(self)

    def needNormals(self) -> "SbBool":
        r"""needNormals(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_needNormals(self)

    def needTexCoords(self) -> "SbBool":
        r"""needTexCoords(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_needTexCoords(self)

    def getRenderCaseMask(self) -> "int":
        r"""getRenderCaseMask(SoShapeStyleElement self) -> int"""
        return _coin.SoShapeStyleElement_getRenderCaseMask(self)

    @staticmethod
    def setDrawStyle(state: "SoState", value: "int32_t const") -> "void":
        r"""setDrawStyle(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setDrawStyle(state, value)

    @staticmethod
    def setComplexityType(state: "SoState", value: "int32_t const") -> "void":
        r"""setComplexityType(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setComplexityType(state, value)

    @staticmethod
    def setTransparencyType(state: "SoState", value: "int32_t const") -> "void":
        r"""setTransparencyType(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setTransparencyType(state, value)

    @staticmethod
    def setTextureEnabled(state: "SoState", value: "SbBool const") -> "void":
        r"""setTextureEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTextureEnabled(state, value)

    @staticmethod
    def setTexture3Enabled(state: "SoState", value: "SbBool const") -> "void":
        r"""setTexture3Enabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTexture3Enabled(state, value)

    @staticmethod
    def setTextureFunction(state: "SoState", value: "SbBool const") -> "void":
        r"""setTextureFunction(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTextureFunction(state, value)

    @staticmethod
    def setLightModel(state: "SoState", value: "int32_t const") -> "void":
        r"""setLightModel(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setLightModel(state, value)

    @staticmethod
    def setOverrides(state: "SoState", value: "SbBool const") -> "void":
        r"""setOverrides(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setOverrides(state, value)

    @staticmethod
    def isScreenDoor(state: "SoState") -> "SbBool":
        r"""isScreenDoor(SoState state) -> SbBool"""
        return _coin.SoShapeStyleElement_isScreenDoor(state)

    @staticmethod
    def getTransparencyType(state: "SoState") -> "int":
        r"""getTransparencyType(SoState state) -> int"""
        return _coin.SoShapeStyleElement_getTransparencyType(state)

    def isTextureFunction(self) -> "SbBool":
        r"""isTextureFunction(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_isTextureFunction(self)

    @staticmethod
    def setBumpmapEnabled(state: "SoState", value: "SbBool const") -> "void":
        r"""setBumpmapEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setBumpmapEnabled(state, value)

    @staticmethod
    def setBigImageEnabled(state: "SoState", value: "SbBool const") -> "void":
        r"""setBigImageEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setBigImageEnabled(state, value)

    @staticmethod
    def setVertexArrayRendering(state: "SoState", value: "SbBool const") -> "void":
        r"""setVertexArrayRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setVertexArrayRendering(state, value)

    @staticmethod
    def setTransparentMaterial(state: "SoState", value: "SbBool const") -> "void":
        r"""setTransparentMaterial(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTransparentMaterial(state, value)

    @staticmethod
    def setTransparentTexture(state: "SoState", value: "SbBool const") -> "void":
        r"""setTransparentTexture(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTransparentTexture(state, value)

    @staticmethod
    def setShadowMapRendering(state: "SoState", value: "SbBool const") -> "void":
        r"""setShadowMapRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setShadowMapRendering(state, value)

    @staticmethod
    def setShadowsRendering(state: "SoState", value: "SbBool const") -> "void":
        r"""setShadowsRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setShadowsRendering(state, value)

# Register SoShapeStyleElement in _coin:
_coin.SoShapeStyleElement_swigregister(SoShapeStyleElement)

def SoShapeStyleElement_getClassTypeId() -> "SoType":
    r"""SoShapeStyleElement_getClassTypeId() -> SoType"""
    return _coin.SoShapeStyleElement_getClassTypeId()

def SoShapeStyleElement_getClassStackIndex() -> "int":
    r"""SoShapeStyleElement_getClassStackIndex() -> int"""
    return _coin.SoShapeStyleElement_getClassStackIndex()

def SoShapeStyleElement_createInstance() -> "void *":
    r"""SoShapeStyleElement_createInstance() -> void *"""
    return _coin.SoShapeStyleElement_createInstance()

def SoShapeStyleElement_initClass() -> "void":
    r"""SoShapeStyleElement_initClass()"""
    return _coin.SoShapeStyleElement_initClass()

def SoShapeStyleElement_get(state: "SoState") -> "SoShapeStyleElement const *":
    r"""SoShapeStyleElement_get(SoState state) -> SoShapeStyleElement"""
    return _coin.SoShapeStyleElement_get(state)

def SoShapeStyleElement_setDrawStyle(state: "SoState", value: "int32_t const") -> "void":
    r"""SoShapeStyleElement_setDrawStyle(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setDrawStyle(state, value)

def SoShapeStyleElement_setComplexityType(state: "SoState", value: "int32_t const") -> "void":
    r"""SoShapeStyleElement_setComplexityType(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setComplexityType(state, value)

def SoShapeStyleElement_setTransparencyType(state: "SoState", value: "int32_t const") -> "void":
    r"""SoShapeStyleElement_setTransparencyType(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setTransparencyType(state, value)

def SoShapeStyleElement_setTextureEnabled(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setTextureEnabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTextureEnabled(state, value)

def SoShapeStyleElement_setTexture3Enabled(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setTexture3Enabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTexture3Enabled(state, value)

def SoShapeStyleElement_setTextureFunction(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setTextureFunction(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTextureFunction(state, value)

def SoShapeStyleElement_setLightModel(state: "SoState", value: "int32_t const") -> "void":
    r"""SoShapeStyleElement_setLightModel(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setLightModel(state, value)

def SoShapeStyleElement_setOverrides(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setOverrides(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setOverrides(state, value)

def SoShapeStyleElement_isScreenDoor(state: "SoState") -> "SbBool":
    r"""SoShapeStyleElement_isScreenDoor(SoState state) -> SbBool"""
    return _coin.SoShapeStyleElement_isScreenDoor(state)

def SoShapeStyleElement_getTransparencyType(state: "SoState") -> "int":
    r"""SoShapeStyleElement_getTransparencyType(SoState state) -> int"""
    return _coin.SoShapeStyleElement_getTransparencyType(state)

def SoShapeStyleElement_setBumpmapEnabled(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setBumpmapEnabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setBumpmapEnabled(state, value)

def SoShapeStyleElement_setBigImageEnabled(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setBigImageEnabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setBigImageEnabled(state, value)

def SoShapeStyleElement_setVertexArrayRendering(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setVertexArrayRendering(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setVertexArrayRendering(state, value)

def SoShapeStyleElement_setTransparentMaterial(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setTransparentMaterial(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTransparentMaterial(state, value)

def SoShapeStyleElement_setTransparentTexture(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setTransparentTexture(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTransparentTexture(state, value)

def SoShapeStyleElement_setShadowMapRendering(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setShadowMapRendering(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setShadowMapRendering(state, value)

def SoShapeStyleElement_setShadowsRendering(state: "SoState", value: "SbBool const") -> "void":
    r"""SoShapeStyleElement_setShadowsRendering(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setShadowsRendering(state, value)

class SoViewportRegionElement(SoElement):
    r"""Proxy of C++ SoViewportRegionElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoViewportRegionElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoViewportRegionElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoViewportRegionElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoViewportRegionElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoViewportRegionElement self, SoState state)"""
        return _coin.SoViewportRegionElement_init(self, state)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoViewportRegionElement self, SoElement element) -> SbBool"""
        return _coin.SoViewportRegionElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoViewportRegionElement self) -> SoElement"""
        return _coin.SoViewportRegionElement_copyMatchInfo(self)

    @staticmethod
    def set(state: "SoState", viewportRegion: "SbViewportRegion") -> "void":
        r"""set(SoState state, SbViewportRegion viewportRegion)"""
        return _coin.SoViewportRegionElement_set(state, viewportRegion)

    @staticmethod
    def get(state: "SoState") -> "SbViewportRegion const &":
        r"""get(SoState state) -> SbViewportRegion"""
        return _coin.SoViewportRegionElement_get(state)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoViewportRegionElement self, FILE * file)"""
        return _coin.SoViewportRegionElement_output(self, file)

# Register SoViewportRegionElement in _coin:
_coin.SoViewportRegionElement_swigregister(SoViewportRegionElement)

def SoViewportRegionElement_getClassTypeId() -> "SoType":
    r"""SoViewportRegionElement_getClassTypeId() -> SoType"""
    return _coin.SoViewportRegionElement_getClassTypeId()

def SoViewportRegionElement_getClassStackIndex() -> "int":
    r"""SoViewportRegionElement_getClassStackIndex() -> int"""
    return _coin.SoViewportRegionElement_getClassStackIndex()

def SoViewportRegionElement_createInstance() -> "void *":
    r"""SoViewportRegionElement_createInstance() -> void *"""
    return _coin.SoViewportRegionElement_createInstance()

def SoViewportRegionElement_initClass() -> "void":
    r"""SoViewportRegionElement_initClass()"""
    return _coin.SoViewportRegionElement_initClass()

def SoViewportRegionElement_set(state: "SoState", viewportRegion: "SbViewportRegion") -> "void":
    r"""SoViewportRegionElement_set(SoState state, SbViewportRegion viewportRegion)"""
    return _coin.SoViewportRegionElement_set(state, viewportRegion)

def SoViewportRegionElement_get(state: "SoState") -> "SbViewportRegion const &":
    r"""SoViewportRegionElement_get(SoState state) -> SbViewportRegion"""
    return _coin.SoViewportRegionElement_get(state)

class SoGLViewportRegionElement(SoViewportRegionElement):
    r"""Proxy of C++ SoGLViewportRegionElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLViewportRegionElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLViewportRegionElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLViewportRegionElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLViewportRegionElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLViewportRegionElement self, SoState state)"""
        return _coin.SoGLViewportRegionElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLViewportRegionElement self, SoState state)"""
        return _coin.SoGLViewportRegionElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLViewportRegionElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewportRegionElement_pop(self, state, prevTopElement)

# Register SoGLViewportRegionElement in _coin:
_coin.SoGLViewportRegionElement_swigregister(SoGLViewportRegionElement)

def SoGLViewportRegionElement_getClassTypeId() -> "SoType":
    r"""SoGLViewportRegionElement_getClassTypeId() -> SoType"""
    return _coin.SoGLViewportRegionElement_getClassTypeId()

def SoGLViewportRegionElement_getClassStackIndex() -> "int":
    r"""SoGLViewportRegionElement_getClassStackIndex() -> int"""
    return _coin.SoGLViewportRegionElement_getClassStackIndex()

def SoGLViewportRegionElement_createInstance() -> "void *":
    r"""SoGLViewportRegionElement_createInstance() -> void *"""
    return _coin.SoGLViewportRegionElement_createInstance()

def SoGLViewportRegionElement_initClass() -> "void":
    r"""SoGLViewportRegionElement_initClass()"""
    return _coin.SoGLViewportRegionElement_initClass()

class SoWindowElement(SoElement):
    r"""Proxy of C++ SoWindowElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWindowElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoWindowElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoWindowElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoWindowElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoWindowElement self, SoState state)"""
        return _coin.SoWindowElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoWindowElement self, SoState state)"""
        return _coin.SoWindowElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoWindowElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoWindowElement_pop(self, state, prevTopElement)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoWindowElement self, SoElement element) -> SbBool"""
        return _coin.SoWindowElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoWindowElement self) -> SoElement"""
        return _coin.SoWindowElement_copyMatchInfo(self)

    @staticmethod
    def set(state: "SoState", window: "void *", context: "void *", display: "void *", action: "SoGLRenderAction") -> "void":
        r"""set(SoState state, void * window, void * context, void * display, SoGLRenderAction action)"""
        return _coin.SoWindowElement_set(state, window, context, display, action)

    @staticmethod
    def get(state: "SoState", window: "void *&", context: "void *&", display: "void *&", action: "SoGLRenderAction *&") -> "void":
        r"""get(SoState state, void *& window, void *& context, void *& display, SoGLRenderAction *& action)"""
        return _coin.SoWindowElement_get(state, window, context, display, action)

# Register SoWindowElement in _coin:
_coin.SoWindowElement_swigregister(SoWindowElement)

def SoWindowElement_getClassTypeId() -> "SoType":
    r"""SoWindowElement_getClassTypeId() -> SoType"""
    return _coin.SoWindowElement_getClassTypeId()

def SoWindowElement_getClassStackIndex() -> "int":
    r"""SoWindowElement_getClassStackIndex() -> int"""
    return _coin.SoWindowElement_getClassStackIndex()

def SoWindowElement_createInstance() -> "void *":
    r"""SoWindowElement_createInstance() -> void *"""
    return _coin.SoWindowElement_createInstance()

def SoWindowElement_initClass() -> "void":
    r"""SoWindowElement_initClass()"""
    return _coin.SoWindowElement_initClass()

def SoWindowElement_set(state: "SoState", window: "void *", context: "void *", display: "void *", action: "SoGLRenderAction") -> "void":
    r"""SoWindowElement_set(SoState state, void * window, void * context, void * display, SoGLRenderAction action)"""
    return _coin.SoWindowElement_set(state, window, context, display, action)

def SoWindowElement_get(state: "SoState", window: "void *&", context: "void *&", display: "void *&", action: "SoGLRenderAction *&") -> "void":
    r"""SoWindowElement_get(SoState state, void *& window, void *& context, void *& display, SoGLRenderAction *& action)"""
    return _coin.SoWindowElement_get(state, window, context, display, action)

class SoGLCacheContextElement(SoElement):
    r"""Proxy of C++ SoGLCacheContextElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLCacheContextElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLCacheContextElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLCacheContextElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLCacheContextElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLCacheContextElement self, SoState state)"""
        return _coin.SoGLCacheContextElement_init(self, state)

    def matches(self, elt: "SoElement") -> "SbBool":
        r"""matches(SoGLCacheContextElement self, SoElement elt) -> SbBool"""
        return _coin.SoGLCacheContextElement_matches(self, elt)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoGLCacheContextElement self) -> SoElement"""
        return _coin.SoGLCacheContextElement_copyMatchInfo(self)

    @staticmethod
    def set(state: "SoState", context: "int", twopasstransparency: "SbBool", remoterendering: "SbBool") -> "void":
        r"""set(SoState state, int context, SbBool twopasstransparency, SbBool remoterendering)"""
        return _coin.SoGLCacheContextElement_set(state, context, twopasstransparency, remoterendering)

    @staticmethod
    def get(state: "SoState") -> "int":
        r"""get(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_get(state)

    @staticmethod
    def getExtID(str: "char const *") -> "int":
        r"""getExtID(char const * str) -> int"""
        return _coin.SoGLCacheContextElement_getExtID(str)

    @staticmethod
    def getOpenGLVersion(state: "SoState", major: "int &", minor: "int &") -> "void":
        r"""getOpenGLVersion(SoState state, int & major, int & minor)"""
        return _coin.SoGLCacheContextElement_getOpenGLVersion(state, major, minor)

    @staticmethod
    def extSupported(state: "SoState", extid: "int") -> "SbBool":
        r"""extSupported(SoState state, int extid) -> SbBool"""
        return _coin.SoGLCacheContextElement_extSupported(state, extid)

    @staticmethod
    def areMipMapsFast(state: "SoState") -> "SbBool":
        r"""areMipMapsFast(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_areMipMapsFast(state)
    DO_AUTO_CACHE = _coin.SoGLCacheContextElement_DO_AUTO_CACHE
    
    DONT_AUTO_CACHE = _coin.SoGLCacheContextElement_DONT_AUTO_CACHE
    

    @staticmethod
    def shouldAutoCache(state: "SoState", bits: "int") -> "void":
        r"""shouldAutoCache(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_shouldAutoCache(state, bits)

    @staticmethod
    def setAutoCacheBits(state: "SoState", bits: "int") -> "void":
        r"""setAutoCacheBits(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_setAutoCacheBits(state, bits)

    @staticmethod
    def resetAutoCacheBits(state: "SoState") -> "int":
        r"""resetAutoCacheBits(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_resetAutoCacheBits(state)

    @staticmethod
    def getIsRemoteRendering(state: "SoState") -> "SbBool":
        r"""getIsRemoteRendering(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_getIsRemoteRendering(state)

    @staticmethod
    def getUniqueCacheContext() -> "uint32_t":
        r"""getUniqueCacheContext() -> uint32_t"""
        return _coin.SoGLCacheContextElement_getUniqueCacheContext()

    @staticmethod
    def scheduleDeleteCallback(contextid: "uint32_t const", cb: "SoScheduleDeleteCB *", closure: "void *") -> "void":
        r"""scheduleDeleteCallback(uint32_t const contextid, SoScheduleDeleteCB * cb, void * closure)"""
        return _coin.SoGLCacheContextElement_scheduleDeleteCallback(contextid, cb, closure)

    @staticmethod
    def incNumShapes(state: "SoState") -> "void":
        r"""incNumShapes(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumShapes(state)

    @staticmethod
    def getNumShapes(state: "SoState") -> "int":
        r"""getNumShapes(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumShapes(state)

    @staticmethod
    def incNumSeparators(state: "SoState") -> "void":
        r"""incNumSeparators(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumSeparators(state)

    @staticmethod
    def getNumSeparators(state: "SoState") -> "int":
        r"""getNumSeparators(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumSeparators(state)

# Register SoGLCacheContextElement in _coin:
_coin.SoGLCacheContextElement_swigregister(SoGLCacheContextElement)

def SoGLCacheContextElement_getClassTypeId() -> "SoType":
    r"""SoGLCacheContextElement_getClassTypeId() -> SoType"""
    return _coin.SoGLCacheContextElement_getClassTypeId()

def SoGLCacheContextElement_getClassStackIndex() -> "int":
    r"""SoGLCacheContextElement_getClassStackIndex() -> int"""
    return _coin.SoGLCacheContextElement_getClassStackIndex()

def SoGLCacheContextElement_createInstance() -> "void *":
    r"""SoGLCacheContextElement_createInstance() -> void *"""
    return _coin.SoGLCacheContextElement_createInstance()

def SoGLCacheContextElement_initClass() -> "void":
    r"""SoGLCacheContextElement_initClass()"""
    return _coin.SoGLCacheContextElement_initClass()

def SoGLCacheContextElement_set(state: "SoState", context: "int", twopasstransparency: "SbBool", remoterendering: "SbBool") -> "void":
    r"""SoGLCacheContextElement_set(SoState state, int context, SbBool twopasstransparency, SbBool remoterendering)"""
    return _coin.SoGLCacheContextElement_set(state, context, twopasstransparency, remoterendering)

def SoGLCacheContextElement_get(state: "SoState") -> "int":
    r"""SoGLCacheContextElement_get(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_get(state)

def SoGLCacheContextElement_getExtID(str: "char const *") -> "int":
    r"""SoGLCacheContextElement_getExtID(char const * str) -> int"""
    return _coin.SoGLCacheContextElement_getExtID(str)

def SoGLCacheContextElement_getOpenGLVersion(state: "SoState", major: "int &", minor: "int &") -> "void":
    r"""SoGLCacheContextElement_getOpenGLVersion(SoState state, int & major, int & minor)"""
    return _coin.SoGLCacheContextElement_getOpenGLVersion(state, major, minor)

def SoGLCacheContextElement_extSupported(state: "SoState", extid: "int") -> "SbBool":
    r"""SoGLCacheContextElement_extSupported(SoState state, int extid) -> SbBool"""
    return _coin.SoGLCacheContextElement_extSupported(state, extid)

def SoGLCacheContextElement_areMipMapsFast(state: "SoState") -> "SbBool":
    r"""SoGLCacheContextElement_areMipMapsFast(SoState state) -> SbBool"""
    return _coin.SoGLCacheContextElement_areMipMapsFast(state)

def SoGLCacheContextElement_shouldAutoCache(state: "SoState", bits: "int") -> "void":
    r"""SoGLCacheContextElement_shouldAutoCache(SoState state, int bits)"""
    return _coin.SoGLCacheContextElement_shouldAutoCache(state, bits)

def SoGLCacheContextElement_setAutoCacheBits(state: "SoState", bits: "int") -> "void":
    r"""SoGLCacheContextElement_setAutoCacheBits(SoState state, int bits)"""
    return _coin.SoGLCacheContextElement_setAutoCacheBits(state, bits)

def SoGLCacheContextElement_resetAutoCacheBits(state: "SoState") -> "int":
    r"""SoGLCacheContextElement_resetAutoCacheBits(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_resetAutoCacheBits(state)

def SoGLCacheContextElement_getIsRemoteRendering(state: "SoState") -> "SbBool":
    r"""SoGLCacheContextElement_getIsRemoteRendering(SoState state) -> SbBool"""
    return _coin.SoGLCacheContextElement_getIsRemoteRendering(state)

def SoGLCacheContextElement_getUniqueCacheContext() -> "uint32_t":
    r"""SoGLCacheContextElement_getUniqueCacheContext() -> uint32_t"""
    return _coin.SoGLCacheContextElement_getUniqueCacheContext()

def SoGLCacheContextElement_scheduleDeleteCallback(contextid: "uint32_t const", cb: "SoScheduleDeleteCB *", closure: "void *") -> "void":
    r"""SoGLCacheContextElement_scheduleDeleteCallback(uint32_t const contextid, SoScheduleDeleteCB * cb, void * closure)"""
    return _coin.SoGLCacheContextElement_scheduleDeleteCallback(contextid, cb, closure)

def SoGLCacheContextElement_incNumShapes(state: "SoState") -> "void":
    r"""SoGLCacheContextElement_incNumShapes(SoState state)"""
    return _coin.SoGLCacheContextElement_incNumShapes(state)

def SoGLCacheContextElement_getNumShapes(state: "SoState") -> "int":
    r"""SoGLCacheContextElement_getNumShapes(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_getNumShapes(state)

def SoGLCacheContextElement_incNumSeparators(state: "SoState") -> "void":
    r"""SoGLCacheContextElement_incNumSeparators(SoState state)"""
    return _coin.SoGLCacheContextElement_incNumSeparators(state)

def SoGLCacheContextElement_getNumSeparators(state: "SoState") -> "int":
    r"""SoGLCacheContextElement_getNumSeparators(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_getNumSeparators(state)

class SoGLDisplayList(object):
    r"""Proxy of C++ SoGLDisplayList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    DISPLAY_LIST = _coin.SoGLDisplayList_DISPLAY_LIST
    
    TEXTURE_OBJECT = _coin.SoGLDisplayList_TEXTURE_OBJECT
    

    def __init__(self, state: "SoState", type: "SoGLDisplayList::Type", allocnum: "int"=1, mipmaptexobj: "SbBool"=0):
        r"""__init__(SoGLDisplayList self, SoState state, SoGLDisplayList::Type type, int allocnum=1, SbBool mipmaptexobj=0) -> SoGLDisplayList"""
        _coin.SoGLDisplayList_swiginit(self, _coin.new_SoGLDisplayList(state, type, allocnum, mipmaptexobj))

    def ref(self) -> "void":
        r"""ref(SoGLDisplayList self)"""
        return _coin.SoGLDisplayList_ref(self)

    def unref(self, state: "SoState"=None) -> "void":
        r"""unref(SoGLDisplayList self, SoState state=None)"""
        return _coin.SoGLDisplayList_unref(self, state)

    def open(self, state: "SoState", index: "int"=0) -> "void":
        r"""open(SoGLDisplayList self, SoState state, int index=0)"""
        return _coin.SoGLDisplayList_open(self, state, index)

    def close(self, state: "SoState") -> "void":
        r"""close(SoGLDisplayList self, SoState state)"""
        return _coin.SoGLDisplayList_close(self, state)

    def call(self, state: "SoState", index: "int"=0) -> "void":
        r"""call(SoGLDisplayList self, SoState state, int index=0)"""
        return _coin.SoGLDisplayList_call(self, state, index)

    def addDependency(self, state: "SoState") -> "void":
        r"""addDependency(SoGLDisplayList self, SoState state)"""
        return _coin.SoGLDisplayList_addDependency(self, state)

    def isMipMapTextureObject(self) -> "SbBool":
        r"""isMipMapTextureObject(SoGLDisplayList self) -> SbBool"""
        return _coin.SoGLDisplayList_isMipMapTextureObject(self)

    def getType(self) -> "SoGLDisplayList::Type":
        r"""getType(SoGLDisplayList self) -> SoGLDisplayList::Type"""
        return _coin.SoGLDisplayList_getType(self)

    def getNumAllocated(self) -> "int":
        r"""getNumAllocated(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getNumAllocated(self)

    def getFirstIndex(self) -> "unsigned int":
        r"""getFirstIndex(SoGLDisplayList self) -> unsigned int"""
        return _coin.SoGLDisplayList_getFirstIndex(self)

    def getContext(self) -> "int":
        r"""getContext(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getContext(self)

    def setTextureTarget(self, target: "int") -> "void":
        r"""setTextureTarget(SoGLDisplayList self, int target)"""
        return _coin.SoGLDisplayList_setTextureTarget(self, target)

    def getTextureTarget(self) -> "int":
        r"""getTextureTarget(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getTextureTarget(self)

# Register SoGLDisplayList in _coin:
_coin.SoGLDisplayList_swigregister(SoGLDisplayList)

class SoGLColorIndexElement(SoReplacedElement):
    r"""Proxy of C++ SoGLColorIndexElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLColorIndexElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLColorIndexElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLColorIndexElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLColorIndexElement_initClass()

    @staticmethod
    def isColorIndexMode(state: "SoState") -> "SbBool":
        r"""isColorIndexMode(SoState state) -> SbBool"""
        return _coin.SoGLColorIndexElement_isColorIndexMode(state)

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLColorIndexElement self, SoState state)"""
        return _coin.SoGLColorIndexElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numindices: "int32_t const", indices: "int32_t const *const") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numindices, int32_t const *const indices)"""
        return _coin.SoGLColorIndexElement_set(state, node, numindices, indices)

    @staticmethod
    def getInstance(state: "SoState") -> "SoGLColorIndexElement const *":
        r"""getInstance(SoState state) -> SoGLColorIndexElement"""
        return _coin.SoGLColorIndexElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoGLColorIndexElement self) -> int32_t"""
        return _coin.SoGLColorIndexElement_getNum(self)

    def get(self, index: "int const") -> "int32_t":
        r"""get(SoGLColorIndexElement self, int const index) -> int32_t"""
        return _coin.SoGLColorIndexElement_get(self, index)

    @staticmethod
    def getDefault() -> "int32_t":
        r"""getDefault() -> int32_t"""
        return _coin.SoGLColorIndexElement_getDefault()

# Register SoGLColorIndexElement in _coin:
_coin.SoGLColorIndexElement_swigregister(SoGLColorIndexElement)

def SoGLColorIndexElement_getClassTypeId() -> "SoType":
    r"""SoGLColorIndexElement_getClassTypeId() -> SoType"""
    return _coin.SoGLColorIndexElement_getClassTypeId()

def SoGLColorIndexElement_getClassStackIndex() -> "int":
    r"""SoGLColorIndexElement_getClassStackIndex() -> int"""
    return _coin.SoGLColorIndexElement_getClassStackIndex()

def SoGLColorIndexElement_createInstance() -> "void *":
    r"""SoGLColorIndexElement_createInstance() -> void *"""
    return _coin.SoGLColorIndexElement_createInstance()

def SoGLColorIndexElement_initClass() -> "void":
    r"""SoGLColorIndexElement_initClass()"""
    return _coin.SoGLColorIndexElement_initClass()

def SoGLColorIndexElement_isColorIndexMode(state: "SoState") -> "SbBool":
    r"""SoGLColorIndexElement_isColorIndexMode(SoState state) -> SbBool"""
    return _coin.SoGLColorIndexElement_isColorIndexMode(state)

def SoGLColorIndexElement_set(state: "SoState", node: "SoNode", numindices: "int32_t const", indices: "int32_t const *const") -> "void":
    r"""SoGLColorIndexElement_set(SoState state, SoNode node, int32_t const numindices, int32_t const *const indices)"""
    return _coin.SoGLColorIndexElement_set(state, node, numindices, indices)

def SoGLColorIndexElement_getInstance(state: "SoState") -> "SoGLColorIndexElement const *":
    r"""SoGLColorIndexElement_getInstance(SoState state) -> SoGLColorIndexElement"""
    return _coin.SoGLColorIndexElement_getInstance(state)

def SoGLColorIndexElement_getDefault() -> "int32_t":
    r"""SoGLColorIndexElement_getDefault() -> int32_t"""
    return _coin.SoGLColorIndexElement_getDefault()

class SoListenerPositionElement(SoReplacedElement):
    r"""Proxy of C++ SoListenerPositionElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerPositionElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerPositionElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoListenerPositionElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoListenerPositionElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoListenerPositionElement self, SoState state)"""
        return _coin.SoListenerPositionElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", position: "SbVec3f", setbylistener: "SbBool") -> "void":
        r"""set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"""
        return _coin.SoListenerPositionElement_set(state, node, position, setbylistener)

    @staticmethod
    def get(state: "SoState") -> "SbVec3f const &":
        r"""get(SoState state) -> SbVec3f"""
        return _coin.SoListenerPositionElement_get(state)

    @staticmethod
    def isSetByListener(state: "SoState") -> "SbBool":
        r"""isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerPositionElement_isSetByListener(state)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoListenerPositionElement self, FILE * file)"""
        return _coin.SoListenerPositionElement_output(self, file)

# Register SoListenerPositionElement in _coin:
_coin.SoListenerPositionElement_swigregister(SoListenerPositionElement)

def SoListenerPositionElement_getClassTypeId() -> "SoType":
    r"""SoListenerPositionElement_getClassTypeId() -> SoType"""
    return _coin.SoListenerPositionElement_getClassTypeId()

def SoListenerPositionElement_getClassStackIndex() -> "int":
    r"""SoListenerPositionElement_getClassStackIndex() -> int"""
    return _coin.SoListenerPositionElement_getClassStackIndex()

def SoListenerPositionElement_createInstance() -> "void *":
    r"""SoListenerPositionElement_createInstance() -> void *"""
    return _coin.SoListenerPositionElement_createInstance()

def SoListenerPositionElement_initClass() -> "void":
    r"""SoListenerPositionElement_initClass()"""
    return _coin.SoListenerPositionElement_initClass()

def SoListenerPositionElement_set(state: "SoState", node: "SoNode", position: "SbVec3f", setbylistener: "SbBool") -> "void":
    r"""SoListenerPositionElement_set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"""
    return _coin.SoListenerPositionElement_set(state, node, position, setbylistener)

def SoListenerPositionElement_get(state: "SoState") -> "SbVec3f const &":
    r"""SoListenerPositionElement_get(SoState state) -> SbVec3f"""
    return _coin.SoListenerPositionElement_get(state)

def SoListenerPositionElement_isSetByListener(state: "SoState") -> "SbBool":
    r"""SoListenerPositionElement_isSetByListener(SoState state) -> SbBool"""
    return _coin.SoListenerPositionElement_isSetByListener(state)

class SoListenerOrientationElement(SoReplacedElement):
    r"""Proxy of C++ SoListenerOrientationElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerOrientationElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerOrientationElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoListenerOrientationElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoListenerOrientationElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoListenerOrientationElement self, SoState state)"""
        return _coin.SoListenerOrientationElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", orientation: "SbRotation", setbylistener: "SbBool") -> "void":
        r"""set(SoState state, SoNode node, SbRotation orientation, SbBool setbylistener)"""
        return _coin.SoListenerOrientationElement_set(state, node, orientation, setbylistener)

    @staticmethod
    def get(state: "SoState") -> "SbRotation const &":
        r"""get(SoState state) -> SbRotation"""
        return _coin.SoListenerOrientationElement_get(state)

    @staticmethod
    def isSetByListener(state: "SoState") -> "SbBool":
        r"""isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerOrientationElement_isSetByListener(state)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoListenerOrientationElement self, FILE * file)"""
        return _coin.SoListenerOrientationElement_output(self, file)

# Register SoListenerOrientationElement in _coin:
_coin.SoListenerOrientationElement_swigregister(SoListenerOrientationElement)

def SoListenerOrientationElement_getClassTypeId() -> "SoType":
    r"""SoListenerOrientationElement_getClassTypeId() -> SoType"""
    return _coin.SoListenerOrientationElement_getClassTypeId()

def SoListenerOrientationElement_getClassStackIndex() -> "int":
    r"""SoListenerOrientationElement_getClassStackIndex() -> int"""
    return _coin.SoListenerOrientationElement_getClassStackIndex()

def SoListenerOrientationElement_createInstance() -> "void *":
    r"""SoListenerOrientationElement_createInstance() -> void *"""
    return _coin.SoListenerOrientationElement_createInstance()

def SoListenerOrientationElement_initClass() -> "void":
    r"""SoListenerOrientationElement_initClass()"""
    return _coin.SoListenerOrientationElement_initClass()

def SoListenerOrientationElement_set(state: "SoState", node: "SoNode", orientation: "SbRotation", setbylistener: "SbBool") -> "void":
    r"""SoListenerOrientationElement_set(SoState state, SoNode node, SbRotation orientation, SbBool setbylistener)"""
    return _coin.SoListenerOrientationElement_set(state, node, orientation, setbylistener)

def SoListenerOrientationElement_get(state: "SoState") -> "SbRotation const &":
    r"""SoListenerOrientationElement_get(SoState state) -> SbRotation"""
    return _coin.SoListenerOrientationElement_get(state)

def SoListenerOrientationElement_isSetByListener(state: "SoState") -> "SbBool":
    r"""SoListenerOrientationElement_isSetByListener(SoState state) -> SbBool"""
    return _coin.SoListenerOrientationElement_isSetByListener(state)

class SoListenerDopplerElement(SoReplacedElement):
    r"""Proxy of C++ SoListenerDopplerElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerDopplerElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerDopplerElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoListenerDopplerElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoListenerDopplerElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoListenerDopplerElement self, SoState state)"""
        return _coin.SoListenerDopplerElement_init(self, state)

    @staticmethod
    def setDopplerVelocity(state: "SoState", node: "SoNode", velocity: "SbVec3f") -> "void":
        r"""setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"""
        return _coin.SoListenerDopplerElement_setDopplerVelocity(state, node, velocity)

    @staticmethod
    def setDopplerFactor(state: "SoState", node: "SoNode", factor: "float") -> "void":
        r"""setDopplerFactor(SoState state, SoNode node, float factor)"""
        return _coin.SoListenerDopplerElement_setDopplerFactor(state, node, factor)

    @staticmethod
    def getDopplerVelocity(state: "SoState") -> "SbVec3f const &":
        r"""getDopplerVelocity(SoState state) -> SbVec3f"""
        return _coin.SoListenerDopplerElement_getDopplerVelocity(state)

    @staticmethod
    def getDopplerFactor(state: "SoState") -> "float":
        r"""getDopplerFactor(SoState state) -> float"""
        return _coin.SoListenerDopplerElement_getDopplerFactor(state)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoListenerDopplerElement self, FILE * file)"""
        return _coin.SoListenerDopplerElement_output(self, file)

# Register SoListenerDopplerElement in _coin:
_coin.SoListenerDopplerElement_swigregister(SoListenerDopplerElement)

def SoListenerDopplerElement_getClassTypeId() -> "SoType":
    r"""SoListenerDopplerElement_getClassTypeId() -> SoType"""
    return _coin.SoListenerDopplerElement_getClassTypeId()

def SoListenerDopplerElement_getClassStackIndex() -> "int":
    r"""SoListenerDopplerElement_getClassStackIndex() -> int"""
    return _coin.SoListenerDopplerElement_getClassStackIndex()

def SoListenerDopplerElement_createInstance() -> "void *":
    r"""SoListenerDopplerElement_createInstance() -> void *"""
    return _coin.SoListenerDopplerElement_createInstance()

def SoListenerDopplerElement_initClass() -> "void":
    r"""SoListenerDopplerElement_initClass()"""
    return _coin.SoListenerDopplerElement_initClass()

def SoListenerDopplerElement_setDopplerVelocity(state: "SoState", node: "SoNode", velocity: "SbVec3f") -> "void":
    r"""SoListenerDopplerElement_setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"""
    return _coin.SoListenerDopplerElement_setDopplerVelocity(state, node, velocity)

def SoListenerDopplerElement_setDopplerFactor(state: "SoState", node: "SoNode", factor: "float") -> "void":
    r"""SoListenerDopplerElement_setDopplerFactor(SoState state, SoNode node, float factor)"""
    return _coin.SoListenerDopplerElement_setDopplerFactor(state, node, factor)

def SoListenerDopplerElement_getDopplerVelocity(state: "SoState") -> "SbVec3f const &":
    r"""SoListenerDopplerElement_getDopplerVelocity(SoState state) -> SbVec3f"""
    return _coin.SoListenerDopplerElement_getDopplerVelocity(state)

def SoListenerDopplerElement_getDopplerFactor(state: "SoState") -> "float":
    r"""SoListenerDopplerElement_getDopplerFactor(SoState state) -> float"""
    return _coin.SoListenerDopplerElement_getDopplerFactor(state)

class SoListenerGainElement(SoFloatElement):
    r"""Proxy of C++ SoListenerGainElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerGainElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerGainElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoListenerGainElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoListenerGainElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoListenerGainElement self, SoState state)"""
        return _coin.SoListenerGainElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, float const gain)
        set(SoState state, float const gain)
        """
        return _coin.SoListenerGainElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "float":
        r"""get(SoState state) -> float"""
        return _coin.SoListenerGainElement_get(state)

# Register SoListenerGainElement in _coin:
_coin.SoListenerGainElement_swigregister(SoListenerGainElement)

def SoListenerGainElement_getClassTypeId() -> "SoType":
    r"""SoListenerGainElement_getClassTypeId() -> SoType"""
    return _coin.SoListenerGainElement_getClassTypeId()

def SoListenerGainElement_getClassStackIndex() -> "int":
    r"""SoListenerGainElement_getClassStackIndex() -> int"""
    return _coin.SoListenerGainElement_getClassStackIndex()

def SoListenerGainElement_createInstance() -> "void *":
    r"""SoListenerGainElement_createInstance() -> void *"""
    return _coin.SoListenerGainElement_createInstance()

def SoListenerGainElement_initClass() -> "void":
    r"""SoListenerGainElement_initClass()"""
    return _coin.SoListenerGainElement_initClass()

def SoListenerGainElement_set(*args) -> "void":
    r"""
    SoListenerGainElement_set(SoState state, SoNode node, float const gain)
    SoListenerGainElement_set(SoState state, float const gain)
    """
    return _coin.SoListenerGainElement_set(*args)

def SoListenerGainElement_get(state: "SoState") -> "float":
    r"""SoListenerGainElement_get(SoState state) -> float"""
    return _coin.SoListenerGainElement_get(state)

class SoSoundElement(SoReplacedElement):
    r"""Proxy of C++ SoSoundElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSoundElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoSoundElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSoundElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSoundElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoSoundElement self, SoState state)"""
        return _coin.SoSoundElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", scenegraphhassoundnode: "SbBool", soundnodeisplaying: "SbBool", ispartofactivescenegraph: "SbBool") -> "void":
        r"""set(SoState state, SoNode node, SbBool scenegraphhassoundnode, SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)"""
        return _coin.SoSoundElement_set(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph)

    @staticmethod
    def setSceneGraphHasSoundNode(state: "SoState", node: "SoNode", flag: "SbBool") -> "SbBool":
        r"""setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSceneGraphHasSoundNode(state, node, flag)

    @staticmethod
    def sceneGraphHasSoundNode(state: "SoState") -> "SbBool":
        r"""sceneGraphHasSoundNode(SoState state) -> SbBool"""
        return _coin.SoSoundElement_sceneGraphHasSoundNode(state)

    @staticmethod
    def setSoundNodeIsPlaying(state: "SoState", node: "SoNode", flag: "SbBool") -> "SbBool":
        r"""setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSoundNodeIsPlaying(state, node, flag)

    @staticmethod
    def soundNodeIsPlaying(state: "SoState") -> "SbBool":
        r"""soundNodeIsPlaying(SoState state) -> SbBool"""
        return _coin.SoSoundElement_soundNodeIsPlaying(state)

    @staticmethod
    def setIsPartOfActiveSceneGraph(state: "SoState", node: "SoNode", flag: "SbBool") -> "SbBool":
        r"""setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setIsPartOfActiveSceneGraph(state, node, flag)

    @staticmethod
    def isPartOfActiveSceneGraph(state: "SoState") -> "SbBool":
        r"""isPartOfActiveSceneGraph(SoState state) -> SbBool"""
        return _coin.SoSoundElement_isPartOfActiveSceneGraph(state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoSoundElement self, SoState state)"""
        return _coin.SoSoundElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoSoundElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoSoundElement_pop(self, state, prevTopElement)

    def output(self, file: "FILE *") -> "void":
        r"""output(SoSoundElement self, FILE * file)"""
        return _coin.SoSoundElement_output(self, file)

# Register SoSoundElement in _coin:
_coin.SoSoundElement_swigregister(SoSoundElement)

def SoSoundElement_getClassTypeId() -> "SoType":
    r"""SoSoundElement_getClassTypeId() -> SoType"""
    return _coin.SoSoundElement_getClassTypeId()

def SoSoundElement_getClassStackIndex() -> "int":
    r"""SoSoundElement_getClassStackIndex() -> int"""
    return _coin.SoSoundElement_getClassStackIndex()

def SoSoundElement_createInstance() -> "void *":
    r"""SoSoundElement_createInstance() -> void *"""
    return _coin.SoSoundElement_createInstance()

def SoSoundElement_initClass() -> "void":
    r"""SoSoundElement_initClass()"""
    return _coin.SoSoundElement_initClass()

def SoSoundElement_set(state: "SoState", node: "SoNode", scenegraphhassoundnode: "SbBool", soundnodeisplaying: "SbBool", ispartofactivescenegraph: "SbBool") -> "void":
    r"""SoSoundElement_set(SoState state, SoNode node, SbBool scenegraphhassoundnode, SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)"""
    return _coin.SoSoundElement_set(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph)

def SoSoundElement_setSceneGraphHasSoundNode(state: "SoState", node: "SoNode", flag: "SbBool") -> "SbBool":
    r"""SoSoundElement_setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"""
    return _coin.SoSoundElement_setSceneGraphHasSoundNode(state, node, flag)

def SoSoundElement_sceneGraphHasSoundNode(state: "SoState") -> "SbBool":
    r"""SoSoundElement_sceneGraphHasSoundNode(SoState state) -> SbBool"""
    return _coin.SoSoundElement_sceneGraphHasSoundNode(state)

def SoSoundElement_setSoundNodeIsPlaying(state: "SoState", node: "SoNode", flag: "SbBool") -> "SbBool":
    r"""SoSoundElement_setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"""
    return _coin.SoSoundElement_setSoundNodeIsPlaying(state, node, flag)

def SoSoundElement_soundNodeIsPlaying(state: "SoState") -> "SbBool":
    r"""SoSoundElement_soundNodeIsPlaying(SoState state) -> SbBool"""
    return _coin.SoSoundElement_soundNodeIsPlaying(state)

def SoSoundElement_setIsPartOfActiveSceneGraph(state: "SoState", node: "SoNode", flag: "SbBool") -> "SbBool":
    r"""SoSoundElement_setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"""
    return _coin.SoSoundElement_setIsPartOfActiveSceneGraph(state, node, flag)

def SoSoundElement_isPartOfActiveSceneGraph(state: "SoState") -> "SbBool":
    r"""SoSoundElement_isPartOfActiveSceneGraph(SoState state) -> SbBool"""
    return _coin.SoSoundElement_isPartOfActiveSceneGraph(state)

class SoGLVBOElement(SoElement):
    r"""Proxy of C++ SoGLVBOElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLVBOElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLVBOElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLVBOElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLVBOElement_initClass()

    @staticmethod
    def shouldCreateVBO(state: "SoState", numdata: "int const") -> "SbBool":
        r"""shouldCreateVBO(SoState state, int const numdata) -> SbBool"""
        return _coin.SoGLVBOElement_shouldCreateVBO(state, numdata)

    @staticmethod
    def setVertexVBO(state: "SoState", vbo: "SoVBO *") -> "void":
        r"""setVertexVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setVertexVBO(state, vbo)

    @staticmethod
    def setNormalVBO(state: "SoState", vbo: "SoVBO *") -> "void":
        r"""setNormalVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setNormalVBO(state, vbo)

    @staticmethod
    def setColorVBO(state: "SoState", vbo: "SoVBO *") -> "void":
        r"""setColorVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setColorVBO(state, vbo)

    @staticmethod
    def setTexCoordVBO(state: "SoState", unit: "int const", vbo: "SoVBO *") -> "void":
        r"""setTexCoordVBO(SoState state, int const unit, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setTexCoordVBO(state, unit, vbo)

    @staticmethod
    def getInstance(state: "SoState") -> "SoGLVBOElement const *":
        r"""getInstance(SoState state) -> SoGLVBOElement"""
        return _coin.SoGLVBOElement_getInstance(state)

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLVBOElement self, SoState state)"""
        return _coin.SoGLVBOElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLVBOElement self, SoState state)"""
        return _coin.SoGLVBOElement_push(self, state)

    def pop(self, state: "SoState", prevtopelement: "SoElement") -> "void":
        r"""pop(SoGLVBOElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLVBOElement_pop(self, state, prevtopelement)

    def matches(self, elt: "SoElement") -> "SbBool":
        r"""matches(SoGLVBOElement self, SoElement elt) -> SbBool"""
        return _coin.SoGLVBOElement_matches(self, elt)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoGLVBOElement self) -> SoElement"""
        return _coin.SoGLVBOElement_copyMatchInfo(self)

    def getVertexVBO(self) -> "SoVBO *":
        r"""getVertexVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getVertexVBO(self)

    def getNormalVBO(self) -> "SoVBO *":
        r"""getNormalVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getNormalVBO(self)

    def getColorVBO(self) -> "SoVBO *":
        r"""getColorVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getColorVBO(self)

    def getNumTexCoordVBO(self) -> "int":
        r"""getNumTexCoordVBO(SoGLVBOElement self) -> int"""
        return _coin.SoGLVBOElement_getNumTexCoordVBO(self)

    def getTexCoordVBO(self, idx: "int const") -> "SoVBO *":
        r"""getTexCoordVBO(SoGLVBOElement self, int const idx) -> SoVBO *"""
        return _coin.SoGLVBOElement_getTexCoordVBO(self, idx)

# Register SoGLVBOElement in _coin:
_coin.SoGLVBOElement_swigregister(SoGLVBOElement)

def SoGLVBOElement_getClassTypeId() -> "SoType":
    r"""SoGLVBOElement_getClassTypeId() -> SoType"""
    return _coin.SoGLVBOElement_getClassTypeId()

def SoGLVBOElement_getClassStackIndex() -> "int":
    r"""SoGLVBOElement_getClassStackIndex() -> int"""
    return _coin.SoGLVBOElement_getClassStackIndex()

def SoGLVBOElement_createInstance() -> "void *":
    r"""SoGLVBOElement_createInstance() -> void *"""
    return _coin.SoGLVBOElement_createInstance()

def SoGLVBOElement_initClass() -> "void":
    r"""SoGLVBOElement_initClass()"""
    return _coin.SoGLVBOElement_initClass()

def SoGLVBOElement_shouldCreateVBO(state: "SoState", numdata: "int const") -> "SbBool":
    r"""SoGLVBOElement_shouldCreateVBO(SoState state, int const numdata) -> SbBool"""
    return _coin.SoGLVBOElement_shouldCreateVBO(state, numdata)

def SoGLVBOElement_setVertexVBO(state: "SoState", vbo: "SoVBO *") -> "void":
    r"""SoGLVBOElement_setVertexVBO(SoState state, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setVertexVBO(state, vbo)

def SoGLVBOElement_setNormalVBO(state: "SoState", vbo: "SoVBO *") -> "void":
    r"""SoGLVBOElement_setNormalVBO(SoState state, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setNormalVBO(state, vbo)

def SoGLVBOElement_setColorVBO(state: "SoState", vbo: "SoVBO *") -> "void":
    r"""SoGLVBOElement_setColorVBO(SoState state, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setColorVBO(state, vbo)

def SoGLVBOElement_setTexCoordVBO(state: "SoState", unit: "int const", vbo: "SoVBO *") -> "void":
    r"""SoGLVBOElement_setTexCoordVBO(SoState state, int const unit, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setTexCoordVBO(state, unit, vbo)

def SoGLVBOElement_getInstance(state: "SoState") -> "SoGLVBOElement const *":
    r"""SoGLVBOElement_getInstance(SoState state) -> SoGLVBOElement"""
    return _coin.SoGLVBOElement_getInstance(state)

class SoDepthBufferElement(SoElement):
    r"""Proxy of C++ SoDepthBufferElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDepthBufferElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoDepthBufferElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDepthBufferElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDepthBufferElement_initClass()
    NEVER = _coin.SoDepthBufferElement_NEVER
    
    ALWAYS = _coin.SoDepthBufferElement_ALWAYS
    
    LESS = _coin.SoDepthBufferElement_LESS
    
    LEQUAL = _coin.SoDepthBufferElement_LEQUAL
    
    EQUAL = _coin.SoDepthBufferElement_EQUAL
    
    GEQUAL = _coin.SoDepthBufferElement_GEQUAL
    
    GREATER = _coin.SoDepthBufferElement_GREATER
    
    NOTEQUAL = _coin.SoDepthBufferElement_NOTEQUAL
    

    @staticmethod
    def set(state: "SoState", test: "SbBool", write: "SbBool", function: "SoDepthBufferElement::DepthWriteFunction", range: "SbVec2f") -> "void":
        r"""set(SoState state, SbBool test, SbBool write, SoDepthBufferElement::DepthWriteFunction function, SbVec2f range)"""
        return _coin.SoDepthBufferElement_set(state, test, write, function, range)

    @staticmethod
    def get(state: "SoState", test_out: "SbBool &", write_out: "SbBool &", function_out: "SoDepthBufferElement::DepthWriteFunction &", range_out: "SbVec2f") -> "void":
        r"""get(SoState state, SbBool & test_out, SbBool & write_out, SoDepthBufferElement::DepthWriteFunction & function_out, SbVec2f range_out)"""
        return _coin.SoDepthBufferElement_get(state, test_out, write_out, function_out, range_out)

    @staticmethod
    def getTestEnable(state: "SoState") -> "SbBool":
        r"""getTestEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getTestEnable(state)

    @staticmethod
    def getWriteEnable(state: "SoState") -> "SbBool":
        r"""getWriteEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getWriteEnable(state)

    @staticmethod
    def getFunction(state: "SoState") -> "SoDepthBufferElement::DepthWriteFunction":
        r"""getFunction(SoState state) -> SoDepthBufferElement::DepthWriteFunction"""
        return _coin.SoDepthBufferElement_getFunction(state)

    @staticmethod
    def getRange(state: "SoState") -> "SbVec2f":
        r"""getRange(SoState state) -> SbVec2f"""
        return _coin.SoDepthBufferElement_getRange(state)

    def init(self, state: "SoState") -> "void":
        r"""init(SoDepthBufferElement self, SoState state)"""
        return _coin.SoDepthBufferElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoDepthBufferElement self, SoState state)"""
        return _coin.SoDepthBufferElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoDepthBufferElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoDepthBufferElement_pop(self, state, prevTopElement)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoDepthBufferElement self, SoElement element) -> SbBool"""
        return _coin.SoDepthBufferElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoDepthBufferElement self) -> SoElement"""
        return _coin.SoDepthBufferElement_copyMatchInfo(self)

# Register SoDepthBufferElement in _coin:
_coin.SoDepthBufferElement_swigregister(SoDepthBufferElement)

def SoDepthBufferElement_getClassTypeId() -> "SoType":
    r"""SoDepthBufferElement_getClassTypeId() -> SoType"""
    return _coin.SoDepthBufferElement_getClassTypeId()

def SoDepthBufferElement_getClassStackIndex() -> "int":
    r"""SoDepthBufferElement_getClassStackIndex() -> int"""
    return _coin.SoDepthBufferElement_getClassStackIndex()

def SoDepthBufferElement_createInstance() -> "void *":
    r"""SoDepthBufferElement_createInstance() -> void *"""
    return _coin.SoDepthBufferElement_createInstance()

def SoDepthBufferElement_initClass() -> "void":
    r"""SoDepthBufferElement_initClass()"""
    return _coin.SoDepthBufferElement_initClass()

def SoDepthBufferElement_set(state: "SoState", test: "SbBool", write: "SbBool", function: "SoDepthBufferElement::DepthWriteFunction", range: "SbVec2f") -> "void":
    r"""SoDepthBufferElement_set(SoState state, SbBool test, SbBool write, SoDepthBufferElement::DepthWriteFunction function, SbVec2f range)"""
    return _coin.SoDepthBufferElement_set(state, test, write, function, range)

def SoDepthBufferElement_get(state: "SoState", test_out: "SbBool &", write_out: "SbBool &", function_out: "SoDepthBufferElement::DepthWriteFunction &", range_out: "SbVec2f") -> "void":
    r"""SoDepthBufferElement_get(SoState state, SbBool & test_out, SbBool & write_out, SoDepthBufferElement::DepthWriteFunction & function_out, SbVec2f range_out)"""
    return _coin.SoDepthBufferElement_get(state, test_out, write_out, function_out, range_out)

def SoDepthBufferElement_getTestEnable(state: "SoState") -> "SbBool":
    r"""SoDepthBufferElement_getTestEnable(SoState state) -> SbBool"""
    return _coin.SoDepthBufferElement_getTestEnable(state)

def SoDepthBufferElement_getWriteEnable(state: "SoState") -> "SbBool":
    r"""SoDepthBufferElement_getWriteEnable(SoState state) -> SbBool"""
    return _coin.SoDepthBufferElement_getWriteEnable(state)

def SoDepthBufferElement_getFunction(state: "SoState") -> "SoDepthBufferElement::DepthWriteFunction":
    r"""SoDepthBufferElement_getFunction(SoState state) -> SoDepthBufferElement::DepthWriteFunction"""
    return _coin.SoDepthBufferElement_getFunction(state)

def SoDepthBufferElement_getRange(state: "SoState") -> "SbVec2f":
    r"""SoDepthBufferElement_getRange(SoState state) -> SbVec2f"""
    return _coin.SoDepthBufferElement_getRange(state)

class SoGLDepthBufferElement(SoDepthBufferElement):
    r"""Proxy of C++ SoGLDepthBufferElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLDepthBufferElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLDepthBufferElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLDepthBufferElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLDepthBufferElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLDepthBufferElement self, SoState state)"""
        return _coin.SoGLDepthBufferElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoGLDepthBufferElement self, SoState state)"""
        return _coin.SoGLDepthBufferElement_push(self, state)

    def pop(self, state: "SoState", prevTopElement: "SoElement") -> "void":
        r"""pop(SoGLDepthBufferElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDepthBufferElement_pop(self, state, prevTopElement)

# Register SoGLDepthBufferElement in _coin:
_coin.SoGLDepthBufferElement_swigregister(SoGLDepthBufferElement)

def SoGLDepthBufferElement_getClassTypeId() -> "SoType":
    r"""SoGLDepthBufferElement_getClassTypeId() -> SoType"""
    return _coin.SoGLDepthBufferElement_getClassTypeId()

def SoGLDepthBufferElement_getClassStackIndex() -> "int":
    r"""SoGLDepthBufferElement_getClassStackIndex() -> int"""
    return _coin.SoGLDepthBufferElement_getClassStackIndex()

def SoGLDepthBufferElement_createInstance() -> "void *":
    r"""SoGLDepthBufferElement_createInstance() -> void *"""
    return _coin.SoGLDepthBufferElement_createInstance()

def SoGLDepthBufferElement_initClass() -> "void":
    r"""SoGLDepthBufferElement_initClass()"""
    return _coin.SoGLDepthBufferElement_initClass()

class SoVertexAttributeElement(SoAccumulatedElement):
    r"""Proxy of C++ SoVertexAttributeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoVertexAttributeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVertexAttributeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVertexAttributeElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoVertexAttributeElement self, SoState state)"""
        return _coin.SoVertexAttributeElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoVertexAttributeElement self, SoState state)"""
        return _coin.SoVertexAttributeElement_push(self, state)

    @staticmethod
    def add(state: "SoState", attribdata: "SoVertexAttributeData *") -> "void":
        r"""add(SoState state, SoVertexAttributeData * attribdata)"""
        return _coin.SoVertexAttributeElement_add(state, attribdata)

    @staticmethod
    def getInstance(state: "SoState") -> "SoVertexAttributeElement const *":
        r"""getInstance(SoState state) -> SoVertexAttributeElement"""
        return _coin.SoVertexAttributeElement_getInstance(state)

    def getNumAttributes(self) -> "unsigned int":
        r"""getNumAttributes(SoVertexAttributeElement self) -> unsigned int"""
        return _coin.SoVertexAttributeElement_getNumAttributes(self)

    def applyToAttributes(self, func: "SoVertexAttributeElement::AttributeApplyFunc *", closure: "void *") -> "void":
        r"""applyToAttributes(SoVertexAttributeElement self, SoVertexAttributeElement::AttributeApplyFunc * func, void * closure)"""
        return _coin.SoVertexAttributeElement_applyToAttributes(self, func, closure)

# Register SoVertexAttributeElement in _coin:
_coin.SoVertexAttributeElement_swigregister(SoVertexAttributeElement)

def SoVertexAttributeElement_getClassTypeId() -> "SoType":
    r"""SoVertexAttributeElement_getClassTypeId() -> SoType"""
    return _coin.SoVertexAttributeElement_getClassTypeId()

def SoVertexAttributeElement_getClassStackIndex() -> "int":
    r"""SoVertexAttributeElement_getClassStackIndex() -> int"""
    return _coin.SoVertexAttributeElement_getClassStackIndex()

def SoVertexAttributeElement_createInstance() -> "void *":
    r"""SoVertexAttributeElement_createInstance() -> void *"""
    return _coin.SoVertexAttributeElement_createInstance()

def SoVertexAttributeElement_initClass() -> "void":
    r"""SoVertexAttributeElement_initClass()"""
    return _coin.SoVertexAttributeElement_initClass()

def SoVertexAttributeElement_add(state: "SoState", attribdata: "SoVertexAttributeData *") -> "void":
    r"""SoVertexAttributeElement_add(SoState state, SoVertexAttributeData * attribdata)"""
    return _coin.SoVertexAttributeElement_add(state, attribdata)

def SoVertexAttributeElement_getInstance(state: "SoState") -> "SoVertexAttributeElement const *":
    r"""SoVertexAttributeElement_getInstance(SoState state) -> SoVertexAttributeElement"""
    return _coin.SoVertexAttributeElement_getInstance(state)

class SoGLVertexAttributeElement(SoVertexAttributeElement):
    r"""Proxy of C++ SoGLVertexAttributeElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLVertexAttributeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLVertexAttributeElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGLVertexAttributeElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLVertexAttributeElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoGLVertexAttributeElement self, SoState state)"""
        return _coin.SoGLVertexAttributeElement_init(self, state)

    def enableVBO(self, action: "SoGLRenderAction") -> "void":
        r"""enableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_enableVBO(self, action)

    def disableVBO(self, action: "SoGLRenderAction") -> "void":
        r"""disableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_disableVBO(self, action)

    def send(self, index: "int const") -> "void":
        r"""send(SoGLVertexAttributeElement self, int const index)"""
        return _coin.SoGLVertexAttributeElement_send(self, index)

    @staticmethod
    def getInstance(state: "SoState") -> "SoGLVertexAttributeElement const *":
        r"""getInstance(SoState state) -> SoGLVertexAttributeElement"""
        return _coin.SoGLVertexAttributeElement_getInstance(state)

# Register SoGLVertexAttributeElement in _coin:
_coin.SoGLVertexAttributeElement_swigregister(SoGLVertexAttributeElement)

def SoGLVertexAttributeElement_getClassTypeId() -> "SoType":
    r"""SoGLVertexAttributeElement_getClassTypeId() -> SoType"""
    return _coin.SoGLVertexAttributeElement_getClassTypeId()

def SoGLVertexAttributeElement_getClassStackIndex() -> "int":
    r"""SoGLVertexAttributeElement_getClassStackIndex() -> int"""
    return _coin.SoGLVertexAttributeElement_getClassStackIndex()

def SoGLVertexAttributeElement_createInstance() -> "void *":
    r"""SoGLVertexAttributeElement_createInstance() -> void *"""
    return _coin.SoGLVertexAttributeElement_createInstance()

def SoGLVertexAttributeElement_initClass() -> "void":
    r"""SoGLVertexAttributeElement_initClass()"""
    return _coin.SoGLVertexAttributeElement_initClass()

def SoGLVertexAttributeElement_getInstance(state: "SoState") -> "SoGLVertexAttributeElement const *":
    r"""SoGLVertexAttributeElement_getInstance(SoState state) -> SoGLVertexAttributeElement"""
    return _coin.SoGLVertexAttributeElement_getInstance(state)

class SoVertexAttributeBindingElement(SoInt32Element):
    r"""Proxy of C++ SoVertexAttributeBindingElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoVertexAttributeBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVertexAttributeBindingElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVertexAttributeBindingElement_initClass()
    OVERALL = _coin.SoVertexAttributeBindingElement_OVERALL
    
    PER_VERTEX = _coin.SoVertexAttributeBindingElement_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoVertexAttributeBindingElement_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoVertexAttributeBindingElement_DEFAULT
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoVertexAttributeBindingElement self, SoState state)"""
        return _coin.SoVertexAttributeBindingElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoNode node, SoVertexAttributeBindingElement::Binding const binding)
        set(SoState state, SoVertexAttributeBindingElement::Binding const binding)
        """
        return _coin.SoVertexAttributeBindingElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoVertexAttributeBindingElement::Binding":
        r"""get(SoState state) -> SoVertexAttributeBindingElement::Binding"""
        return _coin.SoVertexAttributeBindingElement_get(state)

    @staticmethod
    def getDefault() -> "SoVertexAttributeBindingElement::Binding":
        r"""getDefault() -> SoVertexAttributeBindingElement::Binding"""
        return _coin.SoVertexAttributeBindingElement_getDefault()

# Register SoVertexAttributeBindingElement in _coin:
_coin.SoVertexAttributeBindingElement_swigregister(SoVertexAttributeBindingElement)

def SoVertexAttributeBindingElement_getClassTypeId() -> "SoType":
    r"""SoVertexAttributeBindingElement_getClassTypeId() -> SoType"""
    return _coin.SoVertexAttributeBindingElement_getClassTypeId()

def SoVertexAttributeBindingElement_getClassStackIndex() -> "int":
    r"""SoVertexAttributeBindingElement_getClassStackIndex() -> int"""
    return _coin.SoVertexAttributeBindingElement_getClassStackIndex()

def SoVertexAttributeBindingElement_createInstance() -> "void *":
    r"""SoVertexAttributeBindingElement_createInstance() -> void *"""
    return _coin.SoVertexAttributeBindingElement_createInstance()

def SoVertexAttributeBindingElement_initClass() -> "void":
    r"""SoVertexAttributeBindingElement_initClass()"""
    return _coin.SoVertexAttributeBindingElement_initClass()

def SoVertexAttributeBindingElement_set(*args) -> "void":
    r"""
    SoVertexAttributeBindingElement_set(SoState state, SoNode node, SoVertexAttributeBindingElement::Binding const binding)
    SoVertexAttributeBindingElement_set(SoState state, SoVertexAttributeBindingElement::Binding const binding)
    """
    return _coin.SoVertexAttributeBindingElement_set(*args)

def SoVertexAttributeBindingElement_get(state: "SoState") -> "SoVertexAttributeBindingElement::Binding":
    r"""SoVertexAttributeBindingElement_get(SoState state) -> SoVertexAttributeBindingElement::Binding"""
    return _coin.SoVertexAttributeBindingElement_get(state)

def SoVertexAttributeBindingElement_getDefault() -> "SoVertexAttributeBindingElement::Binding":
    r"""SoVertexAttributeBindingElement_getDefault() -> SoVertexAttributeBindingElement::Binding"""
    return _coin.SoVertexAttributeBindingElement_getDefault()

class SoSpecularColorElement(SoReplacedElement):
    r"""Proxy of C++ SoSpecularColorElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpecularColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoSpecularColorElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSpecularColorElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSpecularColorElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoSpecularColorElement self, SoState state)"""
        return _coin.SoSpecularColorElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numColors: "int32_t const", colors: "SbColor") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numColors, SbColor colors)"""
        return _coin.SoSpecularColorElement_set(state, node, numColors, colors)

    @staticmethod
    def getInstance(state: "SoState") -> "SoSpecularColorElement const *":
        r"""getInstance(SoState state) -> SoSpecularColorElement"""
        return _coin.SoSpecularColorElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoSpecularColorElement self) -> int32_t"""
        return _coin.SoSpecularColorElement_getNum(self)

    def get(self, index: "int const") -> "SbColor const &":
        r"""get(SoSpecularColorElement self, int const index) -> SbColor"""
        return _coin.SoSpecularColorElement_get(self, index)

    def getArrayPtr(self) -> "SbColor const *":
        r"""getArrayPtr(SoSpecularColorElement self) -> SbColor"""
        return _coin.SoSpecularColorElement_getArrayPtr(self)

# Register SoSpecularColorElement in _coin:
_coin.SoSpecularColorElement_swigregister(SoSpecularColorElement)

def SoSpecularColorElement_getClassTypeId() -> "SoType":
    r"""SoSpecularColorElement_getClassTypeId() -> SoType"""
    return _coin.SoSpecularColorElement_getClassTypeId()

def SoSpecularColorElement_getClassStackIndex() -> "int":
    r"""SoSpecularColorElement_getClassStackIndex() -> int"""
    return _coin.SoSpecularColorElement_getClassStackIndex()

def SoSpecularColorElement_createInstance() -> "void *":
    r"""SoSpecularColorElement_createInstance() -> void *"""
    return _coin.SoSpecularColorElement_createInstance()

def SoSpecularColorElement_initClass() -> "void":
    r"""SoSpecularColorElement_initClass()"""
    return _coin.SoSpecularColorElement_initClass()

def SoSpecularColorElement_set(state: "SoState", node: "SoNode", numColors: "int32_t const", colors: "SbColor") -> "void":
    r"""SoSpecularColorElement_set(SoState state, SoNode node, int32_t const numColors, SbColor colors)"""
    return _coin.SoSpecularColorElement_set(state, node, numColors, colors)

def SoSpecularColorElement_getInstance(state: "SoState") -> "SoSpecularColorElement const *":
    r"""SoSpecularColorElement_getInstance(SoState state) -> SoSpecularColorElement"""
    return _coin.SoSpecularColorElement_getInstance(state)

class SoEmissiveColorElement(SoReplacedElement):
    r"""Proxy of C++ SoEmissiveColorElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEmissiveColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoEmissiveColorElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoEmissiveColorElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoEmissiveColorElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoEmissiveColorElement self, SoState state)"""
        return _coin.SoEmissiveColorElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numcolors: "int32_t const", colors: "SbColor") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoEmissiveColorElement_set(state, node, numcolors, colors)

    @staticmethod
    def getInstance(state: "SoState") -> "SoEmissiveColorElement const *":
        r"""getInstance(SoState state) -> SoEmissiveColorElement"""
        return _coin.SoEmissiveColorElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoEmissiveColorElement self) -> int32_t"""
        return _coin.SoEmissiveColorElement_getNum(self)

    def get(self, index: "int const") -> "SbColor const &":
        r"""get(SoEmissiveColorElement self, int const index) -> SbColor"""
        return _coin.SoEmissiveColorElement_get(self, index)

    def getArrayPtr(self) -> "SbColor const *":
        r"""getArrayPtr(SoEmissiveColorElement self) -> SbColor"""
        return _coin.SoEmissiveColorElement_getArrayPtr(self)

# Register SoEmissiveColorElement in _coin:
_coin.SoEmissiveColorElement_swigregister(SoEmissiveColorElement)

def SoEmissiveColorElement_getClassTypeId() -> "SoType":
    r"""SoEmissiveColorElement_getClassTypeId() -> SoType"""
    return _coin.SoEmissiveColorElement_getClassTypeId()

def SoEmissiveColorElement_getClassStackIndex() -> "int":
    r"""SoEmissiveColorElement_getClassStackIndex() -> int"""
    return _coin.SoEmissiveColorElement_getClassStackIndex()

def SoEmissiveColorElement_createInstance() -> "void *":
    r"""SoEmissiveColorElement_createInstance() -> void *"""
    return _coin.SoEmissiveColorElement_createInstance()

def SoEmissiveColorElement_initClass() -> "void":
    r"""SoEmissiveColorElement_initClass()"""
    return _coin.SoEmissiveColorElement_initClass()

def SoEmissiveColorElement_set(state: "SoState", node: "SoNode", numcolors: "int32_t const", colors: "SbColor") -> "void":
    r"""SoEmissiveColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
    return _coin.SoEmissiveColorElement_set(state, node, numcolors, colors)

def SoEmissiveColorElement_getInstance(state: "SoState") -> "SoEmissiveColorElement const *":
    r"""SoEmissiveColorElement_getInstance(SoState state) -> SoEmissiveColorElement"""
    return _coin.SoEmissiveColorElement_getInstance(state)

class SoShininessElement(SoReplacedElement):
    r"""Proxy of C++ SoShininessElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShininessElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoShininessElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoShininessElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShininessElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoShininessElement self, SoState state)"""
        return _coin.SoShininessElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numvalues: "int32_t const", values: "float const *const") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
        return _coin.SoShininessElement_set(state, node, numvalues, values)

    @staticmethod
    def getInstance(state: "SoState") -> "SoShininessElement const *":
        r"""getInstance(SoState state) -> SoShininessElement"""
        return _coin.SoShininessElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoShininessElement self) -> int32_t"""
        return _coin.SoShininessElement_getNum(self)

    def get(self, index: "int const") -> "float":
        r"""get(SoShininessElement self, int const index) -> float"""
        return _coin.SoShininessElement_get(self, index)

    def getArrayPtr(self) -> "float const *":
        r"""getArrayPtr(SoShininessElement self) -> float const *"""
        return _coin.SoShininessElement_getArrayPtr(self)

# Register SoShininessElement in _coin:
_coin.SoShininessElement_swigregister(SoShininessElement)

def SoShininessElement_getClassTypeId() -> "SoType":
    r"""SoShininessElement_getClassTypeId() -> SoType"""
    return _coin.SoShininessElement_getClassTypeId()

def SoShininessElement_getClassStackIndex() -> "int":
    r"""SoShininessElement_getClassStackIndex() -> int"""
    return _coin.SoShininessElement_getClassStackIndex()

def SoShininessElement_createInstance() -> "void *":
    r"""SoShininessElement_createInstance() -> void *"""
    return _coin.SoShininessElement_createInstance()

def SoShininessElement_initClass() -> "void":
    r"""SoShininessElement_initClass()"""
    return _coin.SoShininessElement_initClass()

def SoShininessElement_set(state: "SoState", node: "SoNode", numvalues: "int32_t const", values: "float const *const") -> "void":
    r"""SoShininessElement_set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
    return _coin.SoShininessElement_set(state, node, numvalues, values)

def SoShininessElement_getInstance(state: "SoState") -> "SoShininessElement const *":
    r"""SoShininessElement_getInstance(SoState state) -> SoShininessElement"""
    return _coin.SoShininessElement_getInstance(state)

class SoTransparencyElement(SoReplacedElement):
    r"""Proxy of C++ SoTransparencyElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransparencyElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoTransparencyElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTransparencyElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransparencyElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoTransparencyElement self, SoState state)"""
        return _coin.SoTransparencyElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", numvalues: "int32_t const", values: "float const *const") -> "void":
        r"""set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
        return _coin.SoTransparencyElement_set(state, node, numvalues, values)

    @staticmethod
    def getInstance(state: "SoState") -> "SoTransparencyElement const *":
        r"""getInstance(SoState state) -> SoTransparencyElement"""
        return _coin.SoTransparencyElement_getInstance(state)

    def getNum(self) -> "int32_t":
        r"""getNum(SoTransparencyElement self) -> int32_t"""
        return _coin.SoTransparencyElement_getNum(self)

    def get(self, index: "int const") -> "float":
        r"""get(SoTransparencyElement self, int const index) -> float"""
        return _coin.SoTransparencyElement_get(self, index)

    def getArrayPtr(self) -> "float const *":
        r"""getArrayPtr(SoTransparencyElement self) -> float const *"""
        return _coin.SoTransparencyElement_getArrayPtr(self)

# Register SoTransparencyElement in _coin:
_coin.SoTransparencyElement_swigregister(SoTransparencyElement)

def SoTransparencyElement_getClassTypeId() -> "SoType":
    r"""SoTransparencyElement_getClassTypeId() -> SoType"""
    return _coin.SoTransparencyElement_getClassTypeId()

def SoTransparencyElement_getClassStackIndex() -> "int":
    r"""SoTransparencyElement_getClassStackIndex() -> int"""
    return _coin.SoTransparencyElement_getClassStackIndex()

def SoTransparencyElement_createInstance() -> "void *":
    r"""SoTransparencyElement_createInstance() -> void *"""
    return _coin.SoTransparencyElement_createInstance()

def SoTransparencyElement_initClass() -> "void":
    r"""SoTransparencyElement_initClass()"""
    return _coin.SoTransparencyElement_initClass()

def SoTransparencyElement_set(state: "SoState", node: "SoNode", numvalues: "int32_t const", values: "float const *const") -> "void":
    r"""SoTransparencyElement_set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
    return _coin.SoTransparencyElement_set(state, node, numvalues, values)

def SoTransparencyElement_getInstance(state: "SoState") -> "SoTransparencyElement const *":
    r"""SoTransparencyElement_getInstance(SoState state) -> SoTransparencyElement"""
    return _coin.SoTransparencyElement_getInstance(state)

class SoLightModelElement(SoInt32Element):
    r"""Proxy of C++ SoLightModelElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightModelElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoLightModelElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoLightModelElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLightModelElement_initClass()
    BASE_COLOR = _coin.SoLightModelElement_BASE_COLOR
    
    PHONG = _coin.SoLightModelElement_PHONG
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoLightModelElement self, SoState state)"""
        return _coin.SoLightModelElement_init(self, state)

    @staticmethod
    def set(*args) -> "void":
        r"""
        set(SoState state, SoLightModelElement::Model const model)
        set(SoState state, SoNode node, SoLightModelElement::Model const model)
        """
        return _coin.SoLightModelElement_set(*args)

    @staticmethod
    def get(state: "SoState") -> "SoLightModelElement::Model":
        r"""get(SoState state) -> SoLightModelElement::Model"""
        return _coin.SoLightModelElement_get(state)

    @staticmethod
    def getDefault() -> "SoLightModelElement::Model":
        r"""getDefault() -> SoLightModelElement::Model"""
        return _coin.SoLightModelElement_getDefault()

    @staticmethod
    def getInstance(state: "SoState") -> "SoLightModelElement const *":
        r"""getInstance(SoState state) -> SoLightModelElement"""
        return _coin.SoLightModelElement_getInstance(state)

# Register SoLightModelElement in _coin:
_coin.SoLightModelElement_swigregister(SoLightModelElement)

def SoLightModelElement_getClassTypeId() -> "SoType":
    r"""SoLightModelElement_getClassTypeId() -> SoType"""
    return _coin.SoLightModelElement_getClassTypeId()

def SoLightModelElement_getClassStackIndex() -> "int":
    r"""SoLightModelElement_getClassStackIndex() -> int"""
    return _coin.SoLightModelElement_getClassStackIndex()

def SoLightModelElement_createInstance() -> "void *":
    r"""SoLightModelElement_createInstance() -> void *"""
    return _coin.SoLightModelElement_createInstance()

def SoLightModelElement_initClass() -> "void":
    r"""SoLightModelElement_initClass()"""
    return _coin.SoLightModelElement_initClass()

def SoLightModelElement_set(*args) -> "void":
    r"""
    SoLightModelElement_set(SoState state, SoLightModelElement::Model const model)
    SoLightModelElement_set(SoState state, SoNode node, SoLightModelElement::Model const model)
    """
    return _coin.SoLightModelElement_set(*args)

def SoLightModelElement_get(state: "SoState") -> "SoLightModelElement::Model":
    r"""SoLightModelElement_get(SoState state) -> SoLightModelElement::Model"""
    return _coin.SoLightModelElement_get(state)

def SoLightModelElement_getDefault() -> "SoLightModelElement::Model":
    r"""SoLightModelElement_getDefault() -> SoLightModelElement::Model"""
    return _coin.SoLightModelElement_getDefault()

def SoLightModelElement_getInstance(state: "SoState") -> "SoLightModelElement const *":
    r"""SoLightModelElement_getInstance(SoState state) -> SoLightModelElement"""
    return _coin.SoLightModelElement_getInstance(state)

class SbColor4f(SbVec4f):
    r"""Proxy of C++ SbColor4f class."""

    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):
        r"""
        __init__(SbColor4f self) -> SbColor4f
        __init__(SbColor4f self, SbColor rgb, float const alpha=1.0) -> SbColor4f
        __init__(SbColor4f self, SbVec4f v) -> SbColor4f
        __init__(SbColor4f self, float const *const rgba) -> SbColor4f
        __init__(SbColor4f self, float const r, float const g, float const b, float const a=1.0) -> SbColor4f
        """
        _coin.SbColor4f_swiginit(self, _coin.new_SbColor4f(*args))

    def setValue(self, *args) -> "void":
        r"""
        setValue(SbColor4f self, float const r, float const g, float const b, float const a=1.0)
        setValue(SbColor4f self, float const [4] col)
        """
        return _coin.SbColor4f_setValue(self, *args)

    def getValue(self) -> "void":
        r"""getValue(SbColor4f self)"""
        return _coin.SbColor4f_getValue(self)

    def setRGB(self, col: "SbColor") -> "SbColor4f &":
        r"""setRGB(SbColor4f self, SbColor col) -> SbColor4f"""
        return _coin.SbColor4f_setRGB(self, col)

    def getRGB(self, color: "SbColor") -> "void":
        r"""getRGB(SbColor4f self, SbColor color)"""
        return _coin.SbColor4f_getRGB(self, color)

    def setHSVValue(self, *args) -> "SbColor4f &":
        r"""
        setHSVValue(SbColor4f self, float h, float s, float v, float a=1.0) -> SbColor4f
        setHSVValue(SbColor4f self, float const [3] hsv, float alpha=1.0) -> SbColor4f
        """
        return _coin.SbColor4f_setHSVValue(self, *args)

    def getHSVValue(self) -> "void":
        r"""getHSVValue(SbColor4f self)"""
        return _coin.SbColor4f_getHSVValue(self)

    def setPackedValue(self, rgba: "uint32_t const") -> "SbColor4f &":
        r"""setPackedValue(SbColor4f self, uint32_t const rgba) -> SbColor4f"""
        return _coin.SbColor4f_setPackedValue(self, rgba)

    def getPackedValue(self) -> "uint32_t":
        r"""getPackedValue(SbColor4f self) -> uint32_t"""
        return _coin.SbColor4f_getPackedValue(self)

    def __imul__(self, d: "float const") -> "SbColor4f &":
        r"""__imul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbColor4f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, c: "SbColor4f") -> "SbColor4f &":
        r"""__iadd__(SbColor4f self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___iadd__(self, c)

    def __isub__(self, c: "SbColor4f") -> "SbColor4f &":
        r"""__isub__(SbColor4f self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___isub__(self, c)

    def __add__(self, u: "SbColor4f") -> "SbColor4f":
        r"""__add__(SbColor4f self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___add__(self, u)

    def __sub__(self, u: "SbColor4f") -> "SbColor4f":
        r"""__sub__(SbColor4f self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___sub__(self, u)

    def __mul__(self, d: "float const") -> "SbColor4f":
        r"""__mul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___mul__(self, d)

    def __rmul__(self, d: "float const") -> "SbColor4f":
        r"""__rmul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___rmul__(self, d)

    def __div__(self, d: "float const") -> "SbColor4f":
        r"""__div__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___div__(self, d)

    def __eq__(self, u: "SbColor4f") -> "int":
        r"""__eq__(SbColor4f self, SbColor4f u) -> int"""
        return _coin.SbColor4f___eq__(self, u)

    def __nq__(self, u: "SbColor4f") -> "int":
        r"""__nq__(SbColor4f self, SbColor4f u) -> int"""
        return _coin.SbColor4f___nq__(self, u)

    def __getitem__(self, i: "int") -> "float":
        r"""__getitem__(SbColor4f self, int i) -> float"""
        return _coin.SbColor4f___getitem__(self, i)
    __swig_destroy__ = _coin.delete_SbColor4f

# Register SbColor4f in _coin:
_coin.SbColor4f_swigregister(SbColor4f)

class SoTextureCombineElement(SoElement):
    r"""Proxy of C++ SoTextureCombineElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCombineElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureCombineElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTextureCombineElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCombineElement_initClass()
    PRIMARY_COLOR = _coin.SoTextureCombineElement_PRIMARY_COLOR
    
    TEXTURE = _coin.SoTextureCombineElement_TEXTURE
    
    CONSTANT = _coin.SoTextureCombineElement_CONSTANT
    
    PREVIOUS = _coin.SoTextureCombineElement_PREVIOUS
    
    SRC_COLOR = _coin.SoTextureCombineElement_SRC_COLOR
    
    ONE_MINUS_SRC_COLOR = _coin.SoTextureCombineElement_ONE_MINUS_SRC_COLOR
    
    SRC_ALPHA = _coin.SoTextureCombineElement_SRC_ALPHA
    
    ONE_MINUS_SRC_ALPHA = _coin.SoTextureCombineElement_ONE_MINUS_SRC_ALPHA
    
    REPLACE = _coin.SoTextureCombineElement_REPLACE
    
    MODULATE = _coin.SoTextureCombineElement_MODULATE
    
    ADD = _coin.SoTextureCombineElement_ADD
    
    ADD_SIGNED = _coin.SoTextureCombineElement_ADD_SIGNED
    
    SUBTRACT = _coin.SoTextureCombineElement_SUBTRACT
    
    INTERPOLATE = _coin.SoTextureCombineElement_INTERPOLATE
    
    DOT3_RGB = _coin.SoTextureCombineElement_DOT3_RGB
    
    DOT3_RGBA = _coin.SoTextureCombineElement_DOT3_RGBA
    

    def init(self, state: "SoState") -> "void":
        r"""init(SoTextureCombineElement self, SoState state)"""
        return _coin.SoTextureCombineElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", unit: "int const", rgboperation: "SoTextureCombineElement::Operation const", alphaoperation: "SoTextureCombineElement::Operation const", rgbsource: "SoTextureCombineElement::Source const *", alphasource: "SoTextureCombineElement::Source const *", rgboperand: "SoTextureCombineElement::Operand const *", alphaoperand: "SoTextureCombineElement::Operand const *", constantcolor: "SbColor4f", rgbscale: "float const", alphascale: "float const") -> "void":
        r"""set(SoState state, SoNode node, int const unit, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"""
        return _coin.SoTextureCombineElement_set(state, node, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

    @staticmethod
    def isDefault(state: "SoState", unit: "int const") -> "SbBool":
        r"""isDefault(SoState state, int const unit) -> SbBool"""
        return _coin.SoTextureCombineElement_isDefault(state, unit)

    @staticmethod
    def get(state: "SoState", unit: "int const", rgboperation: "SoTextureCombineElement::Operation &", alphaoperation: "SoTextureCombineElement::Operation &", rgbsource: "SoTextureCombineElement::Source *", alphasource: "SoTextureCombineElement::Source *", rgboperand: "SoTextureCombineElement::Operand *", alphaoperand: "SoTextureCombineElement::Operand *", constantcolor: "SbColor4f", rgbscale: "float &", alphascale: "float &") -> "void":
        r"""get(SoState state, int const unit, SoTextureCombineElement::Operation & rgboperation, SoTextureCombineElement::Operation & alphaoperation, SoTextureCombineElement::Source * rgbsource, SoTextureCombineElement::Source * alphasource, SoTextureCombineElement::Operand * rgboperand, SoTextureCombineElement::Operand * alphaoperand, SbColor4f constantcolor, float & rgbscale, float & alphascale)"""
        return _coin.SoTextureCombineElement_get(state, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

    def push(self, state: "SoState") -> "void":
        r"""push(SoTextureCombineElement self, SoState state)"""
        return _coin.SoTextureCombineElement_push(self, state)

    def matches(self, elem: "SoElement") -> "SbBool":
        r"""matches(SoTextureCombineElement self, SoElement elem) -> SbBool"""
        return _coin.SoTextureCombineElement_matches(self, elem)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoTextureCombineElement self) -> SoElement"""
        return _coin.SoTextureCombineElement_copyMatchInfo(self)

    def setElt(self, unit: "int const", nodeid: "SbUniqueId const", rgboperation: "SoTextureCombineElement::Operation const", alphaoperation: "SoTextureCombineElement::Operation const", rgbsource: "SoTextureCombineElement::Source const *", alphasource: "SoTextureCombineElement::Source const *", rgboperand: "SoTextureCombineElement::Operand const *", alphaoperand: "SoTextureCombineElement::Operand const *", constantcolor: "SbColor4f", rgbscale: "float const", alphascale: "float const") -> "void":
        r"""setElt(SoTextureCombineElement self, int const unit, SbUniqueId const nodeid, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"""
        return _coin.SoTextureCombineElement_setElt(self, unit, nodeid, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

    @staticmethod
    def apply(state: "SoState", unit: "int const") -> "void":
        r"""apply(SoState state, int const unit)"""
        return _coin.SoTextureCombineElement_apply(state, unit)

# Register SoTextureCombineElement in _coin:
_coin.SoTextureCombineElement_swigregister(SoTextureCombineElement)

def SoTextureCombineElement_getClassTypeId() -> "SoType":
    r"""SoTextureCombineElement_getClassTypeId() -> SoType"""
    return _coin.SoTextureCombineElement_getClassTypeId()

def SoTextureCombineElement_getClassStackIndex() -> "int":
    r"""SoTextureCombineElement_getClassStackIndex() -> int"""
    return _coin.SoTextureCombineElement_getClassStackIndex()

def SoTextureCombineElement_createInstance() -> "void *":
    r"""SoTextureCombineElement_createInstance() -> void *"""
    return _coin.SoTextureCombineElement_createInstance()

def SoTextureCombineElement_initClass() -> "void":
    r"""SoTextureCombineElement_initClass()"""
    return _coin.SoTextureCombineElement_initClass()

def SoTextureCombineElement_set(state: "SoState", node: "SoNode", unit: "int const", rgboperation: "SoTextureCombineElement::Operation const", alphaoperation: "SoTextureCombineElement::Operation const", rgbsource: "SoTextureCombineElement::Source const *", alphasource: "SoTextureCombineElement::Source const *", rgboperand: "SoTextureCombineElement::Operand const *", alphaoperand: "SoTextureCombineElement::Operand const *", constantcolor: "SbColor4f", rgbscale: "float const", alphascale: "float const") -> "void":
    r"""SoTextureCombineElement_set(SoState state, SoNode node, int const unit, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"""
    return _coin.SoTextureCombineElement_set(state, node, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

def SoTextureCombineElement_isDefault(state: "SoState", unit: "int const") -> "SbBool":
    r"""SoTextureCombineElement_isDefault(SoState state, int const unit) -> SbBool"""
    return _coin.SoTextureCombineElement_isDefault(state, unit)

def SoTextureCombineElement_get(state: "SoState", unit: "int const", rgboperation: "SoTextureCombineElement::Operation &", alphaoperation: "SoTextureCombineElement::Operation &", rgbsource: "SoTextureCombineElement::Source *", alphasource: "SoTextureCombineElement::Source *", rgboperand: "SoTextureCombineElement::Operand *", alphaoperand: "SoTextureCombineElement::Operand *", constantcolor: "SbColor4f", rgbscale: "float &", alphascale: "float &") -> "void":
    r"""SoTextureCombineElement_get(SoState state, int const unit, SoTextureCombineElement::Operation & rgboperation, SoTextureCombineElement::Operation & alphaoperation, SoTextureCombineElement::Source * rgbsource, SoTextureCombineElement::Source * alphasource, SoTextureCombineElement::Operand * rgboperand, SoTextureCombineElement::Operand * alphaoperand, SbColor4f constantcolor, float & rgbscale, float & alphascale)"""
    return _coin.SoTextureCombineElement_get(state, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

def SoTextureCombineElement_apply(state: "SoState", unit: "int const") -> "void":
    r"""SoTextureCombineElement_apply(SoState state, int const unit)"""
    return _coin.SoTextureCombineElement_apply(state, unit)

class SoTextureUnitElement(SoInt32Element):
    r"""Proxy of C++ SoTextureUnitElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureUnitElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureUnitElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTextureUnitElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureUnitElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoTextureUnitElement self, SoState state)"""
        return _coin.SoTextureUnitElement_init(self, state)

    @staticmethod
    def set(state: "SoState", node: "SoNode", units: "int const") -> "void":
        r"""set(SoState state, SoNode node, int const units)"""
        return _coin.SoTextureUnitElement_set(state, node, units)

    @staticmethod
    def get(state: "SoState") -> "int":
        r"""get(SoState state) -> int"""
        return _coin.SoTextureUnitElement_get(state)

# Register SoTextureUnitElement in _coin:
_coin.SoTextureUnitElement_swigregister(SoTextureUnitElement)

def SoTextureUnitElement_getClassTypeId() -> "SoType":
    r"""SoTextureUnitElement_getClassTypeId() -> SoType"""
    return _coin.SoTextureUnitElement_getClassTypeId()

def SoTextureUnitElement_getClassStackIndex() -> "int":
    r"""SoTextureUnitElement_getClassStackIndex() -> int"""
    return _coin.SoTextureUnitElement_getClassStackIndex()

def SoTextureUnitElement_createInstance() -> "void *":
    r"""SoTextureUnitElement_createInstance() -> void *"""
    return _coin.SoTextureUnitElement_createInstance()

def SoTextureUnitElement_initClass() -> "void":
    r"""SoTextureUnitElement_initClass()"""
    return _coin.SoTextureUnitElement_initClass()

def SoTextureUnitElement_set(state: "SoState", node: "SoNode", units: "int const") -> "void":
    r"""SoTextureUnitElement_set(SoState state, SoNode node, int const units)"""
    return _coin.SoTextureUnitElement_set(state, node, units)

def SoTextureUnitElement_get(state: "SoState") -> "int":
    r"""SoTextureUnitElement_get(SoState state) -> int"""
    return _coin.SoTextureUnitElement_get(state)

class SoEngine(SoFieldContainer):
    r"""Proxy of C++ SoEngine class."""

    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 initClass() -> "void":
        r"""initClass()"""
        return _coin.SoEngine_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoEngine_initClasses()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEngine_getClassTypeId()

    def evaluateWrapper(self) -> "void":
        r"""evaluateWrapper(SoEngine self)"""
        return _coin.SoEngine_evaluateWrapper(self)

    def getOutputs(self, l: "SoEngineOutputList") -> "int":
        r"""getOutputs(SoEngine self, SoEngineOutputList l) -> int"""
        return _coin.SoEngine_getOutputs(self, l)

    def getOutput(self, outputname: "SbName") -> "SoEngineOutput *":
        r"""getOutput(SoEngine self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoEngine_getOutput(self, outputname)

    def getOutputName(self, output: "SoEngineOutput", outputname: "SbName") -> "SbBool":
        r"""getOutputName(SoEngine self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoEngine_getOutputName(self, output, outputname)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoEngine self) -> SoEngineOutputData"""
        return _coin.SoEngine_getOutputData(self)

    @staticmethod
    def getByName(*args) -> "int":
        r"""
        getByName(SbName name) -> SoEngine
        getByName(SbName name, SoEngineList el) -> int
        """
        return _coin.SoEngine_getByName(*args)

    def isNotifying(self) -> "SbBool":
        r"""isNotifying(SoEngine self) -> SbBool"""
        return _coin.SoEngine_isNotifying(self)

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoEngine self, SoNotList nl)"""
        return _coin.SoEngine_notify(self, nl)

    def copy(self) -> "SoEngine *":
        r"""copy(SoEngine self) -> SoEngine"""
        return _coin.SoEngine_copy(self)

    def copyThroughConnection(self) -> "SoFieldContainer *":
        r"""copyThroughConnection(SoEngine self) -> SoFieldContainer"""
        return _coin.SoEngine_copyThroughConnection(self)

    def shouldCopy(self) -> "SbBool":
        r"""shouldCopy(SoEngine self) -> SbBool"""
        return _coin.SoEngine_shouldCopy(self)

    def writeInstance(self, out: "SoOutput") -> "void":
        r"""writeInstance(SoEngine self, SoOutput out)"""
        return _coin.SoEngine_writeInstance(self, out)

    def __getattr__(self, name):
        try:
            return SoFieldContainer.__getattr__(self, name)
        except AttributeError as e:
    ##############################################################
            if name == "this":
                raise AttributeError
    ##############################################################
            out = self.getOutput(SbName(name))
            if out is None:
                raise e
            return out

    def __setattr__(self,name,value):
        if name == 'this':
            return SoFieldContainer.__setattr__(self, name, value)
        out = self.getOutput(SbName(name))
        if out is None:
            return SoFieldContainer.__setattr__(self, name, value)
        raise AttributeError('Cannot set output %s on engine %s' %(name,self.__class__.__name__))



# Register SoEngine in _coin:
_coin.SoEngine_swigregister(SoEngine)

def SoEngine_initClass() -> "void":
    r"""SoEngine_initClass()"""
    return _coin.SoEngine_initClass()

def SoEngine_initClasses() -> "void":
    r"""SoEngine_initClasses()"""
    return _coin.SoEngine_initClasses()

def SoEngine_getClassTypeId() -> "SoType":
    r"""SoEngine_getClassTypeId() -> SoType"""
    return _coin.SoEngine_getClassTypeId()

def SoEngine_getByName(*args) -> "int":
    r"""
    SoEngine_getByName(SbName name) -> SoEngine
    SoEngine_getByName(SbName name, SoEngineList el) -> int
    """
    return _coin.SoEngine_getByName(*args)

class SoEngineOutput(object):
    r"""Proxy of C++ SoEngineOutput class."""

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

    def __init__(self):
        r"""__init__(SoEngineOutput self) -> SoEngineOutput"""
        _coin.SoEngineOutput_swiginit(self, _coin.new_SoEngineOutput())
    __swig_destroy__ = _coin.delete_SoEngineOutput

    def getConnectionType(self) -> "SoType":
        r"""getConnectionType(SoEngineOutput self) -> SoType"""
        return _coin.SoEngineOutput_getConnectionType(self)

    def getForwardConnections(self, fl: "SoFieldList") -> "int":
        r"""getForwardConnections(SoEngineOutput self, SoFieldList fl) -> int"""
        return _coin.SoEngineOutput_getForwardConnections(self, fl)

    def enable(self, flag: "SbBool const") -> "void":
        r"""enable(SoEngineOutput self, SbBool const flag)"""
        return _coin.SoEngineOutput_enable(self, flag)

    def isEnabled(self) -> "SbBool":
        r"""isEnabled(SoEngineOutput self) -> SbBool"""
        return _coin.SoEngineOutput_isEnabled(self)

    def getContainer(self) -> "SoEngine *":
        r"""getContainer(SoEngineOutput self) -> SoEngine"""
        return _coin.SoEngineOutput_getContainer(self)

    def getNodeContainer(self) -> "SoNodeEngine *":
        r"""getNodeContainer(SoEngineOutput self) -> SoNodeEngine"""
        return _coin.SoEngineOutput_getNodeContainer(self)

    def isNodeEngineOutput(self) -> "SbBool":
        r"""isNodeEngineOutput(SoEngineOutput self) -> SbBool"""
        return _coin.SoEngineOutput_isNodeEngineOutput(self)

    def setContainer(self, engine: "SoEngine") -> "void":
        r"""setContainer(SoEngineOutput self, SoEngine engine)"""
        return _coin.SoEngineOutput_setContainer(self, engine)

    def setNodeContainer(self, nodeengine: "SoNodeEngine") -> "void":
        r"""setNodeContainer(SoEngineOutput self, SoNodeEngine nodeengine)"""
        return _coin.SoEngineOutput_setNodeContainer(self, nodeengine)

    def addConnection(self, f: "SoField") -> "void":
        r"""addConnection(SoEngineOutput self, SoField f)"""
        return _coin.SoEngineOutput_addConnection(self, f)

    def removeConnection(self, f: "SoField") -> "void":
        r"""removeConnection(SoEngineOutput self, SoField f)"""
        return _coin.SoEngineOutput_removeConnection(self, f)

    def getNumConnections(self) -> "int":
        r"""getNumConnections(SoEngineOutput self) -> int"""
        return _coin.SoEngineOutput_getNumConnections(self)

    def prepareToWrite(self) -> "void":
        r"""prepareToWrite(SoEngineOutput self)"""
        return _coin.SoEngineOutput_prepareToWrite(self)

    def doneWriting(self) -> "void":
        r"""doneWriting(SoEngineOutput self)"""
        return _coin.SoEngineOutput_doneWriting(self)

    def touchSlaves(self, nl: "SoNotList", donotify: "SbBool") -> "void":
        r"""touchSlaves(SoEngineOutput self, SoNotList nl, SbBool donotify)"""
        return _coin.SoEngineOutput_touchSlaves(self, nl, donotify)

    def getFieldContainer(self) -> "SoFieldContainer *":
        r"""getFieldContainer(SoEngineOutput self) -> SoFieldContainer"""
        return _coin.SoEngineOutput_getFieldContainer(self)

# Register SoEngineOutput in _coin:
_coin.SoEngineOutput_swigregister(SoEngineOutput)

class SoEngineOutputData(object):
    r"""Proxy of C++ SoEngineOutputData class."""

    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):
        r"""
        __init__(SoEngineOutputData self) -> SoEngineOutputData
        __init__(SoEngineOutputData self, SoEngineOutputData data) -> SoEngineOutputData
        __init__(SoEngineOutputData self, int approxnum) -> SoEngineOutputData
        """
        _coin.SoEngineOutputData_swiginit(self, _coin.new_SoEngineOutputData(*args))
    __swig_destroy__ = _coin.delete_SoEngineOutputData

    def addOutput(self, *args) -> "void":
        r"""
        addOutput(SoEngineOutputData self, SoEngine base, char const * name, SoEngineOutput output, SoType type)
        addOutput(SoEngineOutputData self, SoNodeEngine base, char const * name, SoEngineOutput output, SoType type)
        """
        return _coin.SoEngineOutputData_addOutput(self, *args)

    def getNumOutputs(self) -> "int":
        r"""getNumOutputs(SoEngineOutputData self) -> int"""
        return _coin.SoEngineOutputData_getNumOutputs(self)

    def getOutputName(self, index: "int") -> "SbName const &":
        r"""getOutputName(SoEngineOutputData self, int index) -> SbName"""
        return _coin.SoEngineOutputData_getOutputName(self, index)

    def getOutput(self, *args) -> "SoEngineOutput *":
        r"""
        getOutput(SoEngineOutputData self, SoEngine engine, int index) -> SoEngineOutput
        getOutput(SoEngineOutputData self, SoNodeEngine engine, int index) -> SoEngineOutput
        """
        return _coin.SoEngineOutputData_getOutput(self, *args)

    def getIndex(self, *args) -> "int":
        r"""
        getIndex(SoEngineOutputData self, SoEngine engine, SoEngineOutput output) -> int
        getIndex(SoEngineOutputData self, SoNodeEngine engine, SoEngineOutput output) -> int
        """
        return _coin.SoEngineOutputData_getIndex(self, *args)

    def getType(self, index: "int") -> "SoType const &":
        r"""getType(SoEngineOutputData self, int index) -> SoType"""
        return _coin.SoEngineOutputData_getType(self, index)

    def readDescriptions(self, input: "SoInput", engine: "SoEngine") -> "SbBool":
        r"""readDescriptions(SoEngineOutputData self, SoInput input, SoEngine engine) -> SbBool"""
        return _coin.SoEngineOutputData_readDescriptions(self, input, engine)

    def writeDescriptions(self, out: "SoOutput", engine: "SoEngine") -> "void":
        r"""writeDescriptions(SoEngineOutputData self, SoOutput out, SoEngine engine)"""
        return _coin.SoEngineOutputData_writeDescriptions(self, out, engine)

# Register SoEngineOutputData in _coin:
_coin.SoEngineOutputData_swigregister(SoEngineOutputData)

class SoMFBool(SoMField):
    r"""Proxy of C++ SoMFBool class."""

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

    def __init__(self):
        r"""__init__(SoMFBool self) -> SoMFBool"""
        _coin.SoMFBool_swiginit(self, _coin.new_SoMFBool())
    __swig_destroy__ = _coin.delete_SoMFBool

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFBool_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFBool_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFBool self) -> SoType"""
        return _coin.SoMFBool_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFBool self, SoField field)"""
        return _coin.SoMFBool_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFBool self, SoField field) -> SbBool"""
        return _coin.SoMFBool_isSame(self, field)

    def find(self, value: "SbBool", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFBool self, SbBool value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFBool_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFBool):
             val = args[1].getValues()
             return _coin.SoMFBool_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFBool_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFBool):
             val = args[2].getValues()
             return _coin.SoMFBool_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFBool_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFBool_setValues(*args)



    def set1Value(self, idx: "int const", value: "SbBool") -> "void":
        r"""set1Value(SoMFBool self, int const idx, SbBool value)"""
        return _coin.SoMFBool_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFBool") -> "SbBool":
        r"""__eq__(SoMFBool self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___eq__(self, field)

    def __ne__(self, field: "SoMFBool") -> "SbBool":
        r"""__ne__(SoMFBool self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___ne__(self, field)

    def startEditing(self) -> "SbBool *":
        r"""startEditing(SoMFBool self) -> SbBool *"""
        return _coin.SoMFBool_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFBool self)"""
        return _coin.SoMFBool_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFBool self, int const num, SbBool const * userdata)
        setValuesPointer(SoMFBool self, int const num, SbBool * userdata)
        """
        return _coin.SoMFBool_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFBool_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFBool self, SbBool value)
        setValue(SoMFBool self, SoMFBool other)
        """
        return _coin.SoMFBool_setValue(self, *args)

    def __getitem__(self, i: "int") -> "SbBool const":
        r"""__getitem__(SoMFBool self, int i) -> SbBool const"""
        return _coin.SoMFBool___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbBool") -> "void":
        r"""__setitem__(SoMFBool self, int i, SbBool value)"""
        return _coin.SoMFBool___setitem__(self, i, value)

    def getValues(self, i: "int"=0) -> "SbBool const *":
        r"""getValues(SoMFBool self, int i=0) -> SbBool const"""
        return _coin.SoMFBool_getValues(self, i)

# Register SoMFBool in _coin:
_coin.SoMFBool_swigregister(SoMFBool)

def SoMFBool_createInstance() -> "void *":
    r"""SoMFBool_createInstance() -> void *"""
    return _coin.SoMFBool_createInstance()

def SoMFBool_getClassTypeId() -> "SoType":
    r"""SoMFBool_getClassTypeId() -> SoType"""
    return _coin.SoMFBool_getClassTypeId()

def SoMFBool_initClass() -> "void":
    r"""SoMFBool_initClass()"""
    return _coin.SoMFBool_initClass()

class SoMFEnum(SoMField):
    r"""Proxy of C++ SoMFEnum class."""

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

    def __init__(self):
        r"""__init__(SoMFEnum self) -> SoMFEnum"""
        _coin.SoMFEnum_swiginit(self, _coin.new_SoMFEnum())
    __swig_destroy__ = _coin.delete_SoMFEnum

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFEnum_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFEnum_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFEnum self) -> SoType"""
        return _coin.SoMFEnum_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFEnum self, SoField field)"""
        return _coin.SoMFEnum_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFEnum self, SoField field) -> SbBool"""
        return _coin.SoMFEnum_isSame(self, field)

    def find(self, value: "int", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFEnum self, int value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFEnum_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFEnum):
             val = args[1].getValues()
             return _coin.SoMFEnum_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFEnum_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFEnum):
             val = args[2].getValues()
             return _coin.SoMFEnum_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFEnum_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFEnum_setValues(*args)



    def __eq__(self, field: "SoMFEnum") -> "SbBool":
        r"""__eq__(SoMFEnum self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___eq__(self, field)

    def __ne__(self, field: "SoMFEnum") -> "SbBool":
        r"""__ne__(SoMFEnum self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___ne__(self, field)

    def startEditing(self) -> "int *":
        r"""startEditing(SoMFEnum self) -> int *"""
        return _coin.SoMFEnum_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFEnum self)"""
        return _coin.SoMFEnum_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFEnum_initClass()

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFEnum self, int const idx, int value)
        set1Value(SoMFEnum self, int const idx, SbName name)
        """
        return _coin.SoMFEnum_set1Value(self, *args)

    def setEnums(self, num: "int const", values: "int const *const", names: "SbName") -> "void":
        r"""setEnums(SoMFEnum self, int const num, int const *const values, SbName names)"""
        return _coin.SoMFEnum_setEnums(self, num, values, names)

    def getNumEnums(self) -> "int":
        r"""getNumEnums(SoMFEnum self) -> int"""
        return _coin.SoMFEnum_getNumEnums(self)

    def getEnum(self, idx: "int const", name: "SbName") -> "int":
        r"""getEnum(SoMFEnum self, int const idx, SbName name) -> int"""
        return _coin.SoMFEnum_getEnum(self, idx, name)

    def __getitem__(self, i: "int") -> "int const":
        r"""__getitem__(SoMFEnum self, int i) -> int const"""
        return _coin.SoMFEnum___getitem__(self, i)

    def __setitem__(self, i: "int", value: "int") -> "void":
        r"""__setitem__(SoMFEnum self, int i, int value)"""
        return _coin.SoMFEnum___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFEnum self, int value)
        setValue(SoMFEnum self, SbName name)
        setValue(SoMFEnum self, SoMFEnum other)
        """
        return _coin.SoMFEnum_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "int const *":
        r"""getValues(SoMFEnum self, int i=0) -> int const"""
        return _coin.SoMFEnum_getValues(self, i)

# Register SoMFEnum in _coin:
_coin.SoMFEnum_swigregister(SoMFEnum)

def SoMFEnum_createInstance() -> "void *":
    r"""SoMFEnum_createInstance() -> void *"""
    return _coin.SoMFEnum_createInstance()

def SoMFEnum_getClassTypeId() -> "SoType":
    r"""SoMFEnum_getClassTypeId() -> SoType"""
    return _coin.SoMFEnum_getClassTypeId()

def SoMFEnum_initClass() -> "void":
    r"""SoMFEnum_initClass()"""
    return _coin.SoMFEnum_initClass()

class SoBoolOperation(SoEngine):
    r"""Proxy of C++ SoBoolOperation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBoolOperation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBoolOperation self) -> SoType"""
        return _coin.SoBoolOperation_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoBoolOperation self) -> SoFieldData"""
        return _coin.SoBoolOperation_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoBoolOperation self) -> SoEngineOutputData"""
        return _coin.SoBoolOperation_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoBoolOperation_createInstance()
    CLEAR = _coin.SoBoolOperation_CLEAR
    
    SET = _coin.SoBoolOperation_SET
    
    A = _coin.SoBoolOperation_A
    
    NOT_A = _coin.SoBoolOperation_NOT_A
    
    B = _coin.SoBoolOperation_B
    
    NOT_B = _coin.SoBoolOperation_NOT_B
    
    A_OR_B = _coin.SoBoolOperation_A_OR_B
    
    NOT_A_OR_B = _coin.SoBoolOperation_NOT_A_OR_B
    
    A_OR_NOT_B = _coin.SoBoolOperation_A_OR_NOT_B
    
    NOT_A_OR_NOT_B = _coin.SoBoolOperation_NOT_A_OR_NOT_B
    
    A_AND_B = _coin.SoBoolOperation_A_AND_B
    
    NOT_A_AND_B = _coin.SoBoolOperation_NOT_A_AND_B
    
    A_AND_NOT_B = _coin.SoBoolOperation_A_AND_NOT_B
    
    NOT_A_AND_NOT_B = _coin.SoBoolOperation_NOT_A_AND_NOT_B
    
    A_EQUALS_B = _coin.SoBoolOperation_A_EQUALS_B
    
    A_NOT_EQUALS_B = _coin.SoBoolOperation_A_NOT_EQUALS_B
    
    a = property(_coin.SoBoolOperation_a_get, _coin.SoBoolOperation_a_set, doc=r"""a : SoMFBool""")
    b = property(_coin.SoBoolOperation_b_get, _coin.SoBoolOperation_b_set, doc=r"""b : SoMFBool""")
    operation = property(_coin.SoBoolOperation_operation_get, _coin.SoBoolOperation_operation_set, doc=r"""operation : SoMFEnum""")
    output = property(_coin.SoBoolOperation_output_get, _coin.SoBoolOperation_output_set, doc=r"""output : SoEngineOutput""")
    inverse = property(_coin.SoBoolOperation_inverse_get, _coin.SoBoolOperation_inverse_set, doc=r"""inverse : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoBoolOperation self) -> SoBoolOperation"""
        _coin.SoBoolOperation_swiginit(self, _coin.new_SoBoolOperation())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBoolOperation_initClass()

# Register SoBoolOperation in _coin:
_coin.SoBoolOperation_swigregister(SoBoolOperation)

def SoBoolOperation_getClassTypeId() -> "SoType":
    r"""SoBoolOperation_getClassTypeId() -> SoType"""
    return _coin.SoBoolOperation_getClassTypeId()

def SoBoolOperation_createInstance() -> "void *":
    r"""SoBoolOperation_createInstance() -> void *"""
    return _coin.SoBoolOperation_createInstance()

def SoBoolOperation_initClass() -> "void":
    r"""SoBoolOperation_initClass()"""
    return _coin.SoBoolOperation_initClass()

class SoMFFloat(SoMField):
    r"""Proxy of C++ SoMFFloat class."""

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

    def __init__(self):
        r"""__init__(SoMFFloat self) -> SoMFFloat"""
        _coin.SoMFFloat_swiginit(self, _coin.new_SoMFFloat())
    __swig_destroy__ = _coin.delete_SoMFFloat

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFFloat_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFFloat_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFFloat self) -> SoType"""
        return _coin.SoMFFloat_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFFloat self, SoField field)"""
        return _coin.SoMFFloat_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFFloat self, SoField field) -> SbBool"""
        return _coin.SoMFFloat_isSame(self, field)

    def find(self, value: "float", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFFloat self, float value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFFloat_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFFloat):
             val = args[1].getValues()
             return _coin.SoMFFloat_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFFloat_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFFloat):
             val = args[2].getValues()
             return _coin.SoMFFloat_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFFloat_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFFloat_setValues(*args)



    def set1Value(self, idx: "int const", value: "float") -> "void":
        r"""set1Value(SoMFFloat self, int const idx, float value)"""
        return _coin.SoMFFloat_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFFloat") -> "SbBool":
        r"""__eq__(SoMFFloat self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___eq__(self, field)

    def __ne__(self, field: "SoMFFloat") -> "SbBool":
        r"""__ne__(SoMFFloat self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___ne__(self, field)

    def startEditing(self) -> "float *":
        r"""startEditing(SoMFFloat self) -> float *"""
        return _coin.SoMFFloat_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFFloat self)"""
        return _coin.SoMFFloat_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFFloat self, int const num, float const * userdata)
        setValuesPointer(SoMFFloat self, int const num, float * userdata)
        """
        return _coin.SoMFFloat_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFFloat_initClass()

    def __getitem__(self, i: "int") -> "float const":
        r"""__getitem__(SoMFFloat self, int i) -> float const"""
        return _coin.SoMFFloat___getitem__(self, i)

    def __setitem__(self, i: "int", value: "float") -> "void":
        r"""__setitem__(SoMFFloat self, int i, float value)"""
        return _coin.SoMFFloat___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFFloat self, float value)
        setValue(SoMFFloat self, SoMFFloat other)
        """
        return _coin.SoMFFloat_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "float const *":
        r"""getValues(SoMFFloat self, int i=0) -> float const"""
        return _coin.SoMFFloat_getValues(self, i)

# Register SoMFFloat in _coin:
_coin.SoMFFloat_swigregister(SoMFFloat)

def SoMFFloat_createInstance() -> "void *":
    r"""SoMFFloat_createInstance() -> void *"""
    return _coin.SoMFFloat_createInstance()

def SoMFFloat_getClassTypeId() -> "SoType":
    r"""SoMFFloat_getClassTypeId() -> SoType"""
    return _coin.SoMFFloat_getClassTypeId()

def SoMFFloat_initClass() -> "void":
    r"""SoMFFloat_initClass()"""
    return _coin.SoMFFloat_initClass()

class SoMFVec3f(SoMField):
    r"""Proxy of C++ SoMFVec3f class."""

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

    def __init__(self):
        r"""__init__(SoMFVec3f self) -> SoMFVec3f"""
        _coin.SoMFVec3f_swiginit(self, _coin.new_SoMFVec3f())
    __swig_destroy__ = _coin.delete_SoMFVec3f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec3f self) -> SoType"""
        return _coin.SoMFVec3f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec3f self, SoField field)"""
        return _coin.SoMFVec3f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec3f self, SoField field) -> SbBool"""
        return _coin.SoMFVec3f_isSame(self, field)

    def find(self, value: "SbVec3f", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec3f self, SbVec3f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3f_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec3f") -> "SbBool":
        r"""__eq__(SoMFVec3f self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___eq__(self, field)

    def __ne__(self, field: "SoMFVec3f") -> "SbBool":
        r"""__ne__(SoMFVec3f self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___ne__(self, field)

    def startEditing(self) -> "SbVec3f *":
        r"""startEditing(SoMFVec3f self) -> SbVec3f"""
        return _coin.SoMFVec3f_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec3f self)"""
        return _coin.SoMFVec3f_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec3f self, int const num, SbVec3f userdata)
        setValuesPointer(SoMFVec3f self, int const num, SbVec3f userdata)
        setValuesPointer(SoMFVec3f self, int const num, float const * userdata)
        setValuesPointer(SoMFVec3f self, int const num, float * userdata)
        """
        return _coin.SoMFVec3f_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec3f_initClass()

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec3f_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec3f_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec3f_setValues(*args)



    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec3f self, int const idx, SbVec3f value)
        set1Value(SoMFVec3f self, int idx, float x, float y, float z)
        set1Value(SoMFVec3f self, int idx, float const [3] xyz)
        """
        return _coin.SoMFVec3f_set1Value(self, *args)

    def __getitem__(self, i: "int") -> "SbVec3f const &":
        r"""__getitem__(SoMFVec3f self, int i) -> SbVec3f"""
        return _coin.SoMFVec3f___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbVec3f") -> "void":
        r"""__setitem__(SoMFVec3f self, int i, SbVec3f value)"""
        return _coin.SoMFVec3f___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec3f self, SbVec3f value)
        setValue(SoMFVec3f self, float x, float y, float z)
        setValue(SoMFVec3f self, float const [3] xyz)
        setValue(SoMFVec3f self, SoMFVec3f other)
        """
        return _coin.SoMFVec3f_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SbVec3f const *":
        r"""getValues(SoMFVec3f self, int i=0) -> SbVec3f"""
        return _coin.SoMFVec3f_getValues(self, i)

# Register SoMFVec3f in _coin:
_coin.SoMFVec3f_swigregister(SoMFVec3f)

def SoMFVec3f_createInstance() -> "void *":
    r"""SoMFVec3f_createInstance() -> void *"""
    return _coin.SoMFVec3f_createInstance()

def SoMFVec3f_getClassTypeId() -> "SoType":
    r"""SoMFVec3f_getClassTypeId() -> SoType"""
    return _coin.SoMFVec3f_getClassTypeId()

def SoMFVec3f_initClass() -> "void":
    r"""SoMFVec3f_initClass()"""
    return _coin.SoMFVec3f_initClass()

class SoMFString(SoMField):
    r"""Proxy of C++ SoMFString class."""

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

    def __init__(self):
        r"""__init__(SoMFString self) -> SoMFString"""
        _coin.SoMFString_swiginit(self, _coin.new_SoMFString())
    __swig_destroy__ = _coin.delete_SoMFString

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFString_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFString_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFString self) -> SoType"""
        return _coin.SoMFString_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFString self, SoField field)"""
        return _coin.SoMFString_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFString self, SoField field) -> SbBool"""
        return _coin.SoMFString_isSame(self, field)

    def find(self, value: "SbString", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFString self, SbString value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFString_find(self, value, addifnotfound)

    def set1Value(self, idx: "int const", value: "SbString") -> "void":
        r"""set1Value(SoMFString self, int const idx, SbString value)"""
        return _coin.SoMFString_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFString") -> "SbBool":
        r"""__eq__(SoMFString self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___eq__(self, field)

    def __ne__(self, field: "SoMFString") -> "SbBool":
        r"""__ne__(SoMFString self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___ne__(self, field)

    def startEditing(self) -> "SbString *":
        r"""startEditing(SoMFString self) -> SbString"""
        return _coin.SoMFString_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFString self)"""
        return _coin.SoMFString_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFString_initClass()

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFString_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFString_setValues(args[0], args[1], len(args[2]), args[2])
       return _coin.SoMFString_setValues(*args)



    def deleteText(self, fromline: "int const", fromchar: "int const", toline: "int const", tochar: "int const") -> "void":
        r"""deleteText(SoMFString self, int const fromline, int const fromchar, int const toline, int const tochar)"""
        return _coin.SoMFString_deleteText(self, fromline, fromchar, toline, tochar)

    def __getitem__(self, i: "int") -> "SbString const &":
        r"""__getitem__(SoMFString self, int i) -> SbString"""
        return _coin.SoMFString___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbString") -> "void":
        r"""__setitem__(SoMFString self, int i, SbString value)"""
        return _coin.SoMFString___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFString self, SbString value)
        setValue(SoMFString self, char const * string)
        setValue(SoMFString self, SoMFString other)
        """
        return _coin.SoMFString_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SbString const *":
        r"""getValues(SoMFString self, int i=0) -> SbString"""
        return _coin.SoMFString_getValues(self, i)

# Register SoMFString in _coin:
_coin.SoMFString_swigregister(SoMFString)

def SoMFString_createInstance() -> "void *":
    r"""SoMFString_createInstance() -> void *"""
    return _coin.SoMFString_createInstance()

def SoMFString_getClassTypeId() -> "SoType":
    r"""SoMFString_getClassTypeId() -> SoType"""
    return _coin.SoMFString_getClassTypeId()

def SoMFString_initClass() -> "void":
    r"""SoMFString_initClass()"""
    return _coin.SoMFString_initClass()

class SoCalculator(SoEngine):
    r"""Proxy of C++ SoCalculator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCalculator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCalculator self) -> SoType"""
        return _coin.SoCalculator_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoCalculator self) -> SoFieldData"""
        return _coin.SoCalculator_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoCalculator self) -> SoEngineOutputData"""
        return _coin.SoCalculator_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoCalculator_createInstance()
    a = property(_coin.SoCalculator_a_get, _coin.SoCalculator_a_set, doc=r"""a : SoMFFloat""")
    b = property(_coin.SoCalculator_b_get, _coin.SoCalculator_b_set, doc=r"""b : SoMFFloat""")
    c = property(_coin.SoCalculator_c_get, _coin.SoCalculator_c_set, doc=r"""c : SoMFFloat""")
    d = property(_coin.SoCalculator_d_get, _coin.SoCalculator_d_set, doc=r"""d : SoMFFloat""")
    e = property(_coin.SoCalculator_e_get, _coin.SoCalculator_e_set, doc=r"""e : SoMFFloat""")
    f = property(_coin.SoCalculator_f_get, _coin.SoCalculator_f_set, doc=r"""f : SoMFFloat""")
    g = property(_coin.SoCalculator_g_get, _coin.SoCalculator_g_set, doc=r"""g : SoMFFloat""")
    h = property(_coin.SoCalculator_h_get, _coin.SoCalculator_h_set, doc=r"""h : SoMFFloat""")
    A = property(_coin.SoCalculator_A_get, _coin.SoCalculator_A_set, doc=r"""A : SoMFVec3f""")
    B = property(_coin.SoCalculator_B_get, _coin.SoCalculator_B_set, doc=r"""B : SoMFVec3f""")
    C = property(_coin.SoCalculator_C_get, _coin.SoCalculator_C_set, doc=r"""C : SoMFVec3f""")
    D = property(_coin.SoCalculator_D_get, _coin.SoCalculator_D_set, doc=r"""D : SoMFVec3f""")
    E = property(_coin.SoCalculator_E_get, _coin.SoCalculator_E_set, doc=r"""E : SoMFVec3f""")
    F = property(_coin.SoCalculator_F_get, _coin.SoCalculator_F_set, doc=r"""F : SoMFVec3f""")
    G = property(_coin.SoCalculator_G_get, _coin.SoCalculator_G_set, doc=r"""G : SoMFVec3f""")
    H = property(_coin.SoCalculator_H_get, _coin.SoCalculator_H_set, doc=r"""H : SoMFVec3f""")
    expression = property(_coin.SoCalculator_expression_get, _coin.SoCalculator_expression_set, doc=r"""expression : SoMFString""")
    oa = property(_coin.SoCalculator_oa_get, _coin.SoCalculator_oa_set, doc=r"""oa : SoEngineOutput""")
    ob = property(_coin.SoCalculator_ob_get, _coin.SoCalculator_ob_set, doc=r"""ob : SoEngineOutput""")
    oc = property(_coin.SoCalculator_oc_get, _coin.SoCalculator_oc_set, doc=r"""oc : SoEngineOutput""")
    od = property(_coin.SoCalculator_od_get, _coin.SoCalculator_od_set, doc=r"""od : SoEngineOutput""")
    oA = property(_coin.SoCalculator_oA_get, _coin.SoCalculator_oA_set, doc=r"""oA : SoEngineOutput""")
    oB = property(_coin.SoCalculator_oB_get, _coin.SoCalculator_oB_set, doc=r"""oB : SoEngineOutput""")
    oC = property(_coin.SoCalculator_oC_get, _coin.SoCalculator_oC_set, doc=r"""oC : SoEngineOutput""")
    oD = property(_coin.SoCalculator_oD_get, _coin.SoCalculator_oD_set, doc=r"""oD : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoCalculator self) -> SoCalculator"""
        _coin.SoCalculator_swiginit(self, _coin.new_SoCalculator())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCalculator_initClass()

# Register SoCalculator in _coin:
_coin.SoCalculator_swigregister(SoCalculator)

def SoCalculator_getClassTypeId() -> "SoType":
    r"""SoCalculator_getClassTypeId() -> SoType"""
    return _coin.SoCalculator_getClassTypeId()

def SoCalculator_createInstance() -> "void *":
    r"""SoCalculator_createInstance() -> void *"""
    return _coin.SoCalculator_createInstance()

def SoCalculator_initClass() -> "void":
    r"""SoCalculator_initClass()"""
    return _coin.SoCalculator_initClass()

class SoMFVec2f(SoMField):
    r"""Proxy of C++ SoMFVec2f class."""

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

    def __init__(self):
        r"""__init__(SoMFVec2f self) -> SoMFVec2f"""
        _coin.SoMFVec2f_swiginit(self, _coin.new_SoMFVec2f())
    __swig_destroy__ = _coin.delete_SoMFVec2f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec2f self) -> SoType"""
        return _coin.SoMFVec2f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec2f self, SoField field)"""
        return _coin.SoMFVec2f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec2f self, SoField field) -> SbBool"""
        return _coin.SoMFVec2f_isSame(self, field)

    def find(self, value: "SbVec2f", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec2f self, SbVec2f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2f_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec2f") -> "SbBool":
        r"""__eq__(SoMFVec2f self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___eq__(self, field)

    def __ne__(self, field: "SoMFVec2f") -> "SbBool":
        r"""__ne__(SoMFVec2f self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___ne__(self, field)

    def startEditing(self) -> "SbVec2f *":
        r"""startEditing(SoMFVec2f self) -> SbVec2f"""
        return _coin.SoMFVec2f_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec2f self)"""
        return _coin.SoMFVec2f_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec2f self, int const num, SbVec2f userdata)
        setValuesPointer(SoMFVec2f self, int const num, SbVec2f userdata)
        setValuesPointer(SoMFVec2f self, int const num, float const * userdata)
        setValuesPointer(SoMFVec2f self, int const num, float * userdata)
        """
        return _coin.SoMFVec2f_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec2f_initClass()

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec2f_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec2f_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec2f_setValues(*args)



    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec2f self, int const idx, SbVec2f value)
        set1Value(SoMFVec2f self, int idx, float x, float y)
        set1Value(SoMFVec2f self, int idx, float const [2] xy)
        """
        return _coin.SoMFVec2f_set1Value(self, *args)

    def __getitem__(self, i: "int") -> "SbVec2f const &":
        r"""__getitem__(SoMFVec2f self, int i) -> SbVec2f"""
        return _coin.SoMFVec2f___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbVec2f") -> "void":
        r"""__setitem__(SoMFVec2f self, int i, SbVec2f value)"""
        return _coin.SoMFVec2f___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec2f self, SbVec2f value)
        setValue(SoMFVec2f self, float x, float y)
        setValue(SoMFVec2f self, float const [2] xy)
        setValue(SoMFVec2f self, SoMFVec2f other)
        """
        return _coin.SoMFVec2f_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SbVec2f const *":
        r"""getValues(SoMFVec2f self, int i=0) -> SbVec2f"""
        return _coin.SoMFVec2f_getValues(self, i)

# Register SoMFVec2f in _coin:
_coin.SoMFVec2f_swigregister(SoMFVec2f)

def SoMFVec2f_createInstance() -> "void *":
    r"""SoMFVec2f_createInstance() -> void *"""
    return _coin.SoMFVec2f_createInstance()

def SoMFVec2f_getClassTypeId() -> "SoType":
    r"""SoMFVec2f_getClassTypeId() -> SoType"""
    return _coin.SoMFVec2f_getClassTypeId()

def SoMFVec2f_initClass() -> "void":
    r"""SoMFVec2f_initClass()"""
    return _coin.SoMFVec2f_initClass()

class SoComposeVec2f(SoEngine):
    r"""Proxy of C++ SoComposeVec2f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeVec2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComposeVec2f self) -> SoType"""
        return _coin.SoComposeVec2f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoComposeVec2f self) -> SoFieldData"""
        return _coin.SoComposeVec2f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoComposeVec2f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec2f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComposeVec2f_createInstance()

    def __init__(self):
        r"""__init__(SoComposeVec2f self) -> SoComposeVec2f"""
        _coin.SoComposeVec2f_swiginit(self, _coin.new_SoComposeVec2f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComposeVec2f_initClass()
    x = property(_coin.SoComposeVec2f_x_get, _coin.SoComposeVec2f_x_set, doc=r"""x : SoMFFloat""")
    y = property(_coin.SoComposeVec2f_y_get, _coin.SoComposeVec2f_y_set, doc=r"""y : SoMFFloat""")
    vector = property(_coin.SoComposeVec2f_vector_get, _coin.SoComposeVec2f_vector_set, doc=r"""vector : SoEngineOutput""")

# Register SoComposeVec2f in _coin:
_coin.SoComposeVec2f_swigregister(SoComposeVec2f)

def SoComposeVec2f_getClassTypeId() -> "SoType":
    r"""SoComposeVec2f_getClassTypeId() -> SoType"""
    return _coin.SoComposeVec2f_getClassTypeId()

def SoComposeVec2f_createInstance() -> "void *":
    r"""SoComposeVec2f_createInstance() -> void *"""
    return _coin.SoComposeVec2f_createInstance()

def SoComposeVec2f_initClass() -> "void":
    r"""SoComposeVec2f_initClass()"""
    return _coin.SoComposeVec2f_initClass()

class SoComposeVec3f(SoEngine):
    r"""Proxy of C++ SoComposeVec3f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeVec3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComposeVec3f self) -> SoType"""
        return _coin.SoComposeVec3f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoComposeVec3f self) -> SoFieldData"""
        return _coin.SoComposeVec3f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoComposeVec3f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec3f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComposeVec3f_createInstance()

    def __init__(self):
        r"""__init__(SoComposeVec3f self) -> SoComposeVec3f"""
        _coin.SoComposeVec3f_swiginit(self, _coin.new_SoComposeVec3f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComposeVec3f_initClass()
    x = property(_coin.SoComposeVec3f_x_get, _coin.SoComposeVec3f_x_set, doc=r"""x : SoMFFloat""")
    y = property(_coin.SoComposeVec3f_y_get, _coin.SoComposeVec3f_y_set, doc=r"""y : SoMFFloat""")
    z = property(_coin.SoComposeVec3f_z_get, _coin.SoComposeVec3f_z_set, doc=r"""z : SoMFFloat""")
    vector = property(_coin.SoComposeVec3f_vector_get, _coin.SoComposeVec3f_vector_set, doc=r"""vector : SoEngineOutput""")

# Register SoComposeVec3f in _coin:
_coin.SoComposeVec3f_swigregister(SoComposeVec3f)

def SoComposeVec3f_getClassTypeId() -> "SoType":
    r"""SoComposeVec3f_getClassTypeId() -> SoType"""
    return _coin.SoComposeVec3f_getClassTypeId()

def SoComposeVec3f_createInstance() -> "void *":
    r"""SoComposeVec3f_createInstance() -> void *"""
    return _coin.SoComposeVec3f_createInstance()

def SoComposeVec3f_initClass() -> "void":
    r"""SoComposeVec3f_initClass()"""
    return _coin.SoComposeVec3f_initClass()

class SoMFVec4f(SoMField):
    r"""Proxy of C++ SoMFVec4f class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4f self) -> SoMFVec4f"""
        _coin.SoMFVec4f_swiginit(self, _coin.new_SoMFVec4f())
    __swig_destroy__ = _coin.delete_SoMFVec4f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4f self) -> SoType"""
        return _coin.SoMFVec4f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4f self, SoField field)"""
        return _coin.SoMFVec4f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4f self, SoField field) -> SbBool"""
        return _coin.SoMFVec4f_isSame(self, field)

    def find(self, value: "SbVec4f", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4f self, SbVec4f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4f_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4f") -> "SbBool":
        r"""__eq__(SoMFVec4f self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___eq__(self, field)

    def __ne__(self, field: "SoMFVec4f") -> "SbBool":
        r"""__ne__(SoMFVec4f self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___ne__(self, field)

    def startEditing(self) -> "SbVec4f *":
        r"""startEditing(SoMFVec4f self) -> SbVec4f"""
        return _coin.SoMFVec4f_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4f self)"""
        return _coin.SoMFVec4f_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4f self, int const num, SbVec4f userdata)
        setValuesPointer(SoMFVec4f self, int const num, SbVec4f userdata)
        setValuesPointer(SoMFVec4f self, int const num, float const * userdata)
        setValuesPointer(SoMFVec4f self, int const num, float * userdata)
        """
        return _coin.SoMFVec4f_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4f_initClass()

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec4f_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec4f_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec4f_setValues(*args)



    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4f self, int const idx, SbVec4f value)
        set1Value(SoMFVec4f self, int idx, float x, float y, float z, float w)
        set1Value(SoMFVec4f self, int idx, float const [4] xyzw)
        """
        return _coin.SoMFVec4f_set1Value(self, *args)

    def __getitem__(self, i: "int") -> "SbVec4f const &":
        r"""__getitem__(SoMFVec4f self, int i) -> SbVec4f"""
        return _coin.SoMFVec4f___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbVec4f") -> "void":
        r"""__setitem__(SoMFVec4f self, int i, SbVec4f value)"""
        return _coin.SoMFVec4f___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4f self, SbVec4f value)
        setValue(SoMFVec4f self, float x, float y, float z, float w)
        setValue(SoMFVec4f self, float const [4] xyzw)
        setValue(SoMFVec4f self, SoMFVec4f other)
        """
        return _coin.SoMFVec4f_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SbVec4f const *":
        r"""getValues(SoMFVec4f self, int i=0) -> SbVec4f"""
        return _coin.SoMFVec4f_getValues(self, i)

# Register SoMFVec4f in _coin:
_coin.SoMFVec4f_swigregister(SoMFVec4f)

def SoMFVec4f_createInstance() -> "void *":
    r"""SoMFVec4f_createInstance() -> void *"""
    return _coin.SoMFVec4f_createInstance()

def SoMFVec4f_getClassTypeId() -> "SoType":
    r"""SoMFVec4f_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4f_getClassTypeId()

def SoMFVec4f_initClass() -> "void":
    r"""SoMFVec4f_initClass()"""
    return _coin.SoMFVec4f_initClass()

class SoComposeVec4f(SoEngine):
    r"""Proxy of C++ SoComposeVec4f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeVec4f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComposeVec4f self) -> SoType"""
        return _coin.SoComposeVec4f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoComposeVec4f self) -> SoFieldData"""
        return _coin.SoComposeVec4f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoComposeVec4f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec4f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComposeVec4f_createInstance()

    def __init__(self):
        r"""__init__(SoComposeVec4f self) -> SoComposeVec4f"""
        _coin.SoComposeVec4f_swiginit(self, _coin.new_SoComposeVec4f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComposeVec4f_initClass()
    x = property(_coin.SoComposeVec4f_x_get, _coin.SoComposeVec4f_x_set, doc=r"""x : SoMFFloat""")
    y = property(_coin.SoComposeVec4f_y_get, _coin.SoComposeVec4f_y_set, doc=r"""y : SoMFFloat""")
    z = property(_coin.SoComposeVec4f_z_get, _coin.SoComposeVec4f_z_set, doc=r"""z : SoMFFloat""")
    w = property(_coin.SoComposeVec4f_w_get, _coin.SoComposeVec4f_w_set, doc=r"""w : SoMFFloat""")
    vector = property(_coin.SoComposeVec4f_vector_get, _coin.SoComposeVec4f_vector_set, doc=r"""vector : SoEngineOutput""")

# Register SoComposeVec4f in _coin:
_coin.SoComposeVec4f_swigregister(SoComposeVec4f)

def SoComposeVec4f_getClassTypeId() -> "SoType":
    r"""SoComposeVec4f_getClassTypeId() -> SoType"""
    return _coin.SoComposeVec4f_getClassTypeId()

def SoComposeVec4f_createInstance() -> "void *":
    r"""SoComposeVec4f_createInstance() -> void *"""
    return _coin.SoComposeVec4f_createInstance()

def SoComposeVec4f_initClass() -> "void":
    r"""SoComposeVec4f_initClass()"""
    return _coin.SoComposeVec4f_initClass()

class SoDecomposeVec2f(SoEngine):
    r"""Proxy of C++ SoDecomposeVec2f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDecomposeVec2f self) -> SoType"""
        return _coin.SoDecomposeVec2f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoDecomposeVec2f self) -> SoFieldData"""
        return _coin.SoDecomposeVec2f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoDecomposeVec2f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec2f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeVec2f_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeVec2f self) -> SoDecomposeVec2f"""
        _coin.SoDecomposeVec2f_swiginit(self, _coin.new_SoDecomposeVec2f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDecomposeVec2f_initClass()
    vector = property(_coin.SoDecomposeVec2f_vector_get, _coin.SoDecomposeVec2f_vector_set, doc=r"""vector : SoMFVec2f""")
    x = property(_coin.SoDecomposeVec2f_x_get, _coin.SoDecomposeVec2f_x_set, doc=r"""x : SoEngineOutput""")
    y = property(_coin.SoDecomposeVec2f_y_get, _coin.SoDecomposeVec2f_y_set, doc=r"""y : SoEngineOutput""")

# Register SoDecomposeVec2f in _coin:
_coin.SoDecomposeVec2f_swigregister(SoDecomposeVec2f)

def SoDecomposeVec2f_getClassTypeId() -> "SoType":
    r"""SoDecomposeVec2f_getClassTypeId() -> SoType"""
    return _coin.SoDecomposeVec2f_getClassTypeId()

def SoDecomposeVec2f_createInstance() -> "void *":
    r"""SoDecomposeVec2f_createInstance() -> void *"""
    return _coin.SoDecomposeVec2f_createInstance()

def SoDecomposeVec2f_initClass() -> "void":
    r"""SoDecomposeVec2f_initClass()"""
    return _coin.SoDecomposeVec2f_initClass()

class SoDecomposeVec3f(SoEngine):
    r"""Proxy of C++ SoDecomposeVec3f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDecomposeVec3f self) -> SoType"""
        return _coin.SoDecomposeVec3f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoDecomposeVec3f self) -> SoFieldData"""
        return _coin.SoDecomposeVec3f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoDecomposeVec3f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec3f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeVec3f_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeVec3f self) -> SoDecomposeVec3f"""
        _coin.SoDecomposeVec3f_swiginit(self, _coin.new_SoDecomposeVec3f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDecomposeVec3f_initClass()
    vector = property(_coin.SoDecomposeVec3f_vector_get, _coin.SoDecomposeVec3f_vector_set, doc=r"""vector : SoMFVec3f""")
    x = property(_coin.SoDecomposeVec3f_x_get, _coin.SoDecomposeVec3f_x_set, doc=r"""x : SoEngineOutput""")
    y = property(_coin.SoDecomposeVec3f_y_get, _coin.SoDecomposeVec3f_y_set, doc=r"""y : SoEngineOutput""")
    z = property(_coin.SoDecomposeVec3f_z_get, _coin.SoDecomposeVec3f_z_set, doc=r"""z : SoEngineOutput""")

# Register SoDecomposeVec3f in _coin:
_coin.SoDecomposeVec3f_swigregister(SoDecomposeVec3f)

def SoDecomposeVec3f_getClassTypeId() -> "SoType":
    r"""SoDecomposeVec3f_getClassTypeId() -> SoType"""
    return _coin.SoDecomposeVec3f_getClassTypeId()

def SoDecomposeVec3f_createInstance() -> "void *":
    r"""SoDecomposeVec3f_createInstance() -> void *"""
    return _coin.SoDecomposeVec3f_createInstance()

def SoDecomposeVec3f_initClass() -> "void":
    r"""SoDecomposeVec3f_initClass()"""
    return _coin.SoDecomposeVec3f_initClass()

class SoDecomposeVec4f(SoEngine):
    r"""Proxy of C++ SoDecomposeVec4f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec4f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDecomposeVec4f self) -> SoType"""
        return _coin.SoDecomposeVec4f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoDecomposeVec4f self) -> SoFieldData"""
        return _coin.SoDecomposeVec4f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoDecomposeVec4f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec4f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeVec4f_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeVec4f self) -> SoDecomposeVec4f"""
        _coin.SoDecomposeVec4f_swiginit(self, _coin.new_SoDecomposeVec4f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDecomposeVec4f_initClass()
    vector = property(_coin.SoDecomposeVec4f_vector_get, _coin.SoDecomposeVec4f_vector_set, doc=r"""vector : SoMFVec4f""")
    x = property(_coin.SoDecomposeVec4f_x_get, _coin.SoDecomposeVec4f_x_set, doc=r"""x : SoEngineOutput""")
    y = property(_coin.SoDecomposeVec4f_y_get, _coin.SoDecomposeVec4f_y_set, doc=r"""y : SoEngineOutput""")
    z = property(_coin.SoDecomposeVec4f_z_get, _coin.SoDecomposeVec4f_z_set, doc=r"""z : SoEngineOutput""")
    w = property(_coin.SoDecomposeVec4f_w_get, _coin.SoDecomposeVec4f_w_set, doc=r"""w : SoEngineOutput""")

# Register SoDecomposeVec4f in _coin:
_coin.SoDecomposeVec4f_swigregister(SoDecomposeVec4f)

def SoDecomposeVec4f_getClassTypeId() -> "SoType":
    r"""SoDecomposeVec4f_getClassTypeId() -> SoType"""
    return _coin.SoDecomposeVec4f_getClassTypeId()

def SoDecomposeVec4f_createInstance() -> "void *":
    r"""SoDecomposeVec4f_createInstance() -> void *"""
    return _coin.SoDecomposeVec4f_createInstance()

def SoDecomposeVec4f_initClass() -> "void":
    r"""SoDecomposeVec4f_initClass()"""
    return _coin.SoDecomposeVec4f_initClass()

class SoComposeRotation(SoEngine):
    r"""Proxy of C++ SoComposeRotation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeRotation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComposeRotation self) -> SoType"""
        return _coin.SoComposeRotation_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoComposeRotation self) -> SoFieldData"""
        return _coin.SoComposeRotation_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoComposeRotation self) -> SoEngineOutputData"""
        return _coin.SoComposeRotation_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComposeRotation_createInstance()

    def __init__(self):
        r"""__init__(SoComposeRotation self) -> SoComposeRotation"""
        _coin.SoComposeRotation_swiginit(self, _coin.new_SoComposeRotation())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComposeRotation_initClass()
    axis = property(_coin.SoComposeRotation_axis_get, _coin.SoComposeRotation_axis_set, doc=r"""axis : SoMFVec3f""")
    angle = property(_coin.SoComposeRotation_angle_get, _coin.SoComposeRotation_angle_set, doc=r"""angle : SoMFFloat""")
    rotation = property(_coin.SoComposeRotation_rotation_get, _coin.SoComposeRotation_rotation_set, doc=r"""rotation : SoEngineOutput""")

# Register SoComposeRotation in _coin:
_coin.SoComposeRotation_swigregister(SoComposeRotation)

def SoComposeRotation_getClassTypeId() -> "SoType":
    r"""SoComposeRotation_getClassTypeId() -> SoType"""
    return _coin.SoComposeRotation_getClassTypeId()

def SoComposeRotation_createInstance() -> "void *":
    r"""SoComposeRotation_createInstance() -> void *"""
    return _coin.SoComposeRotation_createInstance()

def SoComposeRotation_initClass() -> "void":
    r"""SoComposeRotation_initClass()"""
    return _coin.SoComposeRotation_initClass()

class SoMFRotation(SoMField):
    r"""Proxy of C++ SoMFRotation class."""

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

    def __init__(self):
        r"""__init__(SoMFRotation self) -> SoMFRotation"""
        _coin.SoMFRotation_swiginit(self, _coin.new_SoMFRotation())
    __swig_destroy__ = _coin.delete_SoMFRotation

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFRotation_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFRotation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFRotation self) -> SoType"""
        return _coin.SoMFRotation_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFRotation self, SoField field)"""
        return _coin.SoMFRotation_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFRotation self, SoField field) -> SbBool"""
        return _coin.SoMFRotation_isSame(self, field)

    def find(self, value: "SbRotation", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFRotation self, SbRotation value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFRotation_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFRotation") -> "SbBool":
        r"""__eq__(SoMFRotation self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___eq__(self, field)

    def __ne__(self, field: "SoMFRotation") -> "SbBool":
        r"""__ne__(SoMFRotation self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___ne__(self, field)

    def startEditing(self) -> "SbRotation *":
        r"""startEditing(SoMFRotation self) -> SbRotation"""
        return _coin.SoMFRotation_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFRotation self)"""
        return _coin.SoMFRotation_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFRotation_initClass()

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFRotation_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFRotation_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFRotation_setValues(*args)



    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFRotation self, int const idx, SbRotation value)
        set1Value(SoMFRotation self, int const idx, float const q0, float const q1, float const q2, float const q3)
        set1Value(SoMFRotation self, int const idx, float const [4] q)
        set1Value(SoMFRotation self, int const idx, SbVec3f axis, float const angle)
        """
        return _coin.SoMFRotation_set1Value(self, *args)

    def __getitem__(self, i: "int") -> "SbRotation const &":
        r"""__getitem__(SoMFRotation self, int i) -> SbRotation"""
        return _coin.SoMFRotation___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbRotation") -> "void":
        r"""__setitem__(SoMFRotation self, int i, SbRotation value)"""
        return _coin.SoMFRotation___setitem__(self, i, value)

    def getValues(self, i: "int"=0) -> "SbRotation const *":
        r"""getValues(SoMFRotation self, int i=0) -> SbRotation"""
        return _coin.SoMFRotation_getValues(self, i)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFRotation self, SbRotation value)
        setValue(SoMFRotation self, float const q0, float const q1, float const q2, float const q3)
        setValue(SoMFRotation self, float const [4] q)
        setValue(SoMFRotation self, SbVec3f axis, float const angle)
        setValue(SoMFRotation self, SoMFRotation other)
        """
        return _coin.SoMFRotation_setValue(self, *args)

# Register SoMFRotation in _coin:
_coin.SoMFRotation_swigregister(SoMFRotation)

def SoMFRotation_createInstance() -> "void *":
    r"""SoMFRotation_createInstance() -> void *"""
    return _coin.SoMFRotation_createInstance()

def SoMFRotation_getClassTypeId() -> "SoType":
    r"""SoMFRotation_getClassTypeId() -> SoType"""
    return _coin.SoMFRotation_getClassTypeId()

def SoMFRotation_initClass() -> "void":
    r"""SoMFRotation_initClass()"""
    return _coin.SoMFRotation_initClass()

class SoDecomposeRotation(SoEngine):
    r"""Proxy of C++ SoDecomposeRotation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeRotation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDecomposeRotation self) -> SoType"""
        return _coin.SoDecomposeRotation_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoDecomposeRotation self) -> SoFieldData"""
        return _coin.SoDecomposeRotation_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoDecomposeRotation self) -> SoEngineOutputData"""
        return _coin.SoDecomposeRotation_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeRotation_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeRotation self) -> SoDecomposeRotation"""
        _coin.SoDecomposeRotation_swiginit(self, _coin.new_SoDecomposeRotation())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDecomposeRotation_initClass()
    rotation = property(_coin.SoDecomposeRotation_rotation_get, _coin.SoDecomposeRotation_rotation_set, doc=r"""rotation : SoMFRotation""")
    axis = property(_coin.SoDecomposeRotation_axis_get, _coin.SoDecomposeRotation_axis_set, doc=r"""axis : SoEngineOutput""")
    angle = property(_coin.SoDecomposeRotation_angle_get, _coin.SoDecomposeRotation_angle_set, doc=r"""angle : SoEngineOutput""")

# Register SoDecomposeRotation in _coin:
_coin.SoDecomposeRotation_swigregister(SoDecomposeRotation)

def SoDecomposeRotation_getClassTypeId() -> "SoType":
    r"""SoDecomposeRotation_getClassTypeId() -> SoType"""
    return _coin.SoDecomposeRotation_getClassTypeId()

def SoDecomposeRotation_createInstance() -> "void *":
    r"""SoDecomposeRotation_createInstance() -> void *"""
    return _coin.SoDecomposeRotation_createInstance()

def SoDecomposeRotation_initClass() -> "void":
    r"""SoDecomposeRotation_initClass()"""
    return _coin.SoDecomposeRotation_initClass()

class SoComposeMatrix(SoEngine):
    r"""Proxy of C++ SoComposeMatrix class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeMatrix_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComposeMatrix self) -> SoType"""
        return _coin.SoComposeMatrix_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoComposeMatrix self) -> SoFieldData"""
        return _coin.SoComposeMatrix_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoComposeMatrix self) -> SoEngineOutputData"""
        return _coin.SoComposeMatrix_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComposeMatrix_createInstance()

    def __init__(self):
        r"""__init__(SoComposeMatrix self) -> SoComposeMatrix"""
        _coin.SoComposeMatrix_swiginit(self, _coin.new_SoComposeMatrix())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComposeMatrix_initClass()
    translation = property(_coin.SoComposeMatrix_translation_get, _coin.SoComposeMatrix_translation_set, doc=r"""translation : SoMFVec3f""")
    rotation = property(_coin.SoComposeMatrix_rotation_get, _coin.SoComposeMatrix_rotation_set, doc=r"""rotation : SoMFRotation""")
    scaleFactor = property(_coin.SoComposeMatrix_scaleFactor_get, _coin.SoComposeMatrix_scaleFactor_set, doc=r"""scaleFactor : SoMFVec3f""")
    scaleOrientation = property(_coin.SoComposeMatrix_scaleOrientation_get, _coin.SoComposeMatrix_scaleOrientation_set, doc=r"""scaleOrientation : SoMFRotation""")
    center = property(_coin.SoComposeMatrix_center_get, _coin.SoComposeMatrix_center_set, doc=r"""center : SoMFVec3f""")
    matrix = property(_coin.SoComposeMatrix_matrix_get, _coin.SoComposeMatrix_matrix_set, doc=r"""matrix : SoEngineOutput""")

# Register SoComposeMatrix in _coin:
_coin.SoComposeMatrix_swigregister(SoComposeMatrix)

def SoComposeMatrix_getClassTypeId() -> "SoType":
    r"""SoComposeMatrix_getClassTypeId() -> SoType"""
    return _coin.SoComposeMatrix_getClassTypeId()

def SoComposeMatrix_createInstance() -> "void *":
    r"""SoComposeMatrix_createInstance() -> void *"""
    return _coin.SoComposeMatrix_createInstance()

def SoComposeMatrix_initClass() -> "void":
    r"""SoComposeMatrix_initClass()"""
    return _coin.SoComposeMatrix_initClass()

class SoMFMatrix(SoMField):
    r"""Proxy of C++ SoMFMatrix class."""

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

    def __init__(self):
        r"""__init__(SoMFMatrix self) -> SoMFMatrix"""
        _coin.SoMFMatrix_swiginit(self, _coin.new_SoMFMatrix())
    __swig_destroy__ = _coin.delete_SoMFMatrix

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFMatrix_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFMatrix_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFMatrix self) -> SoType"""
        return _coin.SoMFMatrix_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFMatrix self, SoField field)"""
        return _coin.SoMFMatrix_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFMatrix self, SoField field) -> SbBool"""
        return _coin.SoMFMatrix_isSame(self, field)

    def find(self, value: "SbMatrix", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFMatrix self, SbMatrix value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFMatrix_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFMatrix_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFMatrix_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFMatrix_setValues(*args)



    def set1Value(self, idx: "int const", value: "SbMatrix") -> "void":
        r"""set1Value(SoMFMatrix self, int const idx, SbMatrix value)"""
        return _coin.SoMFMatrix_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFMatrix") -> "SbBool":
        r"""__eq__(SoMFMatrix self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___eq__(self, field)

    def __ne__(self, field: "SoMFMatrix") -> "SbBool":
        r"""__ne__(SoMFMatrix self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___ne__(self, field)

    def startEditing(self) -> "SbMatrix *":
        r"""startEditing(SoMFMatrix self) -> SbMatrix"""
        return _coin.SoMFMatrix_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFMatrix self)"""
        return _coin.SoMFMatrix_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFMatrix_initClass()

    def __getitem__(self, i: "int") -> "SbMatrix const &":
        r"""__getitem__(SoMFMatrix self, int i) -> SbMatrix"""
        return _coin.SoMFMatrix___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbMatrix") -> "void":
        r"""__setitem__(SoMFMatrix self, int i, SbMatrix value)"""
        return _coin.SoMFMatrix___setitem__(self, i, value)

    def getValues(self, i: "int"=0) -> "SbMatrix const *":
        r"""getValues(SoMFMatrix self, int i=0) -> SbMatrix"""
        return _coin.SoMFMatrix_getValues(self, i)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFMatrix self, SbMatrix value)
        setValue(SoMFMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44)
        setValue(SoMFMatrix self, SoMFMatrix other)
        """
        return _coin.SoMFMatrix_setValue(self, *args)

# Register SoMFMatrix in _coin:
_coin.SoMFMatrix_swigregister(SoMFMatrix)

def SoMFMatrix_createInstance() -> "void *":
    r"""SoMFMatrix_createInstance() -> void *"""
    return _coin.SoMFMatrix_createInstance()

def SoMFMatrix_getClassTypeId() -> "SoType":
    r"""SoMFMatrix_getClassTypeId() -> SoType"""
    return _coin.SoMFMatrix_getClassTypeId()

def SoMFMatrix_initClass() -> "void":
    r"""SoMFMatrix_initClass()"""
    return _coin.SoMFMatrix_initClass()

class SoDecomposeMatrix(SoEngine):
    r"""Proxy of C++ SoDecomposeMatrix class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeMatrix_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDecomposeMatrix self) -> SoType"""
        return _coin.SoDecomposeMatrix_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoDecomposeMatrix self) -> SoFieldData"""
        return _coin.SoDecomposeMatrix_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoDecomposeMatrix self) -> SoEngineOutputData"""
        return _coin.SoDecomposeMatrix_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeMatrix_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeMatrix self) -> SoDecomposeMatrix"""
        _coin.SoDecomposeMatrix_swiginit(self, _coin.new_SoDecomposeMatrix())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDecomposeMatrix_initClass()
    matrix = property(_coin.SoDecomposeMatrix_matrix_get, _coin.SoDecomposeMatrix_matrix_set, doc=r"""matrix : SoMFMatrix""")
    center = property(_coin.SoDecomposeMatrix_center_get, _coin.SoDecomposeMatrix_center_set, doc=r"""center : SoMFVec3f""")
    translation = property(_coin.SoDecomposeMatrix_translation_get, _coin.SoDecomposeMatrix_translation_set, doc=r"""translation : SoEngineOutput""")
    rotation = property(_coin.SoDecomposeMatrix_rotation_get, _coin.SoDecomposeMatrix_rotation_set, doc=r"""rotation : SoEngineOutput""")
    scaleFactor = property(_coin.SoDecomposeMatrix_scaleFactor_get, _coin.SoDecomposeMatrix_scaleFactor_set, doc=r"""scaleFactor : SoEngineOutput""")
    scaleOrientation = property(_coin.SoDecomposeMatrix_scaleOrientation_get, _coin.SoDecomposeMatrix_scaleOrientation_set, doc=r"""scaleOrientation : SoEngineOutput""")

# Register SoDecomposeMatrix in _coin:
_coin.SoDecomposeMatrix_swigregister(SoDecomposeMatrix)

def SoDecomposeMatrix_getClassTypeId() -> "SoType":
    r"""SoDecomposeMatrix_getClassTypeId() -> SoType"""
    return _coin.SoDecomposeMatrix_getClassTypeId()

def SoDecomposeMatrix_createInstance() -> "void *":
    r"""SoDecomposeMatrix_createInstance() -> void *"""
    return _coin.SoDecomposeMatrix_createInstance()

def SoDecomposeMatrix_initClass() -> "void":
    r"""SoDecomposeMatrix_initClass()"""
    return _coin.SoDecomposeMatrix_initClass()

class SoComposeRotationFromTo(SoEngine):
    r"""Proxy of C++ SoComposeRotationFromTo class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeRotationFromTo_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComposeRotationFromTo self) -> SoType"""
        return _coin.SoComposeRotationFromTo_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoComposeRotationFromTo self) -> SoFieldData"""
        return _coin.SoComposeRotationFromTo_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoComposeRotationFromTo self) -> SoEngineOutputData"""
        return _coin.SoComposeRotationFromTo_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComposeRotationFromTo_createInstance()

    def __init__(self):
        r"""__init__(SoComposeRotationFromTo self) -> SoComposeRotationFromTo"""
        _coin.SoComposeRotationFromTo_swiginit(self, _coin.new_SoComposeRotationFromTo())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComposeRotationFromTo_initClass()
    srcFrom = property(_coin.SoComposeRotationFromTo_srcFrom_get, _coin.SoComposeRotationFromTo_srcFrom_set, doc=r"""srcFrom : SoMFVec3f""")
    destTo = property(_coin.SoComposeRotationFromTo_destTo_get, _coin.SoComposeRotationFromTo_destTo_set, doc=r"""destTo : SoMFVec3f""")
    rotation = property(_coin.SoComposeRotationFromTo_rotation_get, _coin.SoComposeRotationFromTo_rotation_set, doc=r"""rotation : SoEngineOutput""")

# Register SoComposeRotationFromTo in _coin:
_coin.SoComposeRotationFromTo_swigregister(SoComposeRotationFromTo)

def SoComposeRotationFromTo_getClassTypeId() -> "SoType":
    r"""SoComposeRotationFromTo_getClassTypeId() -> SoType"""
    return _coin.SoComposeRotationFromTo_getClassTypeId()

def SoComposeRotationFromTo_createInstance() -> "void *":
    r"""SoComposeRotationFromTo_createInstance() -> void *"""
    return _coin.SoComposeRotationFromTo_createInstance()

def SoComposeRotationFromTo_initClass() -> "void":
    r"""SoComposeRotationFromTo_initClass()"""
    return _coin.SoComposeRotationFromTo_initClass()

class SoSFPath(SoSField):
    r"""Proxy of C++ SoSFPath class."""

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

    def __init__(self):
        r"""__init__(SoSFPath self) -> SoSFPath"""
        _coin.SoSFPath_swiginit(self, _coin.new_SoSFPath())
    __swig_destroy__ = _coin.delete_SoSFPath

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFPath_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFPath_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFPath self) -> SoType"""
        return _coin.SoSFPath_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFPath self, SoField field)"""
        return _coin.SoSFPath_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFPath self, SoField field) -> SbBool"""
        return _coin.SoSFPath_isSame(self, field)

    def getValue(self) -> "SoPath *":
        r"""getValue(SoSFPath self) -> SoPath"""
        return _coin.SoSFPath_getValue(self)

    def __eq__(self, field: "SoSFPath") -> "int":
        r"""__eq__(SoSFPath self, SoSFPath field) -> int"""
        return _coin.SoSFPath___eq__(self, field)

    def __ne__(self, field: "SoSFPath") -> "int":
        r"""__ne__(SoSFPath self, SoSFPath field) -> int"""
        return _coin.SoSFPath___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFPath_initClass()

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoSFPath self, SoNotList l)"""
        return _coin.SoSFPath_notify(self, l)

    def fixCopy(self, copyconnections: "SbBool") -> "void":
        r"""fixCopy(SoSFPath self, SbBool copyconnections)"""
        return _coin.SoSFPath_fixCopy(self, copyconnections)

    def referencesCopy(self) -> "SbBool":
        r"""referencesCopy(SoSFPath self) -> SbBool"""
        return _coin.SoSFPath_referencesCopy(self)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFPath self, SoPath newvalue)
        setValue(SoSFPath self, SoSFPath other)
        """
        return _coin.SoSFPath_setValue(self, *args)

# Register SoSFPath in _coin:
_coin.SoSFPath_swigregister(SoSFPath)

def SoSFPath_createInstance() -> "void *":
    r"""SoSFPath_createInstance() -> void *"""
    return _coin.SoSFPath_createInstance()

def SoSFPath_getClassTypeId() -> "SoType":
    r"""SoSFPath_getClassTypeId() -> SoType"""
    return _coin.SoSFPath_getClassTypeId()

def SoSFPath_initClass() -> "void":
    r"""SoSFPath_initClass()"""
    return _coin.SoSFPath_initClass()

class SoComputeBoundingBox(SoEngine):
    r"""Proxy of C++ SoComputeBoundingBox class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComputeBoundingBox_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoComputeBoundingBox self) -> SoType"""
        return _coin.SoComputeBoundingBox_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoComputeBoundingBox self) -> SoFieldData"""
        return _coin.SoComputeBoundingBox_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoComputeBoundingBox self) -> SoEngineOutputData"""
        return _coin.SoComputeBoundingBox_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoComputeBoundingBox_createInstance()
    node = property(_coin.SoComputeBoundingBox_node_get, _coin.SoComputeBoundingBox_node_set, doc=r"""node : SoSFNode""")
    path = property(_coin.SoComputeBoundingBox_path_get, _coin.SoComputeBoundingBox_path_set, doc=r"""path : SoSFPath""")
    min = property(_coin.SoComputeBoundingBox_min_get, _coin.SoComputeBoundingBox_min_set, doc=r"""min : SoEngineOutput""")
    max = property(_coin.SoComputeBoundingBox_max_get, _coin.SoComputeBoundingBox_max_set, doc=r"""max : SoEngineOutput""")
    boxCenter = property(_coin.SoComputeBoundingBox_boxCenter_get, _coin.SoComputeBoundingBox_boxCenter_set, doc=r"""boxCenter : SoEngineOutput""")
    objectCenter = property(_coin.SoComputeBoundingBox_objectCenter_get, _coin.SoComputeBoundingBox_objectCenter_set, doc=r"""objectCenter : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoComputeBoundingBox self) -> SoComputeBoundingBox"""
        _coin.SoComputeBoundingBox_swiginit(self, _coin.new_SoComputeBoundingBox())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoComputeBoundingBox_initClass()

    def setViewportRegion(self, vpr: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoComputeBoundingBox self, SbViewportRegion vpr)"""
        return _coin.SoComputeBoundingBox_setViewportRegion(self, vpr)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoComputeBoundingBox self) -> SbViewportRegion"""
        return _coin.SoComputeBoundingBox_getViewportRegion(self)

# Register SoComputeBoundingBox in _coin:
_coin.SoComputeBoundingBox_swigregister(SoComputeBoundingBox)

def SoComputeBoundingBox_getClassTypeId() -> "SoType":
    r"""SoComputeBoundingBox_getClassTypeId() -> SoType"""
    return _coin.SoComputeBoundingBox_getClassTypeId()

def SoComputeBoundingBox_createInstance() -> "void *":
    r"""SoComputeBoundingBox_createInstance() -> void *"""
    return _coin.SoComputeBoundingBox_createInstance()

def SoComputeBoundingBox_initClass() -> "void":
    r"""SoComputeBoundingBox_initClass()"""
    return _coin.SoComputeBoundingBox_initClass()

class SoConcatenate(SoEngine):
    r"""Proxy of C++ SoConcatenate class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoConcatenate_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoConcatenate self) -> SoType"""
        return _coin.SoConcatenate_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoConcatenate self) -> SoFieldData"""
        return _coin.SoConcatenate_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoConcatenate self) -> SoEngineOutputData"""
        return _coin.SoConcatenate_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoConcatenate_createInstance()
    NUMINPUTS = _coin.SoConcatenate_NUMINPUTS
    

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoConcatenate_initClass()

    def __init__(self, inputType: "SoType"):
        r"""__init__(SoConcatenate self, SoType inputType) -> SoConcatenate"""
        _coin.SoConcatenate_swiginit(self, _coin.new_SoConcatenate(inputType))
    input = property(_coin.SoConcatenate_input_get, _coin.SoConcatenate_input_set, doc=r"""input : a(SoConcatenate::NUMINPUTS).p.SoMField""")
    output = property(_coin.SoConcatenate_output_get, _coin.SoConcatenate_output_set, doc=r"""output : p.SoEngineOutput""")

# Register SoConcatenate in _coin:
_coin.SoConcatenate_swigregister(SoConcatenate)

def SoConcatenate_getClassTypeId() -> "SoType":
    r"""SoConcatenate_getClassTypeId() -> SoType"""
    return _coin.SoConcatenate_getClassTypeId()

def SoConcatenate_createInstance() -> "void *":
    r"""SoConcatenate_createInstance() -> void *"""
    return _coin.SoConcatenate_createInstance()

def SoConcatenate_initClass() -> "void":
    r"""SoConcatenate_initClass()"""
    return _coin.SoConcatenate_initClass()

class SoSFTrigger(SoSField):
    r"""Proxy of C++ SoSFTrigger class."""

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

    def __init__(self):
        r"""__init__(SoSFTrigger self) -> SoSFTrigger"""
        _coin.SoSFTrigger_swiginit(self, _coin.new_SoSFTrigger())
    __swig_destroy__ = _coin.delete_SoSFTrigger

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFTrigger_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFTrigger_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFTrigger self) -> SoType"""
        return _coin.SoSFTrigger_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFTrigger self, SoField field)"""
        return _coin.SoSFTrigger_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFTrigger self, SoField field) -> SbBool"""
        return _coin.SoSFTrigger_isSame(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFTrigger_initClass()

    def getValue(self) -> "void":
        r"""getValue(SoSFTrigger self)"""
        return _coin.SoSFTrigger_getValue(self)

    def __eq__(self, trigger: "SoSFTrigger") -> "int":
        r"""__eq__(SoSFTrigger self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___eq__(self, trigger)

    def __ne__(self, trigger: "SoSFTrigger") -> "int":
        r"""__ne__(SoSFTrigger self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___ne__(self, trigger)

    def startNotify(self) -> "void":
        r"""startNotify(SoSFTrigger self)"""
        return _coin.SoSFTrigger_startNotify(self)

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoSFTrigger self, SoNotList l)"""
        return _coin.SoSFTrigger_notify(self, l)

    def touch(self) -> "void":
        r"""touch(SoSFTrigger self)"""
        return _coin.SoSFTrigger_touch(self)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFTrigger self)
        setValue(SoSFTrigger self, SoSFTrigger other)
        """
        return _coin.SoSFTrigger_setValue(self, *args)

# Register SoSFTrigger in _coin:
_coin.SoSFTrigger_swigregister(SoSFTrigger)

def SoSFTrigger_createInstance() -> "void *":
    r"""SoSFTrigger_createInstance() -> void *"""
    return _coin.SoSFTrigger_createInstance()

def SoSFTrigger_getClassTypeId() -> "SoType":
    r"""SoSFTrigger_getClassTypeId() -> SoType"""
    return _coin.SoSFTrigger_getClassTypeId()

def SoSFTrigger_initClass() -> "void":
    r"""SoSFTrigger_initClass()"""
    return _coin.SoSFTrigger_initClass()

class SoSFShort(SoSField):
    r"""Proxy of C++ SoSFShort class."""

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

    def __init__(self):
        r"""__init__(SoSFShort self) -> SoSFShort"""
        _coin.SoSFShort_swiginit(self, _coin.new_SoSFShort())
    __swig_destroy__ = _coin.delete_SoSFShort

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFShort_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFShort_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFShort self) -> SoType"""
        return _coin.SoSFShort_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFShort self, SoField field)"""
        return _coin.SoSFShort_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFShort self, SoField field) -> SbBool"""
        return _coin.SoSFShort_isSame(self, field)

    def getValue(self) -> "short":
        r"""getValue(SoSFShort self) -> short"""
        return _coin.SoSFShort_getValue(self)

    def __eq__(self, field: "SoSFShort") -> "int":
        r"""__eq__(SoSFShort self, SoSFShort field) -> int"""
        return _coin.SoSFShort___eq__(self, field)

    def __ne__(self, field: "SoSFShort") -> "int":
        r"""__ne__(SoSFShort self, SoSFShort field) -> int"""
        return _coin.SoSFShort___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFShort_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFShort self, short newvalue)
        setValue(SoSFShort self, SoSFShort other)
        """
        return _coin.SoSFShort_setValue(self, *args)

# Register SoSFShort in _coin:
_coin.SoSFShort_swigregister(SoSFShort)

def SoSFShort_createInstance() -> "void *":
    r"""SoSFShort_createInstance() -> void *"""
    return _coin.SoSFShort_createInstance()

def SoSFShort_getClassTypeId() -> "SoType":
    r"""SoSFShort_getClassTypeId() -> SoType"""
    return _coin.SoSFShort_getClassTypeId()

def SoSFShort_initClass() -> "void":
    r"""SoSFShort_initClass()"""
    return _coin.SoSFShort_initClass()

class SoCounter(SoEngine):
    r"""Proxy of C++ SoCounter class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCounter_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCounter self) -> SoType"""
        return _coin.SoCounter_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoCounter self) -> SoFieldData"""
        return _coin.SoCounter_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoCounter self) -> SoEngineOutputData"""
        return _coin.SoCounter_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoCounter_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCounter_initClass()

    def __init__(self):
        r"""__init__(SoCounter self) -> SoCounter"""
        _coin.SoCounter_swiginit(self, _coin.new_SoCounter())
    min = property(_coin.SoCounter_min_get, _coin.SoCounter_min_set, doc=r"""min : SoSFShort""")
    max = property(_coin.SoCounter_max_get, _coin.SoCounter_max_set, doc=r"""max : SoSFShort""")
    step = property(_coin.SoCounter_step_get, _coin.SoCounter_step_set, doc=r"""step : SoSFShort""")
    trigger = property(_coin.SoCounter_trigger_get, _coin.SoCounter_trigger_set, doc=r"""trigger : SoSFTrigger""")
    reset = property(_coin.SoCounter_reset_get, _coin.SoCounter_reset_set, doc=r"""reset : SoSFShort""")
    output = property(_coin.SoCounter_output_get, _coin.SoCounter_output_set, doc=r"""output : SoEngineOutput""")
    syncOut = property(_coin.SoCounter_syncOut_get, _coin.SoCounter_syncOut_set, doc=r"""syncOut : SoEngineOutput""")

# Register SoCounter in _coin:
_coin.SoCounter_swigregister(SoCounter)

def SoCounter_getClassTypeId() -> "SoType":
    r"""SoCounter_getClassTypeId() -> SoType"""
    return _coin.SoCounter_getClassTypeId()

def SoCounter_createInstance() -> "void *":
    r"""SoCounter_createInstance() -> void *"""
    return _coin.SoCounter_createInstance()

def SoCounter_initClass() -> "void":
    r"""SoCounter_initClass()"""
    return _coin.SoCounter_initClass()

class SoSFTime(SoSField):
    r"""Proxy of C++ SoSFTime class."""

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

    def __init__(self):
        r"""__init__(SoSFTime self) -> SoSFTime"""
        _coin.SoSFTime_swiginit(self, _coin.new_SoSFTime())
    __swig_destroy__ = _coin.delete_SoSFTime

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFTime_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFTime_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFTime self) -> SoType"""
        return _coin.SoSFTime_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFTime self, SoField field)"""
        return _coin.SoSFTime_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFTime self, SoField field) -> SbBool"""
        return _coin.SoSFTime_isSame(self, field)

    def getValue(self) -> "SbTime const &":
        r"""getValue(SoSFTime self) -> SbTime"""
        return _coin.SoSFTime_getValue(self)

    def __eq__(self, field: "SoSFTime") -> "int":
        r"""__eq__(SoSFTime self, SoSFTime field) -> int"""
        return _coin.SoSFTime___eq__(self, field)

    def __ne__(self, field: "SoSFTime") -> "int":
        r"""__ne__(SoSFTime self, SoSFTime field) -> int"""
        return _coin.SoSFTime___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFTime_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFTime self, SbTime newvalue)
        setValue(SoSFTime self, SbTime other)
        setValue(SoSFTime self, SoSFTime other)
        """
        return _coin.SoSFTime_setValue(self, *args)

# Register SoSFTime in _coin:
_coin.SoSFTime_swigregister(SoSFTime)

def SoSFTime_createInstance() -> "void *":
    r"""SoSFTime_createInstance() -> void *"""
    return _coin.SoSFTime_createInstance()

def SoSFTime_getClassTypeId() -> "SoType":
    r"""SoSFTime_getClassTypeId() -> SoType"""
    return _coin.SoSFTime_getClassTypeId()

def SoSFTime_initClass() -> "void":
    r"""SoSFTime_initClass()"""
    return _coin.SoSFTime_initClass()

class SoElapsedTime(SoEngine):
    r"""Proxy of C++ SoElapsedTime class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoElapsedTime_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoElapsedTime self) -> SoType"""
        return _coin.SoElapsedTime_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoElapsedTime self) -> SoFieldData"""
        return _coin.SoElapsedTime_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoElapsedTime self) -> SoEngineOutputData"""
        return _coin.SoElapsedTime_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoElapsedTime_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoElapsedTime_initClass()

    def __init__(self):
        r"""__init__(SoElapsedTime self) -> SoElapsedTime"""
        _coin.SoElapsedTime_swiginit(self, _coin.new_SoElapsedTime())
    timeIn = property(_coin.SoElapsedTime_timeIn_get, _coin.SoElapsedTime_timeIn_set, doc=r"""timeIn : SoSFTime""")
    speed = property(_coin.SoElapsedTime_speed_get, _coin.SoElapsedTime_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoElapsedTime_on_get, _coin.SoElapsedTime_on_set, doc=r"""on : SoSFBool""")
    pause = property(_coin.SoElapsedTime_pause_get, _coin.SoElapsedTime_pause_set, doc=r"""pause : SoSFBool""")
    reset = property(_coin.SoElapsedTime_reset_get, _coin.SoElapsedTime_reset_set, doc=r"""reset : SoSFTrigger""")
    timeOut = property(_coin.SoElapsedTime_timeOut_get, _coin.SoElapsedTime_timeOut_set, doc=r"""timeOut : SoEngineOutput""")

# Register SoElapsedTime in _coin:
_coin.SoElapsedTime_swigregister(SoElapsedTime)

def SoElapsedTime_getClassTypeId() -> "SoType":
    r"""SoElapsedTime_getClassTypeId() -> SoType"""
    return _coin.SoElapsedTime_getClassTypeId()

def SoElapsedTime_createInstance() -> "void *":
    r"""SoElapsedTime_createInstance() -> void *"""
    return _coin.SoElapsedTime_createInstance()

def SoElapsedTime_initClass() -> "void":
    r"""SoElapsedTime_initClass()"""
    return _coin.SoElapsedTime_initClass()

class SoFieldConverter(SoEngine):
    r"""Proxy of C++ SoFieldConverter class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFieldConverter_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFieldConverter self) -> SoType"""
        return _coin.SoFieldConverter_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoFieldConverter self) -> SoFieldData"""
        return _coin.SoFieldConverter_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoFieldConverter self) -> SoEngineOutputData"""
        return _coin.SoFieldConverter_getOutputData(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFieldConverter_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoFieldConverter_initClasses()

    def getInput(self, type: "SoType") -> "SoField *":
        r"""getInput(SoFieldConverter self, SoType type) -> SoField"""
        return _coin.SoFieldConverter_getInput(self, type)

    def getOutput(self, type: "SoType") -> "SoEngineOutput *":
        r"""getOutput(SoFieldConverter self, SoType type) -> SoEngineOutput"""
        return _coin.SoFieldConverter_getOutput(self, type)

    def getConnectedInput(self) -> "SoField *":
        r"""getConnectedInput(SoFieldConverter self) -> SoField"""
        return _coin.SoFieldConverter_getConnectedInput(self)

    def getForwardConnections(self, l: "SoFieldList") -> "int":
        r"""getForwardConnections(SoFieldConverter self, SoFieldList l) -> int"""
        return _coin.SoFieldConverter_getForwardConnections(self, l)

# Register SoFieldConverter in _coin:
_coin.SoFieldConverter_swigregister(SoFieldConverter)

def SoFieldConverter_getClassTypeId() -> "SoType":
    r"""SoFieldConverter_getClassTypeId() -> SoType"""
    return _coin.SoFieldConverter_getClassTypeId()

def SoFieldConverter_initClass() -> "void":
    r"""SoFieldConverter_initClass()"""
    return _coin.SoFieldConverter_initClass()

def SoFieldConverter_initClasses() -> "void":
    r"""SoFieldConverter_initClasses()"""
    return _coin.SoFieldConverter_initClasses()

class SoGate(SoEngine):
    r"""Proxy of C++ SoGate class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGate_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGate self) -> SoType"""
        return _coin.SoGate_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoGate self) -> SoFieldData"""
        return _coin.SoGate_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoGate self) -> SoEngineOutputData"""
        return _coin.SoGate_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoGate_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGate_initClass()

    def __init__(self, type: "SoType"):
        r"""__init__(SoGate self, SoType type) -> SoGate"""
        _coin.SoGate_swiginit(self, _coin.new_SoGate(type))
    enable = property(_coin.SoGate_enable_get, _coin.SoGate_enable_set, doc=r"""enable : SoSFBool""")
    trigger = property(_coin.SoGate_trigger_get, _coin.SoGate_trigger_set, doc=r"""trigger : SoSFTrigger""")
    input = property(_coin.SoGate_input_get, _coin.SoGate_input_set, doc=r"""input : p.SoMField""")
    output = property(_coin.SoGate_output_get, _coin.SoGate_output_set, doc=r"""output : p.SoEngineOutput""")

# Register SoGate in _coin:
_coin.SoGate_swigregister(SoGate)

def SoGate_getClassTypeId() -> "SoType":
    r"""SoGate_getClassTypeId() -> SoType"""
    return _coin.SoGate_getClassTypeId()

def SoGate_createInstance() -> "void *":
    r"""SoGate_createInstance() -> void *"""
    return _coin.SoGate_createInstance()

def SoGate_initClass() -> "void":
    r"""SoGate_initClass()"""
    return _coin.SoGate_initClass()

class SoInterpolate(SoEngine):
    r"""Proxy of C++ SoInterpolate class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolate_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInterpolate self) -> SoType"""
        return _coin.SoInterpolate_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoInterpolate self) -> SoFieldData"""
        return _coin.SoInterpolate_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoInterpolate self) -> SoEngineOutputData"""
        return _coin.SoInterpolate_getOutputData(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInterpolate_initClass()

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoInterpolate_initClasses()
    alpha = property(_coin.SoInterpolate_alpha_get, _coin.SoInterpolate_alpha_set, doc=r"""alpha : SoSFFloat""")
    output = property(_coin.SoInterpolate_output_get, _coin.SoInterpolate_output_set, doc=r"""output : SoEngineOutput""")

# Register SoInterpolate in _coin:
_coin.SoInterpolate_swigregister(SoInterpolate)

def SoInterpolate_getClassTypeId() -> "SoType":
    r"""SoInterpolate_getClassTypeId() -> SoType"""
    return _coin.SoInterpolate_getClassTypeId()

def SoInterpolate_initClass() -> "void":
    r"""SoInterpolate_initClass()"""
    return _coin.SoInterpolate_initClass()

def SoInterpolate_initClasses() -> "void":
    r"""SoInterpolate_initClasses()"""
    return _coin.SoInterpolate_initClasses()

class SoInterpolateFloat(SoInterpolate):
    r"""Proxy of C++ SoInterpolateFloat class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateFloat_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInterpolateFloat self) -> SoType"""
        return _coin.SoInterpolateFloat_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoInterpolateFloat self) -> SoFieldData"""
        return _coin.SoInterpolateFloat_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoInterpolateFloat self) -> SoEngineOutputData"""
        return _coin.SoInterpolateFloat_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateFloat_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateFloat self) -> SoInterpolateFloat"""
        _coin.SoInterpolateFloat_swiginit(self, _coin.new_SoInterpolateFloat())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInterpolateFloat_initClass()
    input0 = property(_coin.SoInterpolateFloat_input0_get, _coin.SoInterpolateFloat_input0_set, doc=r"""input0 : SoMFFloat""")
    input1 = property(_coin.SoInterpolateFloat_input1_get, _coin.SoInterpolateFloat_input1_set, doc=r"""input1 : SoMFFloat""")

# Register SoInterpolateFloat in _coin:
_coin.SoInterpolateFloat_swigregister(SoInterpolateFloat)

def SoInterpolateFloat_getClassTypeId() -> "SoType":
    r"""SoInterpolateFloat_getClassTypeId() -> SoType"""
    return _coin.SoInterpolateFloat_getClassTypeId()

def SoInterpolateFloat_createInstance() -> "void *":
    r"""SoInterpolateFloat_createInstance() -> void *"""
    return _coin.SoInterpolateFloat_createInstance()

def SoInterpolateFloat_initClass() -> "void":
    r"""SoInterpolateFloat_initClass()"""
    return _coin.SoInterpolateFloat_initClass()

class SoInterpolateVec2f(SoInterpolate):
    r"""Proxy of C++ SoInterpolateVec2f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInterpolateVec2f self) -> SoType"""
        return _coin.SoInterpolateVec2f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoInterpolateVec2f self) -> SoFieldData"""
        return _coin.SoInterpolateVec2f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoInterpolateVec2f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec2f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateVec2f_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateVec2f self) -> SoInterpolateVec2f"""
        _coin.SoInterpolateVec2f_swiginit(self, _coin.new_SoInterpolateVec2f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInterpolateVec2f_initClass()
    input0 = property(_coin.SoInterpolateVec2f_input0_get, _coin.SoInterpolateVec2f_input0_set, doc=r"""input0 : SoMFVec2f""")
    input1 = property(_coin.SoInterpolateVec2f_input1_get, _coin.SoInterpolateVec2f_input1_set, doc=r"""input1 : SoMFVec2f""")

# Register SoInterpolateVec2f in _coin:
_coin.SoInterpolateVec2f_swigregister(SoInterpolateVec2f)

def SoInterpolateVec2f_getClassTypeId() -> "SoType":
    r"""SoInterpolateVec2f_getClassTypeId() -> SoType"""
    return _coin.SoInterpolateVec2f_getClassTypeId()

def SoInterpolateVec2f_createInstance() -> "void *":
    r"""SoInterpolateVec2f_createInstance() -> void *"""
    return _coin.SoInterpolateVec2f_createInstance()

def SoInterpolateVec2f_initClass() -> "void":
    r"""SoInterpolateVec2f_initClass()"""
    return _coin.SoInterpolateVec2f_initClass()

class SoInterpolateVec3f(SoInterpolate):
    r"""Proxy of C++ SoInterpolateVec3f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInterpolateVec3f self) -> SoType"""
        return _coin.SoInterpolateVec3f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoInterpolateVec3f self) -> SoFieldData"""
        return _coin.SoInterpolateVec3f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoInterpolateVec3f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec3f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateVec3f_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateVec3f self) -> SoInterpolateVec3f"""
        _coin.SoInterpolateVec3f_swiginit(self, _coin.new_SoInterpolateVec3f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInterpolateVec3f_initClass()
    input0 = property(_coin.SoInterpolateVec3f_input0_get, _coin.SoInterpolateVec3f_input0_set, doc=r"""input0 : SoMFVec3f""")
    input1 = property(_coin.SoInterpolateVec3f_input1_get, _coin.SoInterpolateVec3f_input1_set, doc=r"""input1 : SoMFVec3f""")

# Register SoInterpolateVec3f in _coin:
_coin.SoInterpolateVec3f_swigregister(SoInterpolateVec3f)

def SoInterpolateVec3f_getClassTypeId() -> "SoType":
    r"""SoInterpolateVec3f_getClassTypeId() -> SoType"""
    return _coin.SoInterpolateVec3f_getClassTypeId()

def SoInterpolateVec3f_createInstance() -> "void *":
    r"""SoInterpolateVec3f_createInstance() -> void *"""
    return _coin.SoInterpolateVec3f_createInstance()

def SoInterpolateVec3f_initClass() -> "void":
    r"""SoInterpolateVec3f_initClass()"""
    return _coin.SoInterpolateVec3f_initClass()

class SoInterpolateVec4f(SoInterpolate):
    r"""Proxy of C++ SoInterpolateVec4f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec4f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInterpolateVec4f self) -> SoType"""
        return _coin.SoInterpolateVec4f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoInterpolateVec4f self) -> SoFieldData"""
        return _coin.SoInterpolateVec4f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoInterpolateVec4f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec4f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateVec4f_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateVec4f self) -> SoInterpolateVec4f"""
        _coin.SoInterpolateVec4f_swiginit(self, _coin.new_SoInterpolateVec4f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInterpolateVec4f_initClass()
    input0 = property(_coin.SoInterpolateVec4f_input0_get, _coin.SoInterpolateVec4f_input0_set, doc=r"""input0 : SoMFVec4f""")
    input1 = property(_coin.SoInterpolateVec4f_input1_get, _coin.SoInterpolateVec4f_input1_set, doc=r"""input1 : SoMFVec4f""")

# Register SoInterpolateVec4f in _coin:
_coin.SoInterpolateVec4f_swigregister(SoInterpolateVec4f)

def SoInterpolateVec4f_getClassTypeId() -> "SoType":
    r"""SoInterpolateVec4f_getClassTypeId() -> SoType"""
    return _coin.SoInterpolateVec4f_getClassTypeId()

def SoInterpolateVec4f_createInstance() -> "void *":
    r"""SoInterpolateVec4f_createInstance() -> void *"""
    return _coin.SoInterpolateVec4f_createInstance()

def SoInterpolateVec4f_initClass() -> "void":
    r"""SoInterpolateVec4f_initClass()"""
    return _coin.SoInterpolateVec4f_initClass()

class SoInterpolateRotation(SoInterpolate):
    r"""Proxy of C++ SoInterpolateRotation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateRotation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInterpolateRotation self) -> SoType"""
        return _coin.SoInterpolateRotation_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoInterpolateRotation self) -> SoFieldData"""
        return _coin.SoInterpolateRotation_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoInterpolateRotation self) -> SoEngineOutputData"""
        return _coin.SoInterpolateRotation_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateRotation_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateRotation self) -> SoInterpolateRotation"""
        _coin.SoInterpolateRotation_swiginit(self, _coin.new_SoInterpolateRotation())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInterpolateRotation_initClass()
    input0 = property(_coin.SoInterpolateRotation_input0_get, _coin.SoInterpolateRotation_input0_set, doc=r"""input0 : SoMFRotation""")
    input1 = property(_coin.SoInterpolateRotation_input1_get, _coin.SoInterpolateRotation_input1_set, doc=r"""input1 : SoMFRotation""")

# Register SoInterpolateRotation in _coin:
_coin.SoInterpolateRotation_swigregister(SoInterpolateRotation)

def SoInterpolateRotation_getClassTypeId() -> "SoType":
    r"""SoInterpolateRotation_getClassTypeId() -> SoType"""
    return _coin.SoInterpolateRotation_getClassTypeId()

def SoInterpolateRotation_createInstance() -> "void *":
    r"""SoInterpolateRotation_createInstance() -> void *"""
    return _coin.SoInterpolateRotation_createInstance()

def SoInterpolateRotation_initClass() -> "void":
    r"""SoInterpolateRotation_initClass()"""
    return _coin.SoInterpolateRotation_initClass()

class SoOnOff(SoEngine):
    r"""Proxy of C++ SoOnOff class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOnOff_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoOnOff self) -> SoType"""
        return _coin.SoOnOff_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoOnOff self) -> SoFieldData"""
        return _coin.SoOnOff_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoOnOff self) -> SoEngineOutputData"""
        return _coin.SoOnOff_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoOnOff_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoOnOff_initClass()

    def __init__(self):
        r"""__init__(SoOnOff self) -> SoOnOff"""
        _coin.SoOnOff_swiginit(self, _coin.new_SoOnOff())
    on = property(_coin.SoOnOff_on_get, _coin.SoOnOff_on_set, doc=r"""on : SoSFTrigger""")
    off = property(_coin.SoOnOff_off_get, _coin.SoOnOff_off_set, doc=r"""off : SoSFTrigger""")
    toggle = property(_coin.SoOnOff_toggle_get, _coin.SoOnOff_toggle_set, doc=r"""toggle : SoSFTrigger""")
    isOn = property(_coin.SoOnOff_isOn_get, _coin.SoOnOff_isOn_set, doc=r"""isOn : SoEngineOutput""")
    isOff = property(_coin.SoOnOff_isOff_get, _coin.SoOnOff_isOff_set, doc=r"""isOff : SoEngineOutput""")

# Register SoOnOff in _coin:
_coin.SoOnOff_swigregister(SoOnOff)

def SoOnOff_getClassTypeId() -> "SoType":
    r"""SoOnOff_getClassTypeId() -> SoType"""
    return _coin.SoOnOff_getClassTypeId()

def SoOnOff_createInstance() -> "void *":
    r"""SoOnOff_createInstance() -> void *"""
    return _coin.SoOnOff_createInstance()

def SoOnOff_initClass() -> "void":
    r"""SoOnOff_initClass()"""
    return _coin.SoOnOff_initClass()

class SoSFBitMask(SoSFEnum):
    r"""Proxy of C++ SoSFBitMask class."""

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

    def __init__(self):
        r"""__init__(SoSFBitMask self) -> SoSFBitMask"""
        _coin.SoSFBitMask_swiginit(self, _coin.new_SoSFBitMask())
    __swig_destroy__ = _coin.delete_SoSFBitMask

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBitMask_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBitMask_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBitMask self) -> SoType"""
        return _coin.SoSFBitMask_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBitMask self, SoField field)"""
        return _coin.SoSFBitMask_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBitMask self, SoField field) -> SbBool"""
        return _coin.SoSFBitMask_isSame(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBitMask_initClass()

# Register SoSFBitMask in _coin:
_coin.SoSFBitMask_swigregister(SoSFBitMask)

def SoSFBitMask_createInstance() -> "void *":
    r"""SoSFBitMask_createInstance() -> void *"""
    return _coin.SoSFBitMask_createInstance()

def SoSFBitMask_getClassTypeId() -> "SoType":
    r"""SoSFBitMask_getClassTypeId() -> SoType"""
    return _coin.SoSFBitMask_getClassTypeId()

def SoSFBitMask_initClass() -> "void":
    r"""SoSFBitMask_initClass()"""
    return _coin.SoSFBitMask_initClass()

class SoOneShot(SoEngine):
    r"""Proxy of C++ SoOneShot class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOneShot_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoOneShot self) -> SoType"""
        return _coin.SoOneShot_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoOneShot self) -> SoFieldData"""
        return _coin.SoOneShot_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoOneShot self) -> SoEngineOutputData"""
        return _coin.SoOneShot_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoOneShot_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoOneShot_initClass()

    def __init__(self):
        r"""__init__(SoOneShot self) -> SoOneShot"""
        _coin.SoOneShot_swiginit(self, _coin.new_SoOneShot())
    RETRIGGERABLE = _coin.SoOneShot_RETRIGGERABLE
    
    HOLD_FINAL = _coin.SoOneShot_HOLD_FINAL
    
    timeIn = property(_coin.SoOneShot_timeIn_get, _coin.SoOneShot_timeIn_set, doc=r"""timeIn : SoSFTime""")
    duration = property(_coin.SoOneShot_duration_get, _coin.SoOneShot_duration_set, doc=r"""duration : SoSFTime""")
    trigger = property(_coin.SoOneShot_trigger_get, _coin.SoOneShot_trigger_set, doc=r"""trigger : SoSFTrigger""")
    flags = property(_coin.SoOneShot_flags_get, _coin.SoOneShot_flags_set, doc=r"""flags : SoSFBitMask""")
    disable = property(_coin.SoOneShot_disable_get, _coin.SoOneShot_disable_set, doc=r"""disable : SoSFBool""")
    timeOut = property(_coin.SoOneShot_timeOut_get, _coin.SoOneShot_timeOut_set, doc=r"""timeOut : SoEngineOutput""")
    isActive = property(_coin.SoOneShot_isActive_get, _coin.SoOneShot_isActive_set, doc=r"""isActive : SoEngineOutput""")
    ramp = property(_coin.SoOneShot_ramp_get, _coin.SoOneShot_ramp_set, doc=r"""ramp : SoEngineOutput""")

# Register SoOneShot in _coin:
_coin.SoOneShot_swigregister(SoOneShot)

def SoOneShot_getClassTypeId() -> "SoType":
    r"""SoOneShot_getClassTypeId() -> SoType"""
    return _coin.SoOneShot_getClassTypeId()

def SoOneShot_createInstance() -> "void *":
    r"""SoOneShot_createInstance() -> void *"""
    return _coin.SoOneShot_createInstance()

def SoOneShot_initClass() -> "void":
    r"""SoOneShot_initClass()"""
    return _coin.SoOneShot_initClass()

class SoSelectOne(SoEngine):
    r"""Proxy of C++ SoSelectOne class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSelectOne_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSelectOne self) -> SoType"""
        return _coin.SoSelectOne_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoSelectOne self) -> SoFieldData"""
        return _coin.SoSelectOne_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoSelectOne self) -> SoEngineOutputData"""
        return _coin.SoSelectOne_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSelectOne_createInstance()
    index = property(_coin.SoSelectOne_index_get, _coin.SoSelectOne_index_set, doc=r"""index : SoSFInt32""")
    input = property(_coin.SoSelectOne_input_get, _coin.SoSelectOne_input_set, doc=r"""input : p.SoMField""")
    output = property(_coin.SoSelectOne_output_get, _coin.SoSelectOne_output_set, doc=r"""output : p.SoEngineOutput""")

    def __init__(self, inputtype: "SoType"):
        r"""__init__(SoSelectOne self, SoType inputtype) -> SoSelectOne"""
        _coin.SoSelectOne_swiginit(self, _coin.new_SoSelectOne(inputtype))

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSelectOne_initClass()

# Register SoSelectOne in _coin:
_coin.SoSelectOne_swigregister(SoSelectOne)

def SoSelectOne_getClassTypeId() -> "SoType":
    r"""SoSelectOne_getClassTypeId() -> SoType"""
    return _coin.SoSelectOne_getClassTypeId()

def SoSelectOne_createInstance() -> "void *":
    r"""SoSelectOne_createInstance() -> void *"""
    return _coin.SoSelectOne_createInstance()

def SoSelectOne_initClass() -> "void":
    r"""SoSelectOne_initClass()"""
    return _coin.SoSelectOne_initClass()

class SoTimeCounter(SoEngine):
    r"""Proxy of C++ SoTimeCounter class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTimeCounter_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTimeCounter self) -> SoType"""
        return _coin.SoTimeCounter_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoTimeCounter self) -> SoFieldData"""
        return _coin.SoTimeCounter_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoTimeCounter self) -> SoEngineOutputData"""
        return _coin.SoTimeCounter_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTimeCounter_createInstance()
    timeIn = property(_coin.SoTimeCounter_timeIn_get, _coin.SoTimeCounter_timeIn_set, doc=r"""timeIn : SoSFTime""")
    min = property(_coin.SoTimeCounter_min_get, _coin.SoTimeCounter_min_set, doc=r"""min : SoSFShort""")
    max = property(_coin.SoTimeCounter_max_get, _coin.SoTimeCounter_max_set, doc=r"""max : SoSFShort""")
    step = property(_coin.SoTimeCounter_step_get, _coin.SoTimeCounter_step_set, doc=r"""step : SoSFShort""")
    on = property(_coin.SoTimeCounter_on_get, _coin.SoTimeCounter_on_set, doc=r"""on : SoSFBool""")
    frequency = property(_coin.SoTimeCounter_frequency_get, _coin.SoTimeCounter_frequency_set, doc=r"""frequency : SoSFFloat""")
    duty = property(_coin.SoTimeCounter_duty_get, _coin.SoTimeCounter_duty_set, doc=r"""duty : SoMFFloat""")
    reset = property(_coin.SoTimeCounter_reset_get, _coin.SoTimeCounter_reset_set, doc=r"""reset : SoSFShort""")
    syncIn = property(_coin.SoTimeCounter_syncIn_get, _coin.SoTimeCounter_syncIn_set, doc=r"""syncIn : SoSFTrigger""")
    output = property(_coin.SoTimeCounter_output_get, _coin.SoTimeCounter_output_set, doc=r"""output : SoEngineOutput""")
    syncOut = property(_coin.SoTimeCounter_syncOut_get, _coin.SoTimeCounter_syncOut_set, doc=r"""syncOut : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoTimeCounter self) -> SoTimeCounter"""
        _coin.SoTimeCounter_swiginit(self, _coin.new_SoTimeCounter())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTimeCounter_initClass()

# Register SoTimeCounter in _coin:
_coin.SoTimeCounter_swigregister(SoTimeCounter)

def SoTimeCounter_getClassTypeId() -> "SoType":
    r"""SoTimeCounter_getClassTypeId() -> SoType"""
    return _coin.SoTimeCounter_getClassTypeId()

def SoTimeCounter_createInstance() -> "void *":
    r"""SoTimeCounter_createInstance() -> void *"""
    return _coin.SoTimeCounter_createInstance()

def SoTimeCounter_initClass() -> "void":
    r"""SoTimeCounter_initClass()"""
    return _coin.SoTimeCounter_initClass()

class SoTransformVec3f(SoEngine):
    r"""Proxy of C++ SoTransformVec3f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformVec3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformVec3f self) -> SoType"""
        return _coin.SoTransformVec3f_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoTransformVec3f self) -> SoFieldData"""
        return _coin.SoTransformVec3f_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoTransformVec3f self) -> SoEngineOutputData"""
        return _coin.SoTransformVec3f_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTransformVec3f_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformVec3f_initClass()

    def __init__(self):
        r"""__init__(SoTransformVec3f self) -> SoTransformVec3f"""
        _coin.SoTransformVec3f_swiginit(self, _coin.new_SoTransformVec3f())
    vector = property(_coin.SoTransformVec3f_vector_get, _coin.SoTransformVec3f_vector_set, doc=r"""vector : SoMFVec3f""")
    matrix = property(_coin.SoTransformVec3f_matrix_get, _coin.SoTransformVec3f_matrix_set, doc=r"""matrix : SoMFMatrix""")
    point = property(_coin.SoTransformVec3f_point_get, _coin.SoTransformVec3f_point_set, doc=r"""point : SoEngineOutput""")
    direction = property(_coin.SoTransformVec3f_direction_get, _coin.SoTransformVec3f_direction_set, doc=r"""direction : SoEngineOutput""")
    normalDirection = property(_coin.SoTransformVec3f_normalDirection_get, _coin.SoTransformVec3f_normalDirection_set, doc=r"""normalDirection : SoEngineOutput""")

# Register SoTransformVec3f in _coin:
_coin.SoTransformVec3f_swigregister(SoTransformVec3f)

def SoTransformVec3f_getClassTypeId() -> "SoType":
    r"""SoTransformVec3f_getClassTypeId() -> SoType"""
    return _coin.SoTransformVec3f_getClassTypeId()

def SoTransformVec3f_createInstance() -> "void *":
    r"""SoTransformVec3f_createInstance() -> void *"""
    return _coin.SoTransformVec3f_createInstance()

def SoTransformVec3f_initClass() -> "void":
    r"""SoTransformVec3f_initClass()"""
    return _coin.SoTransformVec3f_initClass()

class SoTriggerAny(SoEngine):
    r"""Proxy of C++ SoTriggerAny class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTriggerAny_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTriggerAny self) -> SoType"""
        return _coin.SoTriggerAny_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoTriggerAny self) -> SoFieldData"""
        return _coin.SoTriggerAny_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoTriggerAny self) -> SoEngineOutputData"""
        return _coin.SoTriggerAny_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoTriggerAny_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTriggerAny_initClass()

    def __init__(self):
        r"""__init__(SoTriggerAny self) -> SoTriggerAny"""
        _coin.SoTriggerAny_swiginit(self, _coin.new_SoTriggerAny())
    input0 = property(_coin.SoTriggerAny_input0_get, _coin.SoTriggerAny_input0_set, doc=r"""input0 : SoSFTrigger""")
    input1 = property(_coin.SoTriggerAny_input1_get, _coin.SoTriggerAny_input1_set, doc=r"""input1 : SoSFTrigger""")
    input2 = property(_coin.SoTriggerAny_input2_get, _coin.SoTriggerAny_input2_set, doc=r"""input2 : SoSFTrigger""")
    input3 = property(_coin.SoTriggerAny_input3_get, _coin.SoTriggerAny_input3_set, doc=r"""input3 : SoSFTrigger""")
    input4 = property(_coin.SoTriggerAny_input4_get, _coin.SoTriggerAny_input4_set, doc=r"""input4 : SoSFTrigger""")
    input5 = property(_coin.SoTriggerAny_input5_get, _coin.SoTriggerAny_input5_set, doc=r"""input5 : SoSFTrigger""")
    input6 = property(_coin.SoTriggerAny_input6_get, _coin.SoTriggerAny_input6_set, doc=r"""input6 : SoSFTrigger""")
    input7 = property(_coin.SoTriggerAny_input7_get, _coin.SoTriggerAny_input7_set, doc=r"""input7 : SoSFTrigger""")
    input8 = property(_coin.SoTriggerAny_input8_get, _coin.SoTriggerAny_input8_set, doc=r"""input8 : SoSFTrigger""")
    input9 = property(_coin.SoTriggerAny_input9_get, _coin.SoTriggerAny_input9_set, doc=r"""input9 : SoSFTrigger""")
    output = property(_coin.SoTriggerAny_output_get, _coin.SoTriggerAny_output_set, doc=r"""output : SoEngineOutput""")

# Register SoTriggerAny in _coin:
_coin.SoTriggerAny_swigregister(SoTriggerAny)

def SoTriggerAny_getClassTypeId() -> "SoType":
    r"""SoTriggerAny_getClassTypeId() -> SoType"""
    return _coin.SoTriggerAny_getClassTypeId()

def SoTriggerAny_createInstance() -> "void *":
    r"""SoTriggerAny_createInstance() -> void *"""
    return _coin.SoTriggerAny_createInstance()

def SoTriggerAny_initClass() -> "void":
    r"""SoTriggerAny_initClass()"""
    return _coin.SoTriggerAny_initClass()

class SoTexture2Convert(SoEngine):
    r"""Proxy of C++ SoTexture2Convert class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture2Convert_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTexture2Convert self) -> SoType"""
        return _coin.SoTexture2Convert_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoTexture2Convert self) -> SoFieldData"""
        return _coin.SoTexture2Convert_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoTexture2Convert self) -> SoEngineOutputData"""
        return _coin.SoTexture2Convert_getOutputData(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTexture2Convert_initClass()
    sourceImage = property(_coin.SoTexture2Convert_sourceImage_get, _coin.SoTexture2Convert_sourceImage_set, doc=r"""sourceImage : SoSFImage""")
    image = property(_coin.SoTexture2Convert_image_get, _coin.SoTexture2Convert_image_set, doc=r"""image : SoEngineOutput""")
    __swig_destroy__ = _coin.delete_SoTexture2Convert

# Register SoTexture2Convert in _coin:
_coin.SoTexture2Convert_swigregister(SoTexture2Convert)

def SoTexture2Convert_getClassTypeId() -> "SoType":
    r"""SoTexture2Convert_getClassTypeId() -> SoType"""
    return _coin.SoTexture2Convert_getClassTypeId()

def SoTexture2Convert_initClass() -> "void":
    r"""SoTexture2Convert_initClass()"""
    return _coin.SoTexture2Convert_initClass()

class SoHeightMapToNormalMap(SoTexture2Convert):
    r"""Proxy of C++ SoHeightMapToNormalMap class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHeightMapToNormalMap_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoHeightMapToNormalMap self) -> SoType"""
        return _coin.SoHeightMapToNormalMap_getTypeId(self)

    def getFieldData(self) -> "SoFieldData const *":
        r"""getFieldData(SoHeightMapToNormalMap self) -> SoFieldData"""
        return _coin.SoHeightMapToNormalMap_getFieldData(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoHeightMapToNormalMap self) -> SoEngineOutputData"""
        return _coin.SoHeightMapToNormalMap_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoHeightMapToNormalMap_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoHeightMapToNormalMap_initClass()

    def __init__(self):
        r"""__init__(SoHeightMapToNormalMap self) -> SoHeightMapToNormalMap"""
        _coin.SoHeightMapToNormalMap_swiginit(self, _coin.new_SoHeightMapToNormalMap())
    INT8 = _coin.SoHeightMapToNormalMap_INT8
    
    format = property(_coin.SoHeightMapToNormalMap_format_get, _coin.SoHeightMapToNormalMap_format_set, doc=r"""format : SoSFEnum""")

    @staticmethod
    def convert(srcptr: "unsigned char const *", size: "SbVec2s", nc: "int", dst_out: "SbImage") -> "void":
        r"""convert(unsigned char const * srcptr, SbVec2s size, int nc, SbImage dst_out)"""
        return _coin.SoHeightMapToNormalMap_convert(srcptr, size, nc, dst_out)
    __swig_destroy__ = _coin.delete_SoHeightMapToNormalMap

# Register SoHeightMapToNormalMap in _coin:
_coin.SoHeightMapToNormalMap_swigregister(SoHeightMapToNormalMap)

def SoHeightMapToNormalMap_getClassTypeId() -> "SoType":
    r"""SoHeightMapToNormalMap_getClassTypeId() -> SoType"""
    return _coin.SoHeightMapToNormalMap_getClassTypeId()

def SoHeightMapToNormalMap_createInstance() -> "void *":
    r"""SoHeightMapToNormalMap_createInstance() -> void *"""
    return _coin.SoHeightMapToNormalMap_createInstance()

def SoHeightMapToNormalMap_initClass() -> "void":
    r"""SoHeightMapToNormalMap_initClass()"""
    return _coin.SoHeightMapToNormalMap_initClass()

def SoHeightMapToNormalMap_convert(srcptr: "unsigned char const *", size: "SbVec2s", nc: "int", dst_out: "SbImage") -> "void":
    r"""SoHeightMapToNormalMap_convert(unsigned char const * srcptr, SbVec2s size, int nc, SbImage dst_out)"""
    return _coin.SoHeightMapToNormalMap_convert(srcptr, size, nc, dst_out)

class SoNodeEngine(SoNode):
    r"""Proxy of C++ SoNodeEngine class."""

    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 initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNodeEngine_initClass()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNodeEngine_getClassTypeId()

    def evaluateWrapper(self) -> "void":
        r"""evaluateWrapper(SoNodeEngine self)"""
        return _coin.SoNodeEngine_evaluateWrapper(self)

    def getOutputs(self, l: "SoEngineOutputList") -> "int":
        r"""getOutputs(SoNodeEngine self, SoEngineOutputList l) -> int"""
        return _coin.SoNodeEngine_getOutputs(self, l)

    def getOutput(self, outputname: "SbName") -> "SoEngineOutput *":
        r"""getOutput(SoNodeEngine self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoNodeEngine_getOutput(self, outputname)

    def getOutputName(self, output: "SoEngineOutput", outputname: "SbName") -> "SbBool":
        r"""getOutputName(SoNodeEngine self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoNodeEngine_getOutputName(self, output, outputname)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoNodeEngine self) -> SoEngineOutputData"""
        return _coin.SoNodeEngine_getOutputData(self)

    def isNotifying(self) -> "SbBool":
        r"""isNotifying(SoNodeEngine self) -> SbBool"""
        return _coin.SoNodeEngine_isNotifying(self)

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoNodeEngine self, SoNotList nl)"""
        return _coin.SoNodeEngine_notify(self, nl)

    def writeInstance(self, out: "SoOutput") -> "void":
        r"""writeInstance(SoNodeEngine self, SoOutput out)"""
        return _coin.SoNodeEngine_writeInstance(self, out)

# Register SoNodeEngine in _coin:
_coin.SoNodeEngine_swigregister(SoNodeEngine)

def SoNodeEngine_initClass() -> "void":
    r"""SoNodeEngine_initClass()"""
    return _coin.SoNodeEngine_initClass()

def SoNodeEngine_getClassTypeId() -> "SoType":
    r"""SoNodeEngine_getClassTypeId() -> SoType"""
    return _coin.SoNodeEngine_getClassTypeId()

class SoMemoryError(SoError):
    r"""Proxy of C++ SoMemoryError class."""

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

    @staticmethod
    def setHandlerCallback(callback: "SoErrorCB *const", data: "void *const") -> "void":
        r"""setHandlerCallback(SoErrorCB *const callback, void *const data)"""
        return _coin.SoMemoryError_setHandlerCallback(callback, data)

    @staticmethod
    def getHandlerCallback() -> "SoErrorCB *":
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoMemoryError_getHandlerCallback()

    @staticmethod
    def getHandlerData() -> "void *":
        r"""getHandlerData() -> void *"""
        return _coin.SoMemoryError_getHandlerData()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMemoryError_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMemoryError self) -> SoType"""
        return _coin.SoMemoryError_getTypeId(self)

    @staticmethod
    def post(whatWasAllocated: "char const *const") -> "void":
        r"""post(char const *const whatWasAllocated)"""
        return _coin.SoMemoryError_post(whatWasAllocated)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMemoryError_initClass()

    def __init__(self):
        r"""__init__(SoMemoryError self) -> SoMemoryError"""
        _coin.SoMemoryError_swiginit(self, _coin.new_SoMemoryError())
    __swig_destroy__ = _coin.delete_SoMemoryError

# Register SoMemoryError in _coin:
_coin.SoMemoryError_swigregister(SoMemoryError)

def SoMemoryError_setHandlerCallback(callback: "SoErrorCB *const", data: "void *const") -> "void":
    r"""SoMemoryError_setHandlerCallback(SoErrorCB *const callback, void *const data)"""
    return _coin.SoMemoryError_setHandlerCallback(callback, data)

def SoMemoryError_getHandlerCallback() -> "SoErrorCB *":
    r"""SoMemoryError_getHandlerCallback() -> SoErrorCB *"""
    return _coin.SoMemoryError_getHandlerCallback()

def SoMemoryError_getHandlerData() -> "void *":
    r"""SoMemoryError_getHandlerData() -> void *"""
    return _coin.SoMemoryError_getHandlerData()

def SoMemoryError_getClassTypeId() -> "SoType":
    r"""SoMemoryError_getClassTypeId() -> SoType"""
    return _coin.SoMemoryError_getClassTypeId()

def SoMemoryError_post(whatWasAllocated: "char const *const") -> "void":
    r"""SoMemoryError_post(char const *const whatWasAllocated)"""
    return _coin.SoMemoryError_post(whatWasAllocated)

def SoMemoryError_initClass() -> "void":
    r"""SoMemoryError_initClass()"""
    return _coin.SoMemoryError_initClass()

class SoReadError(SoError):
    r"""Proxy of C++ SoReadError class."""

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

    @staticmethod
    def setHandlerCallback(function: "SoErrorCB *const", data: "void *const") -> "void":
        r"""setHandlerCallback(SoErrorCB *const function, void *const data)"""
        return _coin.SoReadError_setHandlerCallback(function, data)

    @staticmethod
    def getHandlerCallback() -> "SoErrorCB *":
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoReadError_getHandlerCallback()

    @staticmethod
    def getHandlerData() -> "void *":
        r"""getHandlerData() -> void *"""
        return _coin.SoReadError_getHandlerData()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoReadError_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoReadError self) -> SoType"""
        return _coin.SoReadError_getTypeId(self)

    @staticmethod
    def post(*args) -> "void":
        r"""post(SoInput input, char const *const format)"""
        return _coin.SoReadError_post(*args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoReadError_initClass()

    def __init__(self):
        r"""__init__(SoReadError self) -> SoReadError"""
        _coin.SoReadError_swiginit(self, _coin.new_SoReadError())
    __swig_destroy__ = _coin.delete_SoReadError

# Register SoReadError in _coin:
_coin.SoReadError_swigregister(SoReadError)

def SoReadError_setHandlerCallback(function: "SoErrorCB *const", data: "void *const") -> "void":
    r"""SoReadError_setHandlerCallback(SoErrorCB *const function, void *const data)"""
    return _coin.SoReadError_setHandlerCallback(function, data)

def SoReadError_getHandlerCallback() -> "SoErrorCB *":
    r"""SoReadError_getHandlerCallback() -> SoErrorCB *"""
    return _coin.SoReadError_getHandlerCallback()

def SoReadError_getHandlerData() -> "void *":
    r"""SoReadError_getHandlerData() -> void *"""
    return _coin.SoReadError_getHandlerData()

def SoReadError_getClassTypeId() -> "SoType":
    r"""SoReadError_getClassTypeId() -> SoType"""
    return _coin.SoReadError_getClassTypeId()

def SoReadError_post(*args) -> "void":
    r"""SoReadError_post(SoInput input, char const *const format)"""
    return _coin.SoReadError_post(*args)

def SoReadError_initClass() -> "void":
    r"""SoReadError_initClass()"""
    return _coin.SoReadError_initClass()

class SoButtonEvent(SoEvent):
    r"""Proxy of C++ SoButtonEvent class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoButtonEvent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoButtonEvent self) -> SoType"""
        return _coin.SoButtonEvent_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoButtonEvent_initClass()

    def __init__(self):
        r"""__init__(SoButtonEvent self) -> SoButtonEvent"""
        _coin.SoButtonEvent_swiginit(self, _coin.new_SoButtonEvent())
    __swig_destroy__ = _coin.delete_SoButtonEvent
    UP = _coin.SoButtonEvent_UP
    
    DOWN = _coin.SoButtonEvent_DOWN
    
    UNKNOWN = _coin.SoButtonEvent_UNKNOWN
    

    def setState(self, state: "SoButtonEvent::State") -> "void":
        r"""setState(SoButtonEvent self, SoButtonEvent::State state)"""
        return _coin.SoButtonEvent_setState(self, state)

    def getState(self) -> "SoButtonEvent::State":
        r"""getState(SoButtonEvent self) -> SoButtonEvent::State"""
        return _coin.SoButtonEvent_getState(self)

    @staticmethod
    def enumToString(enumval: "SoButtonEvent::State", stringrep: "SbString") -> "SbBool":
        r"""enumToString(SoButtonEvent::State enumval, SbString stringrep) -> SbBool"""
        return _coin.SoButtonEvent_enumToString(enumval, stringrep)

# Register SoButtonEvent in _coin:
_coin.SoButtonEvent_swigregister(SoButtonEvent)

def SoButtonEvent_getClassTypeId() -> "SoType":
    r"""SoButtonEvent_getClassTypeId() -> SoType"""
    return _coin.SoButtonEvent_getClassTypeId()

def SoButtonEvent_initClass() -> "void":
    r"""SoButtonEvent_initClass()"""
    return _coin.SoButtonEvent_initClass()

def SoButtonEvent_enumToString(enumval: "SoButtonEvent::State", stringrep: "SbString") -> "SbBool":
    r"""SoButtonEvent_enumToString(SoButtonEvent::State enumval, SbString stringrep) -> SbBool"""
    return _coin.SoButtonEvent_enumToString(enumval, stringrep)

class SoLocation2Event(SoEvent):
    r"""Proxy of C++ SoLocation2Event class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLocation2Event_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLocation2Event self) -> SoType"""
        return _coin.SoLocation2Event_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLocation2Event_initClass()

    def __init__(self):
        r"""__init__(SoLocation2Event self) -> SoLocation2Event"""
        _coin.SoLocation2Event_swiginit(self, _coin.new_SoLocation2Event())
    __swig_destroy__ = _coin.delete_SoLocation2Event

# Register SoLocation2Event in _coin:
_coin.SoLocation2Event_swigregister(SoLocation2Event)

def SoLocation2Event_getClassTypeId() -> "SoType":
    r"""SoLocation2Event_getClassTypeId() -> SoType"""
    return _coin.SoLocation2Event_getClassTypeId()

def SoLocation2Event_initClass() -> "void":
    r"""SoLocation2Event_initClass()"""
    return _coin.SoLocation2Event_initClass()

class SoMotion3Event(SoEvent):
    r"""Proxy of C++ SoMotion3Event class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMotion3Event_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMotion3Event self) -> SoType"""
        return _coin.SoMotion3Event_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMotion3Event_initClass()

    def __init__(self):
        r"""__init__(SoMotion3Event self) -> SoMotion3Event"""
        _coin.SoMotion3Event_swiginit(self, _coin.new_SoMotion3Event())
    __swig_destroy__ = _coin.delete_SoMotion3Event

    def setTranslation(self, t: "SbVec3f") -> "void":
        r"""setTranslation(SoMotion3Event self, SbVec3f t)"""
        return _coin.SoMotion3Event_setTranslation(self, t)

    def getTranslation(self) -> "SbVec3f const &":
        r"""getTranslation(SoMotion3Event self) -> SbVec3f"""
        return _coin.SoMotion3Event_getTranslation(self)

    def setRotation(self, r: "SbRotation") -> "void":
        r"""setRotation(SoMotion3Event self, SbRotation r)"""
        return _coin.SoMotion3Event_setRotation(self, r)

    def getRotation(self) -> "SbRotation const &":
        r"""getRotation(SoMotion3Event self) -> SbRotation"""
        return _coin.SoMotion3Event_getRotation(self)

# Register SoMotion3Event in _coin:
_coin.SoMotion3Event_swigregister(SoMotion3Event)

def SoMotion3Event_getClassTypeId() -> "SoType":
    r"""SoMotion3Event_getClassTypeId() -> SoType"""
    return _coin.SoMotion3Event_getClassTypeId()

def SoMotion3Event_initClass() -> "void":
    r"""SoMotion3Event_initClass()"""
    return _coin.SoMotion3Event_initClass()

class SoKeyboardEvent(SoButtonEvent):
    r"""Proxy of C++ SoKeyboardEvent class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoKeyboardEvent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoKeyboardEvent self) -> SoType"""
        return _coin.SoKeyboardEvent_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoKeyboardEvent_initClass()

    def __init__(self):
        r"""__init__(SoKeyboardEvent self) -> SoKeyboardEvent"""
        _coin.SoKeyboardEvent_swiginit(self, _coin.new_SoKeyboardEvent())
    __swig_destroy__ = _coin.delete_SoKeyboardEvent
    ANY = _coin.SoKeyboardEvent_ANY
    
    UNDEFINED = _coin.SoKeyboardEvent_UNDEFINED
    
    LEFT_SHIFT = _coin.SoKeyboardEvent_LEFT_SHIFT
    
    RIGHT_SHIFT = _coin.SoKeyboardEvent_RIGHT_SHIFT
    
    LEFT_CONTROL = _coin.SoKeyboardEvent_LEFT_CONTROL
    
    RIGHT_CONTROL = _coin.SoKeyboardEvent_RIGHT_CONTROL
    
    LEFT_ALT = _coin.SoKeyboardEvent_LEFT_ALT
    
    RIGHT_ALT = _coin.SoKeyboardEvent_RIGHT_ALT
    
    NUMBER_0 = _coin.SoKeyboardEvent_NUMBER_0
    
    NUMBER_1 = _coin.SoKeyboardEvent_NUMBER_1
    
    NUMBER_2 = _coin.SoKeyboardEvent_NUMBER_2
    
    NUMBER_3 = _coin.SoKeyboardEvent_NUMBER_3
    
    NUMBER_4 = _coin.SoKeyboardEvent_NUMBER_4
    
    NUMBER_5 = _coin.SoKeyboardEvent_NUMBER_5
    
    NUMBER_6 = _coin.SoKeyboardEvent_NUMBER_6
    
    NUMBER_7 = _coin.SoKeyboardEvent_NUMBER_7
    
    NUMBER_8 = _coin.SoKeyboardEvent_NUMBER_8
    
    NUMBER_9 = _coin.SoKeyboardEvent_NUMBER_9
    
    A = _coin.SoKeyboardEvent_A
    
    B = _coin.SoKeyboardEvent_B
    
    C = _coin.SoKeyboardEvent_C
    
    D = _coin.SoKeyboardEvent_D
    
    E = _coin.SoKeyboardEvent_E
    
    F = _coin.SoKeyboardEvent_F
    
    G = _coin.SoKeyboardEvent_G
    
    H = _coin.SoKeyboardEvent_H
    
    I = _coin.SoKeyboardEvent_I
    
    J = _coin.SoKeyboardEvent_J
    
    K = _coin.SoKeyboardEvent_K
    
    L = _coin.SoKeyboardEvent_L
    
    M = _coin.SoKeyboardEvent_M
    
    N = _coin.SoKeyboardEvent_N
    
    O = _coin.SoKeyboardEvent_O
    
    P = _coin.SoKeyboardEvent_P
    
    Q = _coin.SoKeyboardEvent_Q
    
    R = _coin.SoKeyboardEvent_R
    
    S = _coin.SoKeyboardEvent_S
    
    T = _coin.SoKeyboardEvent_T
    
    U = _coin.SoKeyboardEvent_U
    
    V = _coin.SoKeyboardEvent_V
    
    W = _coin.SoKeyboardEvent_W
    
    X = _coin.SoKeyboardEvent_X
    
    Y = _coin.SoKeyboardEvent_Y
    
    Z = _coin.SoKeyboardEvent_Z
    
    HOME = _coin.SoKeyboardEvent_HOME
    
    LEFT_ARROW = _coin.SoKeyboardEvent_LEFT_ARROW
    
    UP_ARROW = _coin.SoKeyboardEvent_UP_ARROW
    
    RIGHT_ARROW = _coin.SoKeyboardEvent_RIGHT_ARROW
    
    DOWN_ARROW = _coin.SoKeyboardEvent_DOWN_ARROW
    
    PAGE_UP = _coin.SoKeyboardEvent_PAGE_UP
    
    PAGE_DOWN = _coin.SoKeyboardEvent_PAGE_DOWN
    
    END = _coin.SoKeyboardEvent_END
    
    PRIOR = _coin.SoKeyboardEvent_PRIOR
    
    NEXT = _coin.SoKeyboardEvent_NEXT
    
    PAD_ENTER = _coin.SoKeyboardEvent_PAD_ENTER
    
    PAD_F1 = _coin.SoKeyboardEvent_PAD_F1
    
    PAD_F2 = _coin.SoKeyboardEvent_PAD_F2
    
    PAD_F3 = _coin.SoKeyboardEvent_PAD_F3
    
    PAD_F4 = _coin.SoKeyboardEvent_PAD_F4
    
    PAD_0 = _coin.SoKeyboardEvent_PAD_0
    
    PAD_1 = _coin.SoKeyboardEvent_PAD_1
    
    PAD_2 = _coin.SoKeyboardEvent_PAD_2
    
    PAD_3 = _coin.SoKeyboardEvent_PAD_3
    
    PAD_4 = _coin.SoKeyboardEvent_PAD_4
    
    PAD_5 = _coin.SoKeyboardEvent_PAD_5
    
    PAD_6 = _coin.SoKeyboardEvent_PAD_6
    
    PAD_7 = _coin.SoKeyboardEvent_PAD_7
    
    PAD_8 = _coin.SoKeyboardEvent_PAD_8
    
    PAD_9 = _coin.SoKeyboardEvent_PAD_9
    
    PAD_ADD = _coin.SoKeyboardEvent_PAD_ADD
    
    PAD_SUBTRACT = _coin.SoKeyboardEvent_PAD_SUBTRACT
    
    PAD_MULTIPLY = _coin.SoKeyboardEvent_PAD_MULTIPLY
    
    PAD_DIVIDE = _coin.SoKeyboardEvent_PAD_DIVIDE
    
    PAD_SPACE = _coin.SoKeyboardEvent_PAD_SPACE
    
    PAD_TAB = _coin.SoKeyboardEvent_PAD_TAB
    
    PAD_INSERT = _coin.SoKeyboardEvent_PAD_INSERT
    
    PAD_DELETE = _coin.SoKeyboardEvent_PAD_DELETE
    
    PAD_PERIOD = _coin.SoKeyboardEvent_PAD_PERIOD
    
    F1 = _coin.SoKeyboardEvent_F1
    
    F2 = _coin.SoKeyboardEvent_F2
    
    F3 = _coin.SoKeyboardEvent_F3
    
    F4 = _coin.SoKeyboardEvent_F4
    
    F5 = _coin.SoKeyboardEvent_F5
    
    F6 = _coin.SoKeyboardEvent_F6
    
    F7 = _coin.SoKeyboardEvent_F7
    
    F8 = _coin.SoKeyboardEvent_F8
    
    F9 = _coin.SoKeyboardEvent_F9
    
    F10 = _coin.SoKeyboardEvent_F10
    
    F11 = _coin.SoKeyboardEvent_F11
    
    F12 = _coin.SoKeyboardEvent_F12
    
    BACKSPACE = _coin.SoKeyboardEvent_BACKSPACE
    
    TAB = _coin.SoKeyboardEvent_TAB
    
    RETURN = _coin.SoKeyboardEvent_RETURN
    
    ENTER = _coin.SoKeyboardEvent_ENTER
    
    PAUSE = _coin.SoKeyboardEvent_PAUSE
    
    SCROLL_LOCK = _coin.SoKeyboardEvent_SCROLL_LOCK
    
    ESCAPE = _coin.SoKeyboardEvent_ESCAPE
    
    DELETE = _coin.SoKeyboardEvent_DELETE
    
    KEY_DELETE = _coin.SoKeyboardEvent_KEY_DELETE
    
    PRINT = _coin.SoKeyboardEvent_PRINT
    
    INSERT = _coin.SoKeyboardEvent_INSERT
    
    NUM_LOCK = _coin.SoKeyboardEvent_NUM_LOCK
    
    CAPS_LOCK = _coin.SoKeyboardEvent_CAPS_LOCK
    
    SHIFT_LOCK = _coin.SoKeyboardEvent_SHIFT_LOCK
    
    SPACE = _coin.SoKeyboardEvent_SPACE
    
    APOSTROPHE = _coin.SoKeyboardEvent_APOSTROPHE
    
    COMMA = _coin.SoKeyboardEvent_COMMA
    
    MINUS = _coin.SoKeyboardEvent_MINUS
    
    PERIOD = _coin.SoKeyboardEvent_PERIOD
    
    SLASH = _coin.SoKeyboardEvent_SLASH
    
    SEMICOLON = _coin.SoKeyboardEvent_SEMICOLON
    
    EQUAL = _coin.SoKeyboardEvent_EQUAL
    
    BRACKETLEFT = _coin.SoKeyboardEvent_BRACKETLEFT
    
    BACKSLASH = _coin.SoKeyboardEvent_BACKSLASH
    
    BRACKETRIGHT = _coin.SoKeyboardEvent_BRACKETRIGHT
    
    GRAVE = _coin.SoKeyboardEvent_GRAVE
    

    def setKey(self, key: "SoKeyboardEvent::Key") -> "void":
        r"""setKey(SoKeyboardEvent self, SoKeyboardEvent::Key key)"""
        return _coin.SoKeyboardEvent_setKey(self, key)

    def getKey(self) -> "SoKeyboardEvent::Key":
        r"""getKey(SoKeyboardEvent self) -> SoKeyboardEvent::Key"""
        return _coin.SoKeyboardEvent_getKey(self)

    def setPrintableCharacter(self, c: "char const") -> "void":
        r"""setPrintableCharacter(SoKeyboardEvent self, char const c)"""
        return _coin.SoKeyboardEvent_setPrintableCharacter(self, c)

    def getPrintableCharacter(self) -> "char":
        r"""getPrintableCharacter(SoKeyboardEvent self) -> char"""
        return _coin.SoKeyboardEvent_getPrintableCharacter(self)

    @staticmethod
    def isKeyPressEvent(e: "SoEvent", whichKey: "SoKeyboardEvent::Key") -> "SbBool":
        r"""isKeyPressEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyPressEvent(e, whichKey)

    @staticmethod
    def isKeyReleaseEvent(e: "SoEvent", whichKey: "SoKeyboardEvent::Key") -> "SbBool":
        r"""isKeyReleaseEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyReleaseEvent(e, whichKey)

    @staticmethod
    def enumToString(enumval: "SoKeyboardEvent::Key", stringrep: "SbString") -> "SbBool":
        r"""enumToString(SoKeyboardEvent::Key enumval, SbString stringrep) -> SbBool"""
        return _coin.SoKeyboardEvent_enumToString(enumval, stringrep)

# Register SoKeyboardEvent in _coin:
_coin.SoKeyboardEvent_swigregister(SoKeyboardEvent)

def SoKeyboardEvent_getClassTypeId() -> "SoType":
    r"""SoKeyboardEvent_getClassTypeId() -> SoType"""
    return _coin.SoKeyboardEvent_getClassTypeId()

def SoKeyboardEvent_initClass() -> "void":
    r"""SoKeyboardEvent_initClass()"""
    return _coin.SoKeyboardEvent_initClass()

def SoKeyboardEvent_isKeyPressEvent(e: "SoEvent", whichKey: "SoKeyboardEvent::Key") -> "SbBool":
    r"""SoKeyboardEvent_isKeyPressEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
    return _coin.SoKeyboardEvent_isKeyPressEvent(e, whichKey)

def SoKeyboardEvent_isKeyReleaseEvent(e: "SoEvent", whichKey: "SoKeyboardEvent::Key") -> "SbBool":
    r"""SoKeyboardEvent_isKeyReleaseEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
    return _coin.SoKeyboardEvent_isKeyReleaseEvent(e, whichKey)

def SoKeyboardEvent_enumToString(enumval: "SoKeyboardEvent::Key", stringrep: "SbString") -> "SbBool":
    r"""SoKeyboardEvent_enumToString(SoKeyboardEvent::Key enumval, SbString stringrep) -> SbBool"""
    return _coin.SoKeyboardEvent_enumToString(enumval, stringrep)

class SoMouseButtonEvent(SoButtonEvent):
    r"""Proxy of C++ SoMouseButtonEvent class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMouseButtonEvent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMouseButtonEvent self) -> SoType"""
        return _coin.SoMouseButtonEvent_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMouseButtonEvent_initClass()

    def __init__(self):
        r"""__init__(SoMouseButtonEvent self) -> SoMouseButtonEvent"""
        _coin.SoMouseButtonEvent_swiginit(self, _coin.new_SoMouseButtonEvent())
    __swig_destroy__ = _coin.delete_SoMouseButtonEvent
    ANY = _coin.SoMouseButtonEvent_ANY
    
    BUTTON1 = _coin.SoMouseButtonEvent_BUTTON1
    
    BUTTON2 = _coin.SoMouseButtonEvent_BUTTON2
    
    BUTTON3 = _coin.SoMouseButtonEvent_BUTTON3
    
    BUTTON4 = _coin.SoMouseButtonEvent_BUTTON4
    
    BUTTON5 = _coin.SoMouseButtonEvent_BUTTON5
    

    def setButton(self, button: "SoMouseButtonEvent::Button") -> "void":
        r"""setButton(SoMouseButtonEvent self, SoMouseButtonEvent::Button button)"""
        return _coin.SoMouseButtonEvent_setButton(self, button)

    def getButton(self) -> "SoMouseButtonEvent::Button":
        r"""getButton(SoMouseButtonEvent self) -> SoMouseButtonEvent::Button"""
        return _coin.SoMouseButtonEvent_getButton(self)

    @staticmethod
    def isButtonPressEvent(e: "SoEvent", whichButton: "SoMouseButtonEvent::Button") -> "SbBool":
        r"""isButtonPressEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonPressEvent(e, whichButton)

    @staticmethod
    def isButtonReleaseEvent(e: "SoEvent", whichButton: "SoMouseButtonEvent::Button") -> "SbBool":
        r"""isButtonReleaseEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonReleaseEvent(e, whichButton)

    @staticmethod
    def enumToString(enumval: "SoMouseButtonEvent::Button", stringrep: "SbString") -> "SbBool":
        r"""enumToString(SoMouseButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoMouseButtonEvent_enumToString(enumval, stringrep)

# Register SoMouseButtonEvent in _coin:
_coin.SoMouseButtonEvent_swigregister(SoMouseButtonEvent)

def SoMouseButtonEvent_getClassTypeId() -> "SoType":
    r"""SoMouseButtonEvent_getClassTypeId() -> SoType"""
    return _coin.SoMouseButtonEvent_getClassTypeId()

def SoMouseButtonEvent_initClass() -> "void":
    r"""SoMouseButtonEvent_initClass()"""
    return _coin.SoMouseButtonEvent_initClass()

def SoMouseButtonEvent_isButtonPressEvent(e: "SoEvent", whichButton: "SoMouseButtonEvent::Button") -> "SbBool":
    r"""SoMouseButtonEvent_isButtonPressEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoMouseButtonEvent_isButtonPressEvent(e, whichButton)

def SoMouseButtonEvent_isButtonReleaseEvent(e: "SoEvent", whichButton: "SoMouseButtonEvent::Button") -> "SbBool":
    r"""SoMouseButtonEvent_isButtonReleaseEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoMouseButtonEvent_isButtonReleaseEvent(e, whichButton)

def SoMouseButtonEvent_enumToString(enumval: "SoMouseButtonEvent::Button", stringrep: "SbString") -> "SbBool":
    r"""SoMouseButtonEvent_enumToString(SoMouseButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
    return _coin.SoMouseButtonEvent_enumToString(enumval, stringrep)

class SoSpaceballButtonEvent(SoButtonEvent):
    r"""Proxy of C++ SoSpaceballButtonEvent class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpaceballButtonEvent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSpaceballButtonEvent self) -> SoType"""
        return _coin.SoSpaceballButtonEvent_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSpaceballButtonEvent_initClass()

    def __init__(self):
        r"""__init__(SoSpaceballButtonEvent self) -> SoSpaceballButtonEvent"""
        _coin.SoSpaceballButtonEvent_swiginit(self, _coin.new_SoSpaceballButtonEvent())
    __swig_destroy__ = _coin.delete_SoSpaceballButtonEvent
    ANY = _coin.SoSpaceballButtonEvent_ANY
    
    BUTTON1 = _coin.SoSpaceballButtonEvent_BUTTON1
    
    BUTTON2 = _coin.SoSpaceballButtonEvent_BUTTON2
    
    BUTTON3 = _coin.SoSpaceballButtonEvent_BUTTON3
    
    BUTTON4 = _coin.SoSpaceballButtonEvent_BUTTON4
    
    BUTTON5 = _coin.SoSpaceballButtonEvent_BUTTON5
    
    BUTTON6 = _coin.SoSpaceballButtonEvent_BUTTON6
    
    BUTTON7 = _coin.SoSpaceballButtonEvent_BUTTON7
    
    BUTTON8 = _coin.SoSpaceballButtonEvent_BUTTON8
    
    PICK = _coin.SoSpaceballButtonEvent_PICK
    

    def setButton(self, button: "SoSpaceballButtonEvent::Button") -> "void":
        r"""setButton(SoSpaceballButtonEvent self, SoSpaceballButtonEvent::Button button)"""
        return _coin.SoSpaceballButtonEvent_setButton(self, button)

    def getButton(self) -> "SoSpaceballButtonEvent::Button":
        r"""getButton(SoSpaceballButtonEvent self) -> SoSpaceballButtonEvent::Button"""
        return _coin.SoSpaceballButtonEvent_getButton(self)

    @staticmethod
    def isButtonPressEvent(e: "SoEvent", whichButton: "SoSpaceballButtonEvent::Button") -> "SbBool":
        r"""isButtonPressEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonPressEvent(e, whichButton)

    @staticmethod
    def isButtonReleaseEvent(e: "SoEvent", whichButton: "SoSpaceballButtonEvent::Button") -> "SbBool":
        r"""isButtonReleaseEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonReleaseEvent(e, whichButton)

    @staticmethod
    def enumToString(enumval: "SoSpaceballButtonEvent::Button", stringrep: "SbString") -> "SbBool":
        r"""enumToString(SoSpaceballButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_enumToString(enumval, stringrep)

# Register SoSpaceballButtonEvent in _coin:
_coin.SoSpaceballButtonEvent_swigregister(SoSpaceballButtonEvent)

def SoSpaceballButtonEvent_getClassTypeId() -> "SoType":
    r"""SoSpaceballButtonEvent_getClassTypeId() -> SoType"""
    return _coin.SoSpaceballButtonEvent_getClassTypeId()

def SoSpaceballButtonEvent_initClass() -> "void":
    r"""SoSpaceballButtonEvent_initClass()"""
    return _coin.SoSpaceballButtonEvent_initClass()

def SoSpaceballButtonEvent_isButtonPressEvent(e: "SoEvent", whichButton: "SoSpaceballButtonEvent::Button") -> "SbBool":
    r"""SoSpaceballButtonEvent_isButtonPressEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoSpaceballButtonEvent_isButtonPressEvent(e, whichButton)

def SoSpaceballButtonEvent_isButtonReleaseEvent(e: "SoEvent", whichButton: "SoSpaceballButtonEvent::Button") -> "SbBool":
    r"""SoSpaceballButtonEvent_isButtonReleaseEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoSpaceballButtonEvent_isButtonReleaseEvent(e, whichButton)

def SoSpaceballButtonEvent_enumToString(enumval: "SoSpaceballButtonEvent::Button", stringrep: "SbString") -> "SbBool":
    r"""SoSpaceballButtonEvent_enumToString(SoSpaceballButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
    return _coin.SoSpaceballButtonEvent_enumToString(enumval, stringrep)

class SbBox2s(object):
    r"""Proxy of C++ SbBox2s class."""

    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):
        r"""
        __init__(SbBox2s self) -> SbBox2s
        __init__(SbBox2s self, short xmin, short ymin, short xmax, short ymax) -> SbBox2s
        __init__(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint) -> SbBox2s
        __init__(SbBox2s self, SbBox2i32 box) -> SbBox2s
        __init__(SbBox2s self, SbBox2f box) -> SbBox2s
        __init__(SbBox2s self, SbBox2d box) -> SbBox2s
        """
        _coin.SbBox2s_swiginit(self, _coin.new_SbBox2s(*args))

    def setBounds(self, *args) -> "SbBox2s &":
        r"""
        setBounds(SbBox2s self, short xmin, short ymin, short xmax, short ymax) -> SbBox2s
        setBounds(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint) -> SbBox2s
        setBounds(SbBox2s self, SbBox2i32 box) -> SbBox2s
        setBounds(SbBox2s self, SbBox2f box) -> SbBox2s
        setBounds(SbBox2s self, SbBox2d box) -> SbBox2s
        """
        return _coin.SbBox2s_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox2s self, short & xmin, short & ymin, short & xmax, short & ymax)
        getBounds(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint)
        """
        return _coin.SbBox2s_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec2s &":
        r"""
        getMin(SbBox2s self) -> SbVec2s
        getMin(SbBox2s self) -> SbVec2s
        """
        return _coin.SbBox2s_getMin(self, *args)

    def getMax(self, *args) -> "SbVec2s &":
        r"""
        getMax(SbBox2s self) -> SbVec2s
        getMax(SbBox2s self) -> SbVec2s
        """
        return _coin.SbBox2s_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox2s self, SbVec2s point)
        extendBy(SbBox2s self, SbBox2s box)
        """
        return _coin.SbBox2s_extendBy(self, *args)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox2s self)"""
        return _coin.SbBox2s_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox2s self) -> SbBool"""
        return _coin.SbBox2s_isEmpty(self)

    def hasArea(self) -> "SbBool":
        r"""hasArea(SbBox2s self) -> SbBool"""
        return _coin.SbBox2s_hasArea(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox2s self, SbVec2s point) -> SbBool
        intersect(SbBox2s self, SbBox2s box) -> SbBool
        """
        return _coin.SbBox2s_intersect(self, *args)

    def getCenter(self) -> "SbVec2f":
        r"""getCenter(SbBox2s self) -> SbVec2f"""
        return _coin.SbBox2s_getCenter(self)

    def getOrigin(self, originX: "short &", originY: "short &") -> "void":
        r"""getOrigin(SbBox2s self, short & originX, short & originY)"""
        return _coin.SbBox2s_getOrigin(self, originX, originY)

    def getSize(self, *args) -> "SbVec2s":
        r"""
        getSize(SbBox2s self, short & sizeX, short & sizeY)
        getSize(SbBox2s self) -> SbVec2s
        """
        return _coin.SbBox2s_getSize(self, *args)

    def getAspectRatio(self) -> "float":
        r"""getAspectRatio(SbBox2s self) -> float"""
        return _coin.SbBox2s_getAspectRatio(self)

    def __eq__(self, u: "SbBox2s") -> "int":
        r"""__eq__(SbBox2s self, SbBox2s u) -> int"""
        return _coin.SbBox2s___eq__(self, u)

    def __ne__(self, u: "SbBox2s") -> "int":
        r"""__ne__(SbBox2s self, SbBox2s u) -> int"""
        return _coin.SbBox2s___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox2s

# Register SbBox2s in _coin:
_coin.SbBox2s_swigregister(SbBox2s)

class SoSFBox2s(SoSField):
    r"""Proxy of C++ SoSFBox2s class."""

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

    def __init__(self):
        r"""__init__(SoSFBox2s self) -> SoSFBox2s"""
        _coin.SoSFBox2s_swiginit(self, _coin.new_SoSFBox2s())
    __swig_destroy__ = _coin.delete_SoSFBox2s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox2s self) -> SoType"""
        return _coin.SoSFBox2s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox2s self, SoField field)"""
        return _coin.SoSFBox2s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox2s self, SoField field) -> SbBool"""
        return _coin.SoSFBox2s_isSame(self, field)

    def __eq__(self, field: "SoSFBox2s") -> "int":
        r"""__eq__(SoSFBox2s self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___eq__(self, field)

    def __ne__(self, field: "SoSFBox2s") -> "int":
        r"""__ne__(SoSFBox2s self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox2s_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox2s self, SbBox2s newvalue)
        setValue(SoSFBox2s self, short xmin, short ymin, short xmax, short ymax)
        setValue(SoSFBox2s self, SbVec2s minvec, SbVec2s maxvec)
        """
        return _coin.SoSFBox2s_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox2s self) -> SbBox2s
        getValue(SoSFBox2s self, SbBox2s box)
        """
        return _coin.SoSFBox2s_getValue(self, *args)

# Register SoSFBox2s in _coin:
_coin.SoSFBox2s_swigregister(SoSFBox2s)

def SoSFBox2s_createInstance() -> "void *":
    r"""SoSFBox2s_createInstance() -> void *"""
    return _coin.SoSFBox2s_createInstance()

def SoSFBox2s_getClassTypeId() -> "SoType":
    r"""SoSFBox2s_getClassTypeId() -> SoType"""
    return _coin.SoSFBox2s_getClassTypeId()

def SoSFBox2s_initClass() -> "void":
    r"""SoSFBox2s_initClass()"""
    return _coin.SoSFBox2s_initClass()

class SbVec2i32(object):
    r"""Proxy of C++ SbVec2i32 class."""

    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):
        r"""
        __init__(SbVec2i32 self) -> SbVec2i32
        __init__(SbVec2i32 self, int32_t const [2] v) -> SbVec2i32
        __init__(SbVec2i32 self, int32_t x, int32_t y) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2ui32 const & v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2b v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2s v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2f v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2d v) -> SbVec2i32
        """
        _coin.SbVec2i32_swiginit(self, _coin.new_SbVec2i32(*args))

    def setValue(self, *args) -> "SbVec2i32 &":
        r"""
        setValue(SbVec2i32 self, int32_t const [2] v) -> SbVec2i32
        setValue(SbVec2i32 self, int32_t x, int32_t y) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2ui32 const & v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2b v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2s v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2f v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2d v) -> SbVec2i32
        """
        return _coin.SbVec2i32_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec2i32 self) -> int32_t const
        getValue(SbVec2i32 self, int32_t & x, int32_t & y)
        """
        return _coin.SbVec2i32_getValue(self, *args)

    def dot(self, v: "SbVec2i32") -> "int32_t":
        r"""dot(SbVec2i32 self, SbVec2i32 v) -> int32_t"""
        return _coin.SbVec2i32_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec2i32 self)"""
        return _coin.SbVec2i32_negate(self)

    def __imul__(self, *args) -> "SbVec2i32 &":
        r"""
        __imul__(SbVec2i32 self, int d) -> SbVec2i32
        __imul__(SbVec2i32 self, double d) -> SbVec2i32
        """
        return _coin.SbVec2i32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec2i32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec2i32") -> "SbVec2i32 &":
        r"""__iadd__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___iadd__(self, v)

    def __isub__(self, v: "SbVec2i32") -> "SbVec2i32 &":
        r"""__isub__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___isub__(self, v)

    def __neg__(self) -> "SbVec2i32":
        r"""__neg__(SbVec2i32 self) -> SbVec2i32"""
        return _coin.SbVec2i32___neg__(self)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec2i32 self, FILE * fp)"""
        return _coin.SbVec2i32_output(self, fp)
    __swig_destroy__ = _coin.delete_SbVec2i32

# Register SbVec2i32 in _coin:
_coin.SbVec2i32_swigregister(SbVec2i32)

class SbBox2i32(object):
    r"""Proxy of C++ SbBox2i32 class."""

    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):
        r"""
        __init__(SbBox2i32 self) -> SbBox2i32
        __init__(SbBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax) -> SbBox2i32
        __init__(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint) -> SbBox2i32
        __init__(SbBox2i32 self, SbBox2s box) -> SbBox2i32
        __init__(SbBox2i32 self, SbBox2f box) -> SbBox2i32
        __init__(SbBox2i32 self, SbBox2d box) -> SbBox2i32
        """
        _coin.SbBox2i32_swiginit(self, _coin.new_SbBox2i32(*args))

    def setBounds(self, *args) -> "SbBox2i32 &":
        r"""
        setBounds(SbBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax) -> SbBox2i32
        setBounds(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint) -> SbBox2i32
        setBounds(SbBox2i32 self, SbBox2s box) -> SbBox2i32
        setBounds(SbBox2i32 self, SbBox2f box) -> SbBox2i32
        setBounds(SbBox2i32 self, SbBox2d box) -> SbBox2i32
        """
        return _coin.SbBox2i32_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox2i32 self, int32_t & xmin, int32_t & ymin, int32_t & xmax, int32_t & ymax)
        getBounds(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint)
        """
        return _coin.SbBox2i32_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec2i32 &":
        r"""
        getMin(SbBox2i32 self) -> SbVec2i32
        getMin(SbBox2i32 self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMin(self, *args)

    def getMax(self, *args) -> "SbVec2i32 &":
        r"""
        getMax(SbBox2i32 self) -> SbVec2i32
        getMax(SbBox2i32 self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox2i32 self, SbVec2i32 point)
        extendBy(SbBox2i32 self, SbBox2i32 box)
        """
        return _coin.SbBox2i32_extendBy(self, *args)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox2i32 self)"""
        return _coin.SbBox2i32_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox2i32 self) -> SbBool"""
        return _coin.SbBox2i32_isEmpty(self)

    def hasArea(self) -> "SbBool":
        r"""hasArea(SbBox2i32 self) -> SbBool"""
        return _coin.SbBox2i32_hasArea(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox2i32 self, SbVec2i32 point) -> SbBool
        intersect(SbBox2i32 self, SbBox2i32 box) -> SbBool
        """
        return _coin.SbBox2i32_intersect(self, *args)

    def getCenter(self) -> "SbVec2f":
        r"""getCenter(SbBox2i32 self) -> SbVec2f"""
        return _coin.SbBox2i32_getCenter(self)

    def getOrigin(self, originX: "int32_t &", originY: "int32_t &") -> "void":
        r"""getOrigin(SbBox2i32 self, int32_t & originX, int32_t & originY)"""
        return _coin.SbBox2i32_getOrigin(self, originX, originY)

    def getSize(self, *args) -> "SbVec2i32":
        r"""
        getSize(SbBox2i32 self, int32_t & sizeX, int32_t & sizeY)
        getSize(SbBox2i32 self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getSize(self, *args)

    def getAspectRatio(self) -> "float":
        r"""getAspectRatio(SbBox2i32 self) -> float"""
        return _coin.SbBox2i32_getAspectRatio(self)
    __swig_destroy__ = _coin.delete_SbBox2i32

# Register SbBox2i32 in _coin:
_coin.SbBox2i32_swigregister(SbBox2i32)

class SoSFBox2i32(SoSField):
    r"""Proxy of C++ SoSFBox2i32 class."""

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

    def __init__(self):
        r"""__init__(SoSFBox2i32 self) -> SoSFBox2i32"""
        _coin.SoSFBox2i32_swiginit(self, _coin.new_SoSFBox2i32())
    __swig_destroy__ = _coin.delete_SoSFBox2i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox2i32 self) -> SoType"""
        return _coin.SoSFBox2i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox2i32 self, SoField field)"""
        return _coin.SoSFBox2i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox2i32 self, SoField field) -> SbBool"""
        return _coin.SoSFBox2i32_isSame(self, field)

    def __eq__(self, field: "SoSFBox2i32") -> "int":
        r"""__eq__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___eq__(self, field)

    def __ne__(self, field: "SoSFBox2i32") -> "int":
        r"""__ne__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox2i32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox2i32 self, SbBox2i32 newvalue)
        setValue(SoSFBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax)
        setValue(SoSFBox2i32 self, SbVec2i32 minvec, SbVec2i32 maxvec)
        """
        return _coin.SoSFBox2i32_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox2i32 self) -> SbBox2i32
        getValue(SoSFBox2i32 self, SbBox2i32 box)
        """
        return _coin.SoSFBox2i32_getValue(self, *args)

# Register SoSFBox2i32 in _coin:
_coin.SoSFBox2i32_swigregister(SoSFBox2i32)

def SoSFBox2i32_createInstance() -> "void *":
    r"""SoSFBox2i32_createInstance() -> void *"""
    return _coin.SoSFBox2i32_createInstance()

def SoSFBox2i32_getClassTypeId() -> "SoType":
    r"""SoSFBox2i32_getClassTypeId() -> SoType"""
    return _coin.SoSFBox2i32_getClassTypeId()

def SoSFBox2i32_initClass() -> "void":
    r"""SoSFBox2i32_initClass()"""
    return _coin.SoSFBox2i32_initClass()

class SbBox2f(object):
    r"""Proxy of C++ SbBox2f class."""

    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):
        r"""
        __init__(SbBox2f self) -> SbBox2f
        __init__(SbBox2f self, float xmin, float ymin, float xmax, float ymax) -> SbBox2f
        __init__(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint) -> SbBox2f
        __init__(SbBox2f self, SbBox2d box) -> SbBox2f
        __init__(SbBox2f self, SbBox2s box) -> SbBox2f
        __init__(SbBox2f self, SbBox2i32 box) -> SbBox2f
        """
        _coin.SbBox2f_swiginit(self, _coin.new_SbBox2f(*args))

    def setBounds(self, *args) -> "SbBox2f &":
        r"""
        setBounds(SbBox2f self, float xmin, float ymin, float xmax, float ymax) -> SbBox2f
        setBounds(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint) -> SbBox2f
        setBounds(SbBox2f self, SbBox2d box) -> SbBox2f
        setBounds(SbBox2f self, SbBox2s box) -> SbBox2f
        setBounds(SbBox2f self, SbBox2i32 box) -> SbBox2f
        """
        return _coin.SbBox2f_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox2f self, float & xmin, float & ymin, float & xmax, float & ymax)
        getBounds(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint)
        """
        return _coin.SbBox2f_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec2f &":
        r"""
        getMin(SbBox2f self) -> SbVec2f
        getMin(SbBox2f self) -> SbVec2f
        """
        return _coin.SbBox2f_getMin(self, *args)

    def getMax(self, *args) -> "SbVec2f &":
        r"""
        getMax(SbBox2f self) -> SbVec2f
        getMax(SbBox2f self) -> SbVec2f
        """
        return _coin.SbBox2f_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox2f self, SbVec2f point)
        extendBy(SbBox2f self, SbBox2f box)
        """
        return _coin.SbBox2f_extendBy(self, *args)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox2f self)"""
        return _coin.SbBox2f_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox2f self) -> SbBool"""
        return _coin.SbBox2f_isEmpty(self)

    def hasArea(self) -> "SbBool":
        r"""hasArea(SbBox2f self) -> SbBool"""
        return _coin.SbBox2f_hasArea(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox2f self, SbVec2f point) -> SbBool
        intersect(SbBox2f self, SbBox2f box) -> SbBool
        """
        return _coin.SbBox2f_intersect(self, *args)

    def getClosestPoint(self, point: "SbVec2f") -> "SbVec2f":
        r"""getClosestPoint(SbBox2f self, SbVec2f point) -> SbVec2f"""
        return _coin.SbBox2f_getClosestPoint(self, point)

    def getCenter(self) -> "SbVec2f":
        r"""getCenter(SbBox2f self) -> SbVec2f"""
        return _coin.SbBox2f_getCenter(self)

    def getOrigin(self, originX: "float &", originY: "float &") -> "void":
        r"""getOrigin(SbBox2f self, float & originX, float & originY)"""
        return _coin.SbBox2f_getOrigin(self, originX, originY)

    def getSize(self, *args) -> "SbVec2f":
        r"""
        getSize(SbBox2f self, float & sizeX, float & sizeY)
        getSize(SbBox2f self) -> SbVec2f
        """
        return _coin.SbBox2f_getSize(self, *args)

    def getAspectRatio(self) -> "float":
        r"""getAspectRatio(SbBox2f self) -> float"""
        return _coin.SbBox2f_getAspectRatio(self)

    def __eq__(self, u: "SbBox2f") -> "int":
        r"""__eq__(SbBox2f self, SbBox2f u) -> int"""
        return _coin.SbBox2f___eq__(self, u)

    def __ne__(self, u: "SbBox2f") -> "int":
        r"""__ne__(SbBox2f self, SbBox2f u) -> int"""
        return _coin.SbBox2f___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox2f

# Register SbBox2f in _coin:
_coin.SbBox2f_swigregister(SbBox2f)

class SoSFBox2f(SoSField):
    r"""Proxy of C++ SoSFBox2f class."""

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

    def __init__(self):
        r"""__init__(SoSFBox2f self) -> SoSFBox2f"""
        _coin.SoSFBox2f_swiginit(self, _coin.new_SoSFBox2f())
    __swig_destroy__ = _coin.delete_SoSFBox2f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox2f self) -> SoType"""
        return _coin.SoSFBox2f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox2f self, SoField field)"""
        return _coin.SoSFBox2f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox2f self, SoField field) -> SbBool"""
        return _coin.SoSFBox2f_isSame(self, field)

    def __eq__(self, field: "SoSFBox2f") -> "int":
        r"""__eq__(SoSFBox2f self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___eq__(self, field)

    def __ne__(self, field: "SoSFBox2f") -> "int":
        r"""__ne__(SoSFBox2f self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox2f_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox2f self, SbBox2f newvalue)
        setValue(SoSFBox2f self, float xmin, float ymin, float xmax, float ymax)
        setValue(SoSFBox2f self, SbVec2f minvec, SbVec2f maxvec)
        """
        return _coin.SoSFBox2f_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox2f self) -> SbBox2f
        getValue(SoSFBox2f self, SbBox2f box)
        """
        return _coin.SoSFBox2f_getValue(self, *args)

# Register SoSFBox2f in _coin:
_coin.SoSFBox2f_swigregister(SoSFBox2f)

def SoSFBox2f_createInstance() -> "void *":
    r"""SoSFBox2f_createInstance() -> void *"""
    return _coin.SoSFBox2f_createInstance()

def SoSFBox2f_getClassTypeId() -> "SoType":
    r"""SoSFBox2f_getClassTypeId() -> SoType"""
    return _coin.SoSFBox2f_getClassTypeId()

def SoSFBox2f_initClass() -> "void":
    r"""SoSFBox2f_initClass()"""
    return _coin.SoSFBox2f_initClass()

class SbVec2d(object):
    r"""Proxy of C++ SbVec2d class."""

    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):
        r"""
        __init__(SbVec2d self) -> SbVec2d
        __init__(SbVec2d self, double const [2] v) -> SbVec2d
        __init__(SbVec2d self, double x, double y) -> SbVec2d
        __init__(SbVec2d self, SbVec2f v) -> SbVec2d
        __init__(SbVec2d self, SbVec2b v) -> SbVec2d
        __init__(SbVec2d self, SbVec2s v) -> SbVec2d
        __init__(SbVec2d self, SbVec2i32 v) -> SbVec2d
        """
        _coin.SbVec2d_swiginit(self, _coin.new_SbVec2d(*args))

    def setValue(self, *args) -> "SbVec2d &":
        r"""
        setValue(SbVec2d self, double const [2] v) -> SbVec2d
        setValue(SbVec2d self, double x, double y) -> SbVec2d
        setValue(SbVec2d self, SbVec2f v) -> SbVec2d
        setValue(SbVec2d self, SbVec2b v) -> SbVec2d
        setValue(SbVec2d self, SbVec2s v) -> SbVec2d
        setValue(SbVec2d self, SbVec2i32 v) -> SbVec2d
        """
        return _coin.SbVec2d_setValue(self, *args)

    def getValue(self) -> "void":
        r"""getValue(SbVec2d self)"""
        return _coin.SbVec2d_getValue(self)

    def equals(self, v: "SbVec2d", tolerance: "double") -> "SbBool":
        r"""equals(SbVec2d self, SbVec2d v, double tolerance) -> SbBool"""
        return _coin.SbVec2d_equals(self, v, tolerance)

    def dot(self, v: "SbVec2d") -> "double":
        r"""dot(SbVec2d self, SbVec2d v) -> double"""
        return _coin.SbVec2d_dot(self, v)

    def length(self) -> "double":
        r"""length(SbVec2d self) -> double"""
        return _coin.SbVec2d_length(self)

    def sqrLength(self) -> "double":
        r"""sqrLength(SbVec2d self) -> double"""
        return _coin.SbVec2d_sqrLength(self)

    def normalize(self) -> "double":
        r"""normalize(SbVec2d self) -> double"""
        return _coin.SbVec2d_normalize(self)

    def negate(self) -> "void":
        r"""negate(SbVec2d self)"""
        return _coin.SbVec2d_negate(self)

    def __imul__(self, d: "double") -> "SbVec2d &":
        r"""__imul__(SbVec2d self, double d) -> SbVec2d"""
        return _coin.SbVec2d___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec2d___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec2d") -> "SbVec2d &":
        r"""__iadd__(SbVec2d self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___iadd__(self, v)

    def __isub__(self, v: "SbVec2d") -> "SbVec2d &":
        r"""__isub__(SbVec2d self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___isub__(self, v)

    def __neg__(self) -> "SbVec2d":
        r"""__neg__(SbVec2d self) -> SbVec2d"""
        return _coin.SbVec2d___neg__(self)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec2d self, FILE * fp)"""
        return _coin.SbVec2d_output(self, fp)

    def __add__(self, u: "SbVec2d") -> "SbVec2d":
        r"""__add__(SbVec2d self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___add__(self, u)

    def __sub__(self, u: "SbVec2d") -> "SbVec2d":
        r"""__sub__(SbVec2d self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___sub__(self, u)

    def __mul__(self, d: "float const") -> "SbVec2d":
        r"""__mul__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___mul__(self, d)

    def __rmul__(self, d: "float const") -> "SbVec2d":
        r"""__rmul__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___rmul__(self, d)

    def __div__(self, d: "float const") -> "SbVec2d":
        r"""__div__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___div__(self, d)

    def __truediv__(self, d: "float const") -> "SbVec2d":
        r"""__truediv__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___truediv__(self, d)

    def __eq__(self, u: "SbVec2d") -> "int":
        r"""__eq__(SbVec2d self, SbVec2d u) -> int"""
        return _coin.SbVec2d___eq__(self, u)

    def __nq__(self, u: "SbVec2d") -> "int":
        r"""__nq__(SbVec2d self, SbVec2d u) -> int"""
        return _coin.SbVec2d___nq__(self, u)

    def __getitem__(self, i: "int") -> "double":
        r"""__getitem__(SbVec2d self, int i) -> double"""
        return _coin.SbVec2d___getitem__(self, i)

    def __setitem__(self, i: "int", value: "double") -> "void":
        r"""__setitem__(SbVec2d self, int i, double value)"""
        return _coin.SbVec2d___setitem__(self, i, value)

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

    def __len__(self):
          return 2

    __swig_destroy__ = _coin.delete_SbVec2d

# Register SbVec2d in _coin:
_coin.SbVec2d_swigregister(SbVec2d)

class SbBox2d(object):
    r"""Proxy of C++ SbBox2d class."""

    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):
        r"""
        __init__(SbBox2d self) -> SbBox2d
        __init__(SbBox2d self, double xmin, double ymin, double xmax, double ymax) -> SbBox2d
        __init__(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint) -> SbBox2d
        __init__(SbBox2d self, SbBox2f box) -> SbBox2d
        __init__(SbBox2d self, SbBox2s box) -> SbBox2d
        __init__(SbBox2d self, SbBox2i32 box) -> SbBox2d
        """
        _coin.SbBox2d_swiginit(self, _coin.new_SbBox2d(*args))

    def setBounds(self, *args) -> "SbBox2d &":
        r"""
        setBounds(SbBox2d self, double xmin, double ymin, double xmax, double ymax) -> SbBox2d
        setBounds(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint) -> SbBox2d
        setBounds(SbBox2d self, SbBox2f box) -> SbBox2d
        setBounds(SbBox2d self, SbBox2s box) -> SbBox2d
        setBounds(SbBox2d self, SbBox2i32 box) -> SbBox2d
        """
        return _coin.SbBox2d_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox2d self, double & xmin, double & ymin, double & xmax, double & ymax)
        getBounds(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint)
        """
        return _coin.SbBox2d_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec2d &":
        r"""
        getMin(SbBox2d self) -> SbVec2d
        getMin(SbBox2d self) -> SbVec2d
        """
        return _coin.SbBox2d_getMin(self, *args)

    def getMax(self, *args) -> "SbVec2d &":
        r"""
        getMax(SbBox2d self) -> SbVec2d
        getMax(SbBox2d self) -> SbVec2d
        """
        return _coin.SbBox2d_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox2d self, SbVec2d point)
        extendBy(SbBox2d self, SbBox2d box)
        """
        return _coin.SbBox2d_extendBy(self, *args)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox2d self)"""
        return _coin.SbBox2d_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox2d self) -> SbBool"""
        return _coin.SbBox2d_isEmpty(self)

    def hasArea(self) -> "SbBool":
        r"""hasArea(SbBox2d self) -> SbBool"""
        return _coin.SbBox2d_hasArea(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox2d self, SbVec2d point) -> SbBool
        intersect(SbBox2d self, SbBox2d box) -> SbBool
        """
        return _coin.SbBox2d_intersect(self, *args)

    def getClosestPoint(self, p: "SbVec2d") -> "SbVec2d":
        r"""getClosestPoint(SbBox2d self, SbVec2d p) -> SbVec2d"""
        return _coin.SbBox2d_getClosestPoint(self, p)

    def findIntersection(self, a: "SbVec2d", b: "SbVec2d", ia: "SbVec2d", ib: "SbVec2d") -> "SbBool":
        r"""findIntersection(SbBox2d self, SbVec2d a, SbVec2d b, SbVec2d ia, SbVec2d ib) -> SbBool"""
        return _coin.SbBox2d_findIntersection(self, a, b, ia, ib)

    def getCenter(self) -> "SbVec2d":
        r"""getCenter(SbBox2d self) -> SbVec2d"""
        return _coin.SbBox2d_getCenter(self)

    def getOrigin(self, originX: "double &", originY: "double &") -> "void":
        r"""getOrigin(SbBox2d self, double & originX, double & originY)"""
        return _coin.SbBox2d_getOrigin(self, originX, originY)

    def getSize(self, *args) -> "SbVec2d":
        r"""
        getSize(SbBox2d self, double & sizeX, double & sizeY)
        getSize(SbBox2d self) -> SbVec2d
        """
        return _coin.SbBox2d_getSize(self, *args)

    def getAspectRatio(self) -> "double":
        r"""getAspectRatio(SbBox2d self) -> double"""
        return _coin.SbBox2d_getAspectRatio(self)

    def __eq__(self, u: "SbBox2d") -> "int":
        r"""__eq__(SbBox2d self, SbBox2d u) -> int"""
        return _coin.SbBox2d___eq__(self, u)

    def __ne__(self, u: "SbBox2d") -> "int":
        r"""__ne__(SbBox2d self, SbBox2d u) -> int"""
        return _coin.SbBox2d___ne__(self, u)

    def setValue(self, u: "SbBox2d") -> "SbBox2d &":
        r"""setValue(SbBox2d self, SbBox2d u) -> SbBox2d"""
        return _coin.SbBox2d_setValue(self, u)
    __swig_destroy__ = _coin.delete_SbBox2d

# Register SbBox2d in _coin:
_coin.SbBox2d_swigregister(SbBox2d)

class SoSFBox2d(SoSField):
    r"""Proxy of C++ SoSFBox2d class."""

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

    def __init__(self):
        r"""__init__(SoSFBox2d self) -> SoSFBox2d"""
        _coin.SoSFBox2d_swiginit(self, _coin.new_SoSFBox2d())
    __swig_destroy__ = _coin.delete_SoSFBox2d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox2d self) -> SoType"""
        return _coin.SoSFBox2d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox2d self, SoField field)"""
        return _coin.SoSFBox2d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox2d self, SoField field) -> SbBool"""
        return _coin.SoSFBox2d_isSame(self, field)

    def __eq__(self, field: "SoSFBox2d") -> "int":
        r"""__eq__(SoSFBox2d self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___eq__(self, field)

    def __ne__(self, field: "SoSFBox2d") -> "int":
        r"""__ne__(SoSFBox2d self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox2d_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox2d self, SbBox2d newvalue)
        setValue(SoSFBox2d self, double xmin, double ymin, double xmax, double ymax)
        setValue(SoSFBox2d self, SbVec2d minvec, SbVec2d maxvec)
        """
        return _coin.SoSFBox2d_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox2d self) -> SbBox2d
        getValue(SoSFBox2d self, SbBox2d box)
        """
        return _coin.SoSFBox2d_getValue(self, *args)

# Register SoSFBox2d in _coin:
_coin.SoSFBox2d_swigregister(SoSFBox2d)

def SoSFBox2d_createInstance() -> "void *":
    r"""SoSFBox2d_createInstance() -> void *"""
    return _coin.SoSFBox2d_createInstance()

def SoSFBox2d_getClassTypeId() -> "SoType":
    r"""SoSFBox2d_getClassTypeId() -> SoType"""
    return _coin.SoSFBox2d_getClassTypeId()

def SoSFBox2d_initClass() -> "void":
    r"""SoSFBox2d_initClass()"""
    return _coin.SoSFBox2d_initClass()

class SbBox3s(object):
    r"""Proxy of C++ SbBox3s class."""

    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):
        r"""
        __init__(SbBox3s self) -> SbBox3s
        __init__(SbBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax) -> SbBox3s
        __init__(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint) -> SbBox3s
        __init__(SbBox3s self, SbBox3i32 box) -> SbBox3s
        __init__(SbBox3s self, SbBox3f box) -> SbBox3s
        __init__(SbBox3s self, SbBox3d box) -> SbBox3s
        """
        _coin.SbBox3s_swiginit(self, _coin.new_SbBox3s(*args))

    def setBounds(self, *args) -> "SbBox3s &":
        r"""
        setBounds(SbBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax) -> SbBox3s
        setBounds(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint) -> SbBox3s
        setBounds(SbBox3s self, SbBox3i32 box) -> SbBox3s
        setBounds(SbBox3s self, SbBox3f box) -> SbBox3s
        setBounds(SbBox3s self, SbBox3d box) -> SbBox3s
        """
        return _coin.SbBox3s_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox3s self, short & xmin, short & ymin, short & zmin, short & xmax, short & ymax, short & zmax)
        getBounds(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint)
        """
        return _coin.SbBox3s_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec3s &":
        r"""
        getMin(SbBox3s self) -> SbVec3s
        getMin(SbBox3s self) -> SbVec3s
        """
        return _coin.SbBox3s_getMin(self, *args)

    def getMax(self, *args) -> "SbVec3s &":
        r"""
        getMax(SbBox3s self) -> SbVec3s
        getMax(SbBox3s self) -> SbVec3s
        """
        return _coin.SbBox3s_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox3s self, SbVec3s pt)
        extendBy(SbBox3s self, SbBox3s box)
        """
        return _coin.SbBox3s_extendBy(self, *args)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox3s self)"""
        return _coin.SbBox3s_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox3s self) -> SbBool"""
        return _coin.SbBox3s_isEmpty(self)

    def hasVolume(self) -> "SbBool":
        r"""hasVolume(SbBox3s self) -> SbBool"""
        return _coin.SbBox3s_hasVolume(self)

    def getVolume(self) -> "int":
        r"""getVolume(SbBox3s self) -> int"""
        return _coin.SbBox3s_getVolume(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox3s self, SbVec3s pt) -> SbBool
        intersect(SbBox3s self, SbBox3s box) -> SbBool
        """
        return _coin.SbBox3s_intersect(self, *args)

    def getClosestPoint(self, pt: "SbVec3f") -> "SbVec3f":
        r"""getClosestPoint(SbBox3s self, SbVec3f pt) -> SbVec3f"""
        return _coin.SbBox3s_getClosestPoint(self, pt)

    def getCenter(self) -> "SbVec3f":
        r"""getCenter(SbBox3s self) -> SbVec3f"""
        return _coin.SbBox3s_getCenter(self)

    def getOrigin(self, originX: "short &", originY: "short &", originZ: "short &") -> "void":
        r"""getOrigin(SbBox3s self, short & originX, short & originY, short & originZ)"""
        return _coin.SbBox3s_getOrigin(self, originX, originY, originZ)

    def getSize(self, *args) -> "SbVec3s":
        r"""
        getSize(SbBox3s self, short & sizeX, short & sizeY, short & sizeZ)
        getSize(SbBox3s self) -> SbVec3s
        """
        return _coin.SbBox3s_getSize(self, *args)

    def __eq__(self, u: "SbBox3s") -> "int":
        r"""__eq__(SbBox3s self, SbBox3s u) -> int"""
        return _coin.SbBox3s___eq__(self, u)

    def __ne__(self, u: "SbBox3s") -> "int":
        r"""__ne__(SbBox3s self, SbBox3s u) -> int"""
        return _coin.SbBox3s___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox3s

# Register SbBox3s in _coin:
_coin.SbBox3s_swigregister(SbBox3s)

class SoSFBox3s(SoSField):
    r"""Proxy of C++ SoSFBox3s class."""

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

    def __init__(self):
        r"""__init__(SoSFBox3s self) -> SoSFBox3s"""
        _coin.SoSFBox3s_swiginit(self, _coin.new_SoSFBox3s())
    __swig_destroy__ = _coin.delete_SoSFBox3s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox3s self) -> SoType"""
        return _coin.SoSFBox3s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox3s self, SoField field)"""
        return _coin.SoSFBox3s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox3s self, SoField field) -> SbBool"""
        return _coin.SoSFBox3s_isSame(self, field)

    def __eq__(self, field: "SoSFBox3s") -> "int":
        r"""__eq__(SoSFBox3s self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___eq__(self, field)

    def __ne__(self, field: "SoSFBox3s") -> "int":
        r"""__ne__(SoSFBox3s self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox3s_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox3s self, SbBox3s newvalue)
        setValue(SoSFBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax)
        setValue(SoSFBox3s self, SbVec3s minvec, SbVec3s maxvec)
        """
        return _coin.SoSFBox3s_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox3s self) -> SbBox3s
        getValue(SoSFBox3s self, SbBox3s box)
        """
        return _coin.SoSFBox3s_getValue(self, *args)

# Register SoSFBox3s in _coin:
_coin.SoSFBox3s_swigregister(SoSFBox3s)

def SoSFBox3s_createInstance() -> "void *":
    r"""SoSFBox3s_createInstance() -> void *"""
    return _coin.SoSFBox3s_createInstance()

def SoSFBox3s_getClassTypeId() -> "SoType":
    r"""SoSFBox3s_getClassTypeId() -> SoType"""
    return _coin.SoSFBox3s_getClassTypeId()

def SoSFBox3s_initClass() -> "void":
    r"""SoSFBox3s_initClass()"""
    return _coin.SoSFBox3s_initClass()

class SbVec3i32(object):
    r"""Proxy of C++ SbVec3i32 class."""

    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):
        r"""
        __init__(SbVec3i32 self) -> SbVec3i32
        __init__(SbVec3i32 self, int32_t const [3] v) -> SbVec3i32
        __init__(SbVec3i32 self, int32_t x, int32_t y, int32_t z) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3ui32 const & v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3b v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3s v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3f v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3d v) -> SbVec3i32
        """
        _coin.SbVec3i32_swiginit(self, _coin.new_SbVec3i32(*args))

    def setValue(self, *args) -> "SbVec3i32 &":
        r"""
        setValue(SbVec3i32 self, int32_t const [3] v) -> SbVec3i32
        setValue(SbVec3i32 self, int32_t x, int32_t y, int32_t z) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3ui32 const & v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3b v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3s v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3f v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3d v) -> SbVec3i32
        """
        return _coin.SbVec3i32_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec3i32 self) -> int32_t const
        getValue(SbVec3i32 self, int32_t & x, int32_t & y, int32_t & z)
        """
        return _coin.SbVec3i32_getValue(self, *args)

    def dot(self, v: "SbVec3i32") -> "int32_t":
        r"""dot(SbVec3i32 self, SbVec3i32 v) -> int32_t"""
        return _coin.SbVec3i32_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec3i32 self)"""
        return _coin.SbVec3i32_negate(self)

    def __imul__(self, *args) -> "SbVec3i32 &":
        r"""
        __imul__(SbVec3i32 self, int d) -> SbVec3i32
        __imul__(SbVec3i32 self, double d) -> SbVec3i32
        """
        return _coin.SbVec3i32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec3i32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec3i32") -> "SbVec3i32 &":
        r"""__iadd__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___iadd__(self, v)

    def __isub__(self, v: "SbVec3i32") -> "SbVec3i32 &":
        r"""__isub__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___isub__(self, v)

    def __neg__(self) -> "SbVec3i32":
        r"""__neg__(SbVec3i32 self) -> SbVec3i32"""
        return _coin.SbVec3i32___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec3i32

# Register SbVec3i32 in _coin:
_coin.SbVec3i32_swigregister(SbVec3i32)

class SbBox3i32(object):
    r"""Proxy of C++ SbBox3i32 class."""

    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):
        r"""
        __init__(SbBox3i32 self) -> SbBox3i32
        __init__(SbBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax) -> SbBox3i32
        __init__(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint) -> SbBox3i32
        __init__(SbBox3i32 self, SbBox3s box) -> SbBox3i32
        __init__(SbBox3i32 self, SbBox3f box) -> SbBox3i32
        __init__(SbBox3i32 self, SbBox3d box) -> SbBox3i32
        """
        _coin.SbBox3i32_swiginit(self, _coin.new_SbBox3i32(*args))

    def setBounds(self, *args) -> "SbBox3i32 &":
        r"""
        setBounds(SbBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax) -> SbBox3i32
        setBounds(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint) -> SbBox3i32
        setBounds(SbBox3i32 self, SbBox3s box) -> SbBox3i32
        setBounds(SbBox3i32 self, SbBox3f box) -> SbBox3i32
        setBounds(SbBox3i32 self, SbBox3d box) -> SbBox3i32
        """
        return _coin.SbBox3i32_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox3i32 self, int32_t & xmin, int32_t & ymin, int32_t & zmin, int32_t & xmax, int32_t & ymax, int32_t & zmax)
        getBounds(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint)
        """
        return _coin.SbBox3i32_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec3i32 &":
        r"""
        getMin(SbBox3i32 self) -> SbVec3i32
        getMin(SbBox3i32 self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMin(self, *args)

    def getMax(self, *args) -> "SbVec3i32 &":
        r"""
        getMax(SbBox3i32 self) -> SbVec3i32
        getMax(SbBox3i32 self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox3i32 self, SbVec3i32 point)
        extendBy(SbBox3i32 self, SbBox3i32 box)
        extendBy(SbBox3i32 self, SbVec3f point)
        """
        return _coin.SbBox3i32_extendBy(self, *args)

    def transform(self, m: "SbMatrix") -> "void":
        r"""transform(SbBox3i32 self, SbMatrix m)"""
        return _coin.SbBox3i32_transform(self, m)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox3i32 self)"""
        return _coin.SbBox3i32_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox3i32 self) -> SbBool"""
        return _coin.SbBox3i32_isEmpty(self)

    def hasVolume(self) -> "SbBool":
        r"""hasVolume(SbBox3i32 self) -> SbBool"""
        return _coin.SbBox3i32_hasVolume(self)

    def getVolume(self) -> "float":
        r"""getVolume(SbBox3i32 self) -> float"""
        return _coin.SbBox3i32_getVolume(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox3i32 self, SbVec3i32 point) -> SbBool
        intersect(SbBox3i32 self, SbBox3i32 box) -> SbBool
        intersect(SbBox3i32 self, SbVec3f point) -> SbBool
        """
        return _coin.SbBox3i32_intersect(self, *args)

    def outside(self, mvp: "SbMatrix", cullBits: "int &") -> "SbBool":
        r"""outside(SbBox3i32 self, SbMatrix mvp, int & cullBits) -> SbBool"""
        return _coin.SbBox3i32_outside(self, mvp, cullBits)

    def getClosestPoint(self, point: "SbVec3f") -> "SbVec3f":
        r"""getClosestPoint(SbBox3i32 self, SbVec3f point) -> SbVec3f"""
        return _coin.SbBox3i32_getClosestPoint(self, point)

    def getCenter(self) -> "SbVec3f":
        r"""getCenter(SbBox3i32 self) -> SbVec3f"""
        return _coin.SbBox3i32_getCenter(self)

    def getOrigin(self, originX: "int32_t &", originY: "int32_t &", originZ: "int32_t &") -> "void":
        r"""getOrigin(SbBox3i32 self, int32_t & originX, int32_t & originY, int32_t & originZ)"""
        return _coin.SbBox3i32_getOrigin(self, originX, originY, originZ)

    def getSize(self, *args) -> "SbVec3i32":
        r"""
        getSize(SbBox3i32 self, int32_t & sizeX, int32_t & sizeY, int32_t & sizeZ)
        getSize(SbBox3i32 self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getSize(self, *args)

    def getSpan(self, direction: "SbVec3f", dmin: "float &", dmax: "float &") -> "void":
        r"""getSpan(SbBox3i32 self, SbVec3f direction, float & dmin, float & dmax)"""
        return _coin.SbBox3i32_getSpan(self, direction, dmin, dmax)
    __swig_destroy__ = _coin.delete_SbBox3i32

# Register SbBox3i32 in _coin:
_coin.SbBox3i32_swigregister(SbBox3i32)

class SoSFBox3i32(SoSField):
    r"""Proxy of C++ SoSFBox3i32 class."""

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

    def __init__(self):
        r"""__init__(SoSFBox3i32 self) -> SoSFBox3i32"""
        _coin.SoSFBox3i32_swiginit(self, _coin.new_SoSFBox3i32())
    __swig_destroy__ = _coin.delete_SoSFBox3i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox3i32 self) -> SoType"""
        return _coin.SoSFBox3i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox3i32 self, SoField field)"""
        return _coin.SoSFBox3i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox3i32 self, SoField field) -> SbBool"""
        return _coin.SoSFBox3i32_isSame(self, field)

    def __eq__(self, field: "SoSFBox3i32") -> "int":
        r"""__eq__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___eq__(self, field)

    def __ne__(self, field: "SoSFBox3i32") -> "int":
        r"""__ne__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox3i32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox3i32 self, SbBox3i32 newvalue)
        setValue(SoSFBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax)
        setValue(SoSFBox3i32 self, SbVec3i32 minvec, SbVec3i32 maxvec)
        """
        return _coin.SoSFBox3i32_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox3i32 self) -> SbBox3i32
        getValue(SoSFBox3i32 self, SbBox3i32 box)
        """
        return _coin.SoSFBox3i32_getValue(self, *args)

# Register SoSFBox3i32 in _coin:
_coin.SoSFBox3i32_swigregister(SoSFBox3i32)

def SoSFBox3i32_createInstance() -> "void *":
    r"""SoSFBox3i32_createInstance() -> void *"""
    return _coin.SoSFBox3i32_createInstance()

def SoSFBox3i32_getClassTypeId() -> "SoType":
    r"""SoSFBox3i32_getClassTypeId() -> SoType"""
    return _coin.SoSFBox3i32_getClassTypeId()

def SoSFBox3i32_initClass() -> "void":
    r"""SoSFBox3i32_initClass()"""
    return _coin.SoSFBox3i32_initClass()

class SoSFBox3f(SoSField):
    r"""Proxy of C++ SoSFBox3f class."""

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

    def __init__(self):
        r"""__init__(SoSFBox3f self) -> SoSFBox3f"""
        _coin.SoSFBox3f_swiginit(self, _coin.new_SoSFBox3f())
    __swig_destroy__ = _coin.delete_SoSFBox3f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox3f self) -> SoType"""
        return _coin.SoSFBox3f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox3f self, SoField field)"""
        return _coin.SoSFBox3f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox3f self, SoField field) -> SbBool"""
        return _coin.SoSFBox3f_isSame(self, field)

    def __eq__(self, field: "SoSFBox3f") -> "int":
        r"""__eq__(SoSFBox3f self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___eq__(self, field)

    def __ne__(self, field: "SoSFBox3f") -> "int":
        r"""__ne__(SoSFBox3f self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox3f_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox3f self, SbBox3f newvalue)
        setValue(SoSFBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax)
        setValue(SoSFBox3f self, SbVec3f minvec, SbVec3f maxvec)
        """
        return _coin.SoSFBox3f_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox3f self) -> SbBox3f
        getValue(SoSFBox3f self, SbBox3f box)
        """
        return _coin.SoSFBox3f_getValue(self, *args)

# Register SoSFBox3f in _coin:
_coin.SoSFBox3f_swigregister(SoSFBox3f)

def SoSFBox3f_createInstance() -> "void *":
    r"""SoSFBox3f_createInstance() -> void *"""
    return _coin.SoSFBox3f_createInstance()

def SoSFBox3f_getClassTypeId() -> "SoType":
    r"""SoSFBox3f_getClassTypeId() -> SoType"""
    return _coin.SoSFBox3f_getClassTypeId()

def SoSFBox3f_initClass() -> "void":
    r"""SoSFBox3f_initClass()"""
    return _coin.SoSFBox3f_initClass()

class SbBox3d(object):
    r"""Proxy of C++ SbBox3d class."""

    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):
        r"""
        __init__(SbBox3d self) -> SbBox3d
        __init__(SbBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax) -> SbBox3d
        __init__(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint) -> SbBox3d
        __init__(SbBox3d self, SbBox3f box) -> SbBox3d
        __init__(SbBox3d self, SbBox3s box) -> SbBox3d
        __init__(SbBox3d self, SbBox3i32 box) -> SbBox3d
        """
        _coin.SbBox3d_swiginit(self, _coin.new_SbBox3d(*args))

    def setBounds(self, *args) -> "SbBox3d &":
        r"""
        setBounds(SbBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax) -> SbBox3d
        setBounds(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint) -> SbBox3d
        setBounds(SbBox3d self, SbBox3f box) -> SbBox3d
        setBounds(SbBox3d self, SbBox3s box) -> SbBox3d
        setBounds(SbBox3d self, SbBox3i32 box) -> SbBox3d
        """
        return _coin.SbBox3d_setBounds(self, *args)

    def getBounds(self, *args) -> "void":
        r"""
        getBounds(SbBox3d self, double & xmin, double & ymin, double & zmin, double & xmax, double & ymax, double & zmax)
        getBounds(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint)
        """
        return _coin.SbBox3d_getBounds(self, *args)

    def getMin(self, *args) -> "SbVec3d &":
        r"""
        getMin(SbBox3d self) -> SbVec3d
        getMin(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getMin(self, *args)

    def getMax(self, *args) -> "SbVec3d &":
        r"""
        getMax(SbBox3d self) -> SbVec3d
        getMax(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getMax(self, *args)

    def extendBy(self, *args) -> "void":
        r"""
        extendBy(SbBox3d self, SbVec3d pt)
        extendBy(SbBox3d self, SbBox3d box)
        """
        return _coin.SbBox3d_extendBy(self, *args)

    def transform(self, matrix: "SbDPMatrix") -> "void":
        r"""transform(SbBox3d self, SbDPMatrix matrix)"""
        return _coin.SbBox3d_transform(self, matrix)

    def makeEmpty(self) -> "void":
        r"""makeEmpty(SbBox3d self)"""
        return _coin.SbBox3d_makeEmpty(self)

    def isEmpty(self) -> "SbBool":
        r"""isEmpty(SbBox3d self) -> SbBool"""
        return _coin.SbBox3d_isEmpty(self)

    def hasVolume(self) -> "SbBool":
        r"""hasVolume(SbBox3d self) -> SbBool"""
        return _coin.SbBox3d_hasVolume(self)

    def getVolume(self) -> "double":
        r"""getVolume(SbBox3d self) -> double"""
        return _coin.SbBox3d_getVolume(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbBox3d self, SbVec3d point) -> SbBool
        intersect(SbBox3d self, SbBox3d box) -> SbBool
        """
        return _coin.SbBox3d_intersect(self, *args)

    def getClosestPoint(self, point: "SbVec3d") -> "SbVec3d":
        r"""getClosestPoint(SbBox3d self, SbVec3d point) -> SbVec3d"""
        return _coin.SbBox3d_getClosestPoint(self, point)

    def outside(self, mvp: "SbDPMatrix", cullbits: "int &") -> "SbBool":
        r"""outside(SbBox3d self, SbDPMatrix mvp, int & cullbits) -> SbBool"""
        return _coin.SbBox3d_outside(self, mvp, cullbits)

    def getCenter(self) -> "SbVec3d":
        r"""getCenter(SbBox3d self) -> SbVec3d"""
        return _coin.SbBox3d_getCenter(self)

    def getOrigin(self, origoX: "double &", origoY: "double &", origoZ: "double &") -> "void":
        r"""getOrigin(SbBox3d self, double & origoX, double & origoY, double & origoZ)"""
        return _coin.SbBox3d_getOrigin(self, origoX, origoY, origoZ)

    def getSize(self, *args) -> "SbVec3d":
        r"""
        getSize(SbBox3d self, double & sizeX, double & sizeY, double & sizeZ)
        getSize(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getSize(self, *args)

    def getSpan(self, dir: "SbVec3d", dmin: "double &", dmax: "double &") -> "void":
        r"""getSpan(SbBox3d self, SbVec3d dir, double & dmin, double & dmax)"""
        return _coin.SbBox3d_getSpan(self, dir, dmin, dmax)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbBox3d self, FILE * file)"""
        return _coin.SbBox3d_output(self, file)
    __swig_destroy__ = _coin.delete_SbBox3d

# Register SbBox3d in _coin:
_coin.SbBox3d_swigregister(SbBox3d)

class SoSFBox3d(SoSField):
    r"""Proxy of C++ SoSFBox3d class."""

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

    def __init__(self):
        r"""__init__(SoSFBox3d self) -> SoSFBox3d"""
        _coin.SoSFBox3d_swiginit(self, _coin.new_SoSFBox3d())
    __swig_destroy__ = _coin.delete_SoSFBox3d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFBox3d self) -> SoType"""
        return _coin.SoSFBox3d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFBox3d self, SoField field)"""
        return _coin.SoSFBox3d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFBox3d self, SoField field) -> SbBool"""
        return _coin.SoSFBox3d_isSame(self, field)

    def __eq__(self, field: "SoSFBox3d") -> "int":
        r"""__eq__(SoSFBox3d self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___eq__(self, field)

    def __ne__(self, field: "SoSFBox3d") -> "int":
        r"""__ne__(SoSFBox3d self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFBox3d_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFBox3d self, SbBox3d newvalue)
        setValue(SoSFBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax)
        setValue(SoSFBox3d self, SbVec3d minvec, SbVec3d maxvec)
        """
        return _coin.SoSFBox3d_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SoSFBox3d self) -> SbBox3d
        getValue(SoSFBox3d self, SbBox3d box)
        """
        return _coin.SoSFBox3d_getValue(self, *args)

# Register SoSFBox3d in _coin:
_coin.SoSFBox3d_swigregister(SoSFBox3d)

def SoSFBox3d_createInstance() -> "void *":
    r"""SoSFBox3d_createInstance() -> void *"""
    return _coin.SoSFBox3d_createInstance()

def SoSFBox3d_getClassTypeId() -> "SoType":
    r"""SoSFBox3d_getClassTypeId() -> SoType"""
    return _coin.SoSFBox3d_getClassTypeId()

def SoSFBox3d_initClass() -> "void":
    r"""SoSFBox3d_initClass()"""
    return _coin.SoSFBox3d_initClass()

class SoSFColorRGBA(SoSField):
    r"""Proxy of C++ SoSFColorRGBA class."""

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

    def __init__(self):
        r"""__init__(SoSFColorRGBA self) -> SoSFColorRGBA"""
        _coin.SoSFColorRGBA_swiginit(self, _coin.new_SoSFColorRGBA())
    __swig_destroy__ = _coin.delete_SoSFColorRGBA

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFColorRGBA_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFColorRGBA_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFColorRGBA self) -> SoType"""
        return _coin.SoSFColorRGBA_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFColorRGBA self, SoField field)"""
        return _coin.SoSFColorRGBA_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFColorRGBA self, SoField field) -> SbBool"""
        return _coin.SoSFColorRGBA_isSame(self, field)

    def getValue(self) -> "SbColor4f const &":
        r"""getValue(SoSFColorRGBA self) -> SbColor4f"""
        return _coin.SoSFColorRGBA_getValue(self)

    def __eq__(self, field: "SoSFColorRGBA") -> "int":
        r"""__eq__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___eq__(self, field)

    def __ne__(self, field: "SoSFColorRGBA") -> "int":
        r"""__ne__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFColorRGBA_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFColorRGBA self, SbColor4f newvalue)
        setValue(SoSFColorRGBA self, SbVec4f vec)
        setValue(SoSFColorRGBA self, float red, float green, float blue, float alpha)
        setValue(SoSFColorRGBA self, float const [4] rgba)
        """
        return _coin.SoSFColorRGBA_setValue(self, *args)

    def setHSVValue(self, *args) -> "void":
        r"""
        setHSVValue(SoSFColorRGBA self, float h, float s, float v, float a)
        setHSVValue(SoSFColorRGBA self, float const [4] hsva)
        """
        return _coin.SoSFColorRGBA_setHSVValue(self, *args)

# Register SoSFColorRGBA in _coin:
_coin.SoSFColorRGBA_swigregister(SoSFColorRGBA)

def SoSFColorRGBA_createInstance() -> "void *":
    r"""SoSFColorRGBA_createInstance() -> void *"""
    return _coin.SoSFColorRGBA_createInstance()

def SoSFColorRGBA_getClassTypeId() -> "SoType":
    r"""SoSFColorRGBA_getClassTypeId() -> SoType"""
    return _coin.SoSFColorRGBA_getClassTypeId()

def SoSFColorRGBA_initClass() -> "void":
    r"""SoSFColorRGBA_initClass()"""
    return _coin.SoSFColorRGBA_initClass()

class SoSFDouble(SoSField):
    r"""Proxy of C++ SoSFDouble class."""

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

    def __init__(self):
        r"""__init__(SoSFDouble self) -> SoSFDouble"""
        _coin.SoSFDouble_swiginit(self, _coin.new_SoSFDouble())
    __swig_destroy__ = _coin.delete_SoSFDouble

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFDouble_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFDouble_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFDouble self) -> SoType"""
        return _coin.SoSFDouble_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFDouble self, SoField field)"""
        return _coin.SoSFDouble_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFDouble self, SoField field) -> SbBool"""
        return _coin.SoSFDouble_isSame(self, field)

    def getValue(self) -> "double":
        r"""getValue(SoSFDouble self) -> double"""
        return _coin.SoSFDouble_getValue(self)

    def setValue(self, newvalue: "double") -> "void":
        r"""setValue(SoSFDouble self, double newvalue)"""
        return _coin.SoSFDouble_setValue(self, newvalue)

    def __eq__(self, field: "SoSFDouble") -> "int":
        r"""__eq__(SoSFDouble self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___eq__(self, field)

    def __ne__(self, field: "SoSFDouble") -> "int":
        r"""__ne__(SoSFDouble self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFDouble_initClass()

# Register SoSFDouble in _coin:
_coin.SoSFDouble_swigregister(SoSFDouble)

def SoSFDouble_createInstance() -> "void *":
    r"""SoSFDouble_createInstance() -> void *"""
    return _coin.SoSFDouble_createInstance()

def SoSFDouble_getClassTypeId() -> "SoType":
    r"""SoSFDouble_getClassTypeId() -> SoType"""
    return _coin.SoSFDouble_getClassTypeId()

def SoSFDouble_initClass() -> "void":
    r"""SoSFDouble_initClass()"""
    return _coin.SoSFDouble_initClass()

class SoSFEngine(SoSField):
    r"""Proxy of C++ SoSFEngine class."""

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

    def __init__(self):
        r"""__init__(SoSFEngine self) -> SoSFEngine"""
        _coin.SoSFEngine_swiginit(self, _coin.new_SoSFEngine())
    __swig_destroy__ = _coin.delete_SoSFEngine

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFEngine_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFEngine_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFEngine self) -> SoType"""
        return _coin.SoSFEngine_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFEngine self, SoField field)"""
        return _coin.SoSFEngine_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFEngine self, SoField field) -> SbBool"""
        return _coin.SoSFEngine_isSame(self, field)

    def getValue(self) -> "SoEngine *":
        r"""getValue(SoSFEngine self) -> SoEngine"""
        return _coin.SoSFEngine_getValue(self)

    def __eq__(self, field: "SoSFEngine") -> "int":
        r"""__eq__(SoSFEngine self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___eq__(self, field)

    def __ne__(self, field: "SoSFEngine") -> "int":
        r"""__ne__(SoSFEngine self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFEngine_initClass()

    def fixCopy(self, copyconnections: "SbBool") -> "void":
        r"""fixCopy(SoSFEngine self, SbBool copyconnections)"""
        return _coin.SoSFEngine_fixCopy(self, copyconnections)

    def referencesCopy(self) -> "SbBool":
        r"""referencesCopy(SoSFEngine self) -> SbBool"""
        return _coin.SoSFEngine_referencesCopy(self)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFEngine self, SoEngine newvalue)
        setValue(SoSFEngine self, SoSFEngine other)
        """
        return _coin.SoSFEngine_setValue(self, *args)

# Register SoSFEngine in _coin:
_coin.SoSFEngine_swigregister(SoSFEngine)

def SoSFEngine_createInstance() -> "void *":
    r"""SoSFEngine_createInstance() -> void *"""
    return _coin.SoSFEngine_createInstance()

def SoSFEngine_getClassTypeId() -> "SoType":
    r"""SoSFEngine_getClassTypeId() -> SoType"""
    return _coin.SoSFEngine_getClassTypeId()

def SoSFEngine_initClass() -> "void":
    r"""SoSFEngine_initClass()"""
    return _coin.SoSFEngine_initClass()

class SoSFImage3(SoSField):
    r"""Proxy of C++ SoSFImage3 class."""

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

    def __init__(self):
        r"""__init__(SoSFImage3 self) -> SoSFImage3"""
        _coin.SoSFImage3_swiginit(self, _coin.new_SoSFImage3())
    __swig_destroy__ = _coin.delete_SoSFImage3

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFImage3_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFImage3_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFImage3 self) -> SoType"""
        return _coin.SoSFImage3_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFImage3 self, SoField field)"""
        return _coin.SoSFImage3_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFImage3 self, SoField field) -> SbBool"""
        return _coin.SoSFImage3_isSame(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFImage3_initClass()

    def getValue(self) -> "unsigned char const *":
        r"""getValue(SoSFImage3 self) -> unsigned char const *"""
        return _coin.SoSFImage3_getValue(self)

    def __eq__(self, field: "SoSFImage3") -> "int":
        r"""__eq__(SoSFImage3 self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___eq__(self, field)

    def __ne__(self, field: "SoSFImage3") -> "int":
        r"""__ne__(SoSFImage3 self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___ne__(self, field)

    def startEditing(self) -> "unsigned char *":
        r"""startEditing(SoSFImage3 self) -> unsigned char *"""
        return _coin.SoSFImage3_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoSFImage3 self)"""
        return _coin.SoSFImage3_finishEditing(self)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFImage3 self, SbVec3s size, int const nc, unsigned char const * bytes)
        setValue(SoSFImage3 self, SbVec3s size, int const nc, PyObject * pixels)
        setValue(SoSFImage3 self, SoSFImage3 other)
        """
        return _coin.SoSFImage3_setValue(self, *args)

# Register SoSFImage3 in _coin:
_coin.SoSFImage3_swigregister(SoSFImage3)

def SoSFImage3_createInstance() -> "void *":
    r"""SoSFImage3_createInstance() -> void *"""
    return _coin.SoSFImage3_createInstance()

def SoSFImage3_getClassTypeId() -> "SoType":
    r"""SoSFImage3_getClassTypeId() -> SoType"""
    return _coin.SoSFImage3_getClassTypeId()

def SoSFImage3_initClass() -> "void":
    r"""SoSFImage3_initClass()"""
    return _coin.SoSFImage3_initClass()

class SoSFMatrix(SoSField):
    r"""Proxy of C++ SoSFMatrix class."""

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

    def __init__(self):
        r"""__init__(SoSFMatrix self) -> SoSFMatrix"""
        _coin.SoSFMatrix_swiginit(self, _coin.new_SoSFMatrix())
    __swig_destroy__ = _coin.delete_SoSFMatrix

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFMatrix_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFMatrix_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFMatrix self) -> SoType"""
        return _coin.SoSFMatrix_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFMatrix self, SoField field)"""
        return _coin.SoSFMatrix_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFMatrix self, SoField field) -> SbBool"""
        return _coin.SoSFMatrix_isSame(self, field)

    def getValue(self) -> "SbMatrix const &":
        r"""getValue(SoSFMatrix self) -> SbMatrix"""
        return _coin.SoSFMatrix_getValue(self)

    def __eq__(self, field: "SoSFMatrix") -> "int":
        r"""__eq__(SoSFMatrix self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___eq__(self, field)

    def __ne__(self, field: "SoSFMatrix") -> "int":
        r"""__ne__(SoSFMatrix self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFMatrix_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFMatrix self, SbMatrix newvalue)
        setValue(SoSFMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44)
        setValue(SoSFMatrix self, SoSFMatrix other)
        """
        return _coin.SoSFMatrix_setValue(self, *args)

# Register SoSFMatrix in _coin:
_coin.SoSFMatrix_swigregister(SoSFMatrix)

def SoSFMatrix_createInstance() -> "void *":
    r"""SoSFMatrix_createInstance() -> void *"""
    return _coin.SoSFMatrix_createInstance()

def SoSFMatrix_getClassTypeId() -> "SoType":
    r"""SoSFMatrix_getClassTypeId() -> SoType"""
    return _coin.SoSFMatrix_getClassTypeId()

def SoSFMatrix_initClass() -> "void":
    r"""SoSFMatrix_initClass()"""
    return _coin.SoSFMatrix_initClass()

class SoSFPlane(SoSField):
    r"""Proxy of C++ SoSFPlane class."""

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

    def __init__(self):
        r"""__init__(SoSFPlane self) -> SoSFPlane"""
        _coin.SoSFPlane_swiginit(self, _coin.new_SoSFPlane())
    __swig_destroy__ = _coin.delete_SoSFPlane

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFPlane_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFPlane_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFPlane self) -> SoType"""
        return _coin.SoSFPlane_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFPlane self, SoField field)"""
        return _coin.SoSFPlane_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFPlane self, SoField field) -> SbBool"""
        return _coin.SoSFPlane_isSame(self, field)

    def getValue(self) -> "SbPlane const &":
        r"""getValue(SoSFPlane self) -> SbPlane"""
        return _coin.SoSFPlane_getValue(self)

    def __eq__(self, field: "SoSFPlane") -> "int":
        r"""__eq__(SoSFPlane self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___eq__(self, field)

    def __ne__(self, field: "SoSFPlane") -> "int":
        r"""__ne__(SoSFPlane self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFPlane_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFPlane self, SbPlane newvalue)
        setValue(SoSFPlane self, SoSFPlane other)
        """
        return _coin.SoSFPlane_setValue(self, *args)

# Register SoSFPlane in _coin:
_coin.SoSFPlane_swigregister(SoSFPlane)

def SoSFPlane_createInstance() -> "void *":
    r"""SoSFPlane_createInstance() -> void *"""
    return _coin.SoSFPlane_createInstance()

def SoSFPlane_getClassTypeId() -> "SoType":
    r"""SoSFPlane_getClassTypeId() -> SoType"""
    return _coin.SoSFPlane_getClassTypeId()

def SoSFPlane_initClass() -> "void":
    r"""SoSFPlane_initClass()"""
    return _coin.SoSFPlane_initClass()

class SoSFUInt32(SoSField):
    r"""Proxy of C++ SoSFUInt32 class."""

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

    def __init__(self):
        r"""__init__(SoSFUInt32 self) -> SoSFUInt32"""
        _coin.SoSFUInt32_swiginit(self, _coin.new_SoSFUInt32())
    __swig_destroy__ = _coin.delete_SoSFUInt32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFUInt32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFUInt32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFUInt32 self) -> SoType"""
        return _coin.SoSFUInt32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFUInt32 self, SoField field)"""
        return _coin.SoSFUInt32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFUInt32 self, SoField field) -> SbBool"""
        return _coin.SoSFUInt32_isSame(self, field)

    def getValue(self) -> "uint32_t":
        r"""getValue(SoSFUInt32 self) -> uint32_t"""
        return _coin.SoSFUInt32_getValue(self)

    def __eq__(self, field: "SoSFUInt32") -> "int":
        r"""__eq__(SoSFUInt32 self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___eq__(self, field)

    def __ne__(self, field: "SoSFUInt32") -> "int":
        r"""__ne__(SoSFUInt32 self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFUInt32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFUInt32 self, uint32_t newvalue)
        setValue(SoSFUInt32 self, SoSFUInt32 other)
        """
        return _coin.SoSFUInt32_setValue(self, *args)

# Register SoSFUInt32 in _coin:
_coin.SoSFUInt32_swigregister(SoSFUInt32)

def SoSFUInt32_createInstance() -> "void *":
    r"""SoSFUInt32_createInstance() -> void *"""
    return _coin.SoSFUInt32_createInstance()

def SoSFUInt32_getClassTypeId() -> "SoType":
    r"""SoSFUInt32_getClassTypeId() -> SoType"""
    return _coin.SoSFUInt32_getClassTypeId()

def SoSFUInt32_initClass() -> "void":
    r"""SoSFUInt32_initClass()"""
    return _coin.SoSFUInt32_initClass()

class SbVec2b(object):
    r"""Proxy of C++ SbVec2b class."""

    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):
        r"""
        __init__(SbVec2b self) -> SbVec2b
        __init__(SbVec2b self, int8_t const [2] v) -> SbVec2b
        __init__(SbVec2b self, int8_t x, int8_t y) -> SbVec2b
        __init__(SbVec2b self, SbVec2ub const & v) -> SbVec2b
        __init__(SbVec2b self, SbVec2s v) -> SbVec2b
        __init__(SbVec2b self, SbVec2i32 v) -> SbVec2b
        __init__(SbVec2b self, SbVec2f v) -> SbVec2b
        __init__(SbVec2b self, SbVec2d v) -> SbVec2b
        """
        _coin.SbVec2b_swiginit(self, _coin.new_SbVec2b(*args))

    def setValue(self, *args) -> "SbVec2b &":
        r"""
        setValue(SbVec2b self, int8_t const [2] v) -> SbVec2b
        setValue(SbVec2b self, int8_t x, int8_t y) -> SbVec2b
        setValue(SbVec2b self, SbVec2ub const & v) -> SbVec2b
        setValue(SbVec2b self, SbVec2s v) -> SbVec2b
        setValue(SbVec2b self, SbVec2i32 v) -> SbVec2b
        setValue(SbVec2b self, SbVec2f v) -> SbVec2b
        setValue(SbVec2b self, SbVec2d v) -> SbVec2b
        """
        return _coin.SbVec2b_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec2b self) -> int8_t const
        getValue(SbVec2b self, int8_t & x, int8_t & y)
        """
        return _coin.SbVec2b_getValue(self, *args)

    def dot(self, v: "SbVec2b") -> "int32_t":
        r"""dot(SbVec2b self, SbVec2b v) -> int32_t"""
        return _coin.SbVec2b_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec2b self)"""
        return _coin.SbVec2b_negate(self)

    def __imul__(self, *args) -> "SbVec2b &":
        r"""
        __imul__(SbVec2b self, int d) -> SbVec2b
        __imul__(SbVec2b self, double d) -> SbVec2b
        """
        return _coin.SbVec2b___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec2b___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec2b") -> "SbVec2b &":
        r"""__iadd__(SbVec2b self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___iadd__(self, v)

    def __isub__(self, v: "SbVec2b") -> "SbVec2b &":
        r"""__isub__(SbVec2b self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___isub__(self, v)

    def __neg__(self) -> "SbVec2b":
        r"""__neg__(SbVec2b self) -> SbVec2b"""
        return _coin.SbVec2b___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec2b

# Register SbVec2b in _coin:
_coin.SbVec2b_swigregister(SbVec2b)

class SoSFVec2b(SoSField):
    r"""Proxy of C++ SoSFVec2b class."""

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

    def __init__(self):
        r"""__init__(SoSFVec2b self) -> SoSFVec2b"""
        _coin.SoSFVec2b_swiginit(self, _coin.new_SoSFVec2b())
    __swig_destroy__ = _coin.delete_SoSFVec2b

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2b_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2b_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec2b self) -> SoType"""
        return _coin.SoSFVec2b_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec2b self, SoField field)"""
        return _coin.SoSFVec2b_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec2b self, SoField field) -> SbBool"""
        return _coin.SoSFVec2b_isSame(self, field)

    def getValue(self) -> "SbVec2b":
        r"""getValue(SoSFVec2b self) -> SbVec2b"""
        return _coin.SoSFVec2b_getValue(self)

    def __eq__(self, field: "SoSFVec2b") -> "int":
        r"""__eq__(SoSFVec2b self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___eq__(self, field)

    def __ne__(self, field: "SoSFVec2b") -> "int":
        r"""__ne__(SoSFVec2b self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec2b_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec2b self, SbVec2b newvalue)
        setValue(SoSFVec2b self, int8_t x, int8_t y)
        setValue(SoSFVec2b self, int8_t const [2] xy)
        """
        return _coin.SoSFVec2b_setValue(self, *args)

# Register SoSFVec2b in _coin:
_coin.SoSFVec2b_swigregister(SoSFVec2b)

def SoSFVec2b_createInstance() -> "void *":
    r"""SoSFVec2b_createInstance() -> void *"""
    return _coin.SoSFVec2b_createInstance()

def SoSFVec2b_getClassTypeId() -> "SoType":
    r"""SoSFVec2b_getClassTypeId() -> SoType"""
    return _coin.SoSFVec2b_getClassTypeId()

def SoSFVec2b_initClass() -> "void":
    r"""SoSFVec2b_initClass()"""
    return _coin.SoSFVec2b_initClass()

class SoSFVec2s(SoSField):
    r"""Proxy of C++ SoSFVec2s class."""

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

    def __init__(self):
        r"""__init__(SoSFVec2s self) -> SoSFVec2s"""
        _coin.SoSFVec2s_swiginit(self, _coin.new_SoSFVec2s())
    __swig_destroy__ = _coin.delete_SoSFVec2s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec2s self) -> SoType"""
        return _coin.SoSFVec2s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec2s self, SoField field)"""
        return _coin.SoSFVec2s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec2s self, SoField field) -> SbBool"""
        return _coin.SoSFVec2s_isSame(self, field)

    def getValue(self) -> "SbVec2s":
        r"""getValue(SoSFVec2s self) -> SbVec2s"""
        return _coin.SoSFVec2s_getValue(self)

    def __eq__(self, field: "SoSFVec2s") -> "int":
        r"""__eq__(SoSFVec2s self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___eq__(self, field)

    def __ne__(self, field: "SoSFVec2s") -> "int":
        r"""__ne__(SoSFVec2s self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec2s_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec2s self, SbVec2s newvalue)
        setValue(SoSFVec2s self, short x, short y)
        setValue(SoSFVec2s self, short const [2] xy)
        """
        return _coin.SoSFVec2s_setValue(self, *args)

# Register SoSFVec2s in _coin:
_coin.SoSFVec2s_swigregister(SoSFVec2s)

def SoSFVec2s_createInstance() -> "void *":
    r"""SoSFVec2s_createInstance() -> void *"""
    return _coin.SoSFVec2s_createInstance()

def SoSFVec2s_getClassTypeId() -> "SoType":
    r"""SoSFVec2s_getClassTypeId() -> SoType"""
    return _coin.SoSFVec2s_getClassTypeId()

def SoSFVec2s_initClass() -> "void":
    r"""SoSFVec2s_initClass()"""
    return _coin.SoSFVec2s_initClass()

class SoSFVec2i32(SoSField):
    r"""Proxy of C++ SoSFVec2i32 class."""

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

    def __init__(self):
        r"""__init__(SoSFVec2i32 self) -> SoSFVec2i32"""
        _coin.SoSFVec2i32_swiginit(self, _coin.new_SoSFVec2i32())
    __swig_destroy__ = _coin.delete_SoSFVec2i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec2i32 self) -> SoType"""
        return _coin.SoSFVec2i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec2i32 self, SoField field)"""
        return _coin.SoSFVec2i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec2i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec2i32_isSame(self, field)

    def getValue(self) -> "SbVec2i32 const &":
        r"""getValue(SoSFVec2i32 self) -> SbVec2i32"""
        return _coin.SoSFVec2i32_getValue(self)

    def __eq__(self, field: "SoSFVec2i32") -> "int":
        r"""__eq__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___eq__(self, field)

    def __ne__(self, field: "SoSFVec2i32") -> "int":
        r"""__ne__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec2i32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec2i32 self, SbVec2i32 newvalue)
        setValue(SoSFVec2i32 self, int32_t x, int32_t y)
        setValue(SoSFVec2i32 self, int32_t const [2] xy)
        """
        return _coin.SoSFVec2i32_setValue(self, *args)

# Register SoSFVec2i32 in _coin:
_coin.SoSFVec2i32_swigregister(SoSFVec2i32)

def SoSFVec2i32_createInstance() -> "void *":
    r"""SoSFVec2i32_createInstance() -> void *"""
    return _coin.SoSFVec2i32_createInstance()

def SoSFVec2i32_getClassTypeId() -> "SoType":
    r"""SoSFVec2i32_getClassTypeId() -> SoType"""
    return _coin.SoSFVec2i32_getClassTypeId()

def SoSFVec2i32_initClass() -> "void":
    r"""SoSFVec2i32_initClass()"""
    return _coin.SoSFVec2i32_initClass()

class SoSFVec2d(SoSField):
    r"""Proxy of C++ SoSFVec2d class."""

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

    def __init__(self):
        r"""__init__(SoSFVec2d self) -> SoSFVec2d"""
        _coin.SoSFVec2d_swiginit(self, _coin.new_SoSFVec2d())
    __swig_destroy__ = _coin.delete_SoSFVec2d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec2d self) -> SoType"""
        return _coin.SoSFVec2d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec2d self, SoField field)"""
        return _coin.SoSFVec2d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec2d self, SoField field) -> SbBool"""
        return _coin.SoSFVec2d_isSame(self, field)

    def getValue(self) -> "SbVec2d const &":
        r"""getValue(SoSFVec2d self) -> SbVec2d"""
        return _coin.SoSFVec2d_getValue(self)

    def __eq__(self, field: "SoSFVec2d") -> "int":
        r"""__eq__(SoSFVec2d self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___eq__(self, field)

    def __ne__(self, field: "SoSFVec2d") -> "int":
        r"""__ne__(SoSFVec2d self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec2d_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec2d self, SbVec2d newvalue)
        setValue(SoSFVec2d self, double x, double y)
        setValue(SoSFVec2d self, double const [2] xy)
        """
        return _coin.SoSFVec2d_setValue(self, *args)

# Register SoSFVec2d in _coin:
_coin.SoSFVec2d_swigregister(SoSFVec2d)

def SoSFVec2d_createInstance() -> "void *":
    r"""SoSFVec2d_createInstance() -> void *"""
    return _coin.SoSFVec2d_createInstance()

def SoSFVec2d_getClassTypeId() -> "SoType":
    r"""SoSFVec2d_getClassTypeId() -> SoType"""
    return _coin.SoSFVec2d_getClassTypeId()

def SoSFVec2d_initClass() -> "void":
    r"""SoSFVec2d_initClass()"""
    return _coin.SoSFVec2d_initClass()

class SbVec3b(object):
    r"""Proxy of C++ SbVec3b class."""

    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):
        r"""
        __init__(SbVec3b self) -> SbVec3b
        __init__(SbVec3b self, int8_t const [3] v) -> SbVec3b
        __init__(SbVec3b self, int8_t x, int8_t y, int8_t z) -> SbVec3b
        __init__(SbVec3b self, SbVec3ub const & v) -> SbVec3b
        __init__(SbVec3b self, SbVec3s v) -> SbVec3b
        __init__(SbVec3b self, SbVec3i32 v) -> SbVec3b
        __init__(SbVec3b self, SbVec3f v) -> SbVec3b
        __init__(SbVec3b self, SbVec3d v) -> SbVec3b
        """
        _coin.SbVec3b_swiginit(self, _coin.new_SbVec3b(*args))

    def setValue(self, *args) -> "SbVec3b &":
        r"""
        setValue(SbVec3b self, int8_t [3] v) -> SbVec3b
        setValue(SbVec3b self, int8_t x, int8_t y, int8_t z) -> SbVec3b
        setValue(SbVec3b self, SbVec3ub const & v) -> SbVec3b
        setValue(SbVec3b self, SbVec3s v) -> SbVec3b
        setValue(SbVec3b self, SbVec3i32 v) -> SbVec3b
        setValue(SbVec3b self, SbVec3f v) -> SbVec3b
        setValue(SbVec3b self, SbVec3d v) -> SbVec3b
        """
        return _coin.SbVec3b_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec3b self) -> int8_t const
        getValue(SbVec3b self, int8_t & x, int8_t & y, int8_t & z)
        """
        return _coin.SbVec3b_getValue(self, *args)

    def dot(self, v: "SbVec3b") -> "int32_t":
        r"""dot(SbVec3b self, SbVec3b v) -> int32_t"""
        return _coin.SbVec3b_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec3b self)"""
        return _coin.SbVec3b_negate(self)

    def __imul__(self, *args) -> "SbVec3b &":
        r"""
        __imul__(SbVec3b self, int d) -> SbVec3b
        __imul__(SbVec3b self, double d) -> SbVec3b
        """
        return _coin.SbVec3b___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec3b___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec3b") -> "SbVec3b &":
        r"""__iadd__(SbVec3b self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___iadd__(self, v)

    def __isub__(self, v: "SbVec3b") -> "SbVec3b &":
        r"""__isub__(SbVec3b self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___isub__(self, v)

    def __neg__(self) -> "SbVec3b":
        r"""__neg__(SbVec3b self) -> SbVec3b"""
        return _coin.SbVec3b___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec3b

# Register SbVec3b in _coin:
_coin.SbVec3b_swigregister(SbVec3b)

class SoSFVec3b(SoSField):
    r"""Proxy of C++ SoSFVec3b class."""

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

    def __init__(self):
        r"""__init__(SoSFVec3b self) -> SoSFVec3b"""
        _coin.SoSFVec3b_swiginit(self, _coin.new_SoSFVec3b())
    __swig_destroy__ = _coin.delete_SoSFVec3b

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3b_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3b_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec3b self) -> SoType"""
        return _coin.SoSFVec3b_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec3b self, SoField field)"""
        return _coin.SoSFVec3b_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec3b self, SoField field) -> SbBool"""
        return _coin.SoSFVec3b_isSame(self, field)

    def getValue(self) -> "SbVec3b":
        r"""getValue(SoSFVec3b self) -> SbVec3b"""
        return _coin.SoSFVec3b_getValue(self)

    def __eq__(self, field: "SoSFVec3b") -> "int":
        r"""__eq__(SoSFVec3b self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___eq__(self, field)

    def __ne__(self, field: "SoSFVec3b") -> "int":
        r"""__ne__(SoSFVec3b self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec3b_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec3b self, SbVec3b newvalue)
        setValue(SoSFVec3b self, int8_t x, int8_t y, int8_t z)
        setValue(SoSFVec3b self, int8_t const [3] xyz)
        """
        return _coin.SoSFVec3b_setValue(self, *args)

# Register SoSFVec3b in _coin:
_coin.SoSFVec3b_swigregister(SoSFVec3b)

def SoSFVec3b_createInstance() -> "void *":
    r"""SoSFVec3b_createInstance() -> void *"""
    return _coin.SoSFVec3b_createInstance()

def SoSFVec3b_getClassTypeId() -> "SoType":
    r"""SoSFVec3b_getClassTypeId() -> SoType"""
    return _coin.SoSFVec3b_getClassTypeId()

def SoSFVec3b_initClass() -> "void":
    r"""SoSFVec3b_initClass()"""
    return _coin.SoSFVec3b_initClass()

class SoSFVec3s(SoSField):
    r"""Proxy of C++ SoSFVec3s class."""

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

    def __init__(self):
        r"""__init__(SoSFVec3s self) -> SoSFVec3s"""
        _coin.SoSFVec3s_swiginit(self, _coin.new_SoSFVec3s())
    __swig_destroy__ = _coin.delete_SoSFVec3s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec3s self) -> SoType"""
        return _coin.SoSFVec3s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec3s self, SoField field)"""
        return _coin.SoSFVec3s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec3s self, SoField field) -> SbBool"""
        return _coin.SoSFVec3s_isSame(self, field)

    def getValue(self) -> "SbVec3s const &":
        r"""getValue(SoSFVec3s self) -> SbVec3s"""
        return _coin.SoSFVec3s_getValue(self)

    def __eq__(self, field: "SoSFVec3s") -> "int":
        r"""__eq__(SoSFVec3s self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___eq__(self, field)

    def __ne__(self, field: "SoSFVec3s") -> "int":
        r"""__ne__(SoSFVec3s self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec3s_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec3s self, SbVec3s newvalue)
        setValue(SoSFVec3s self, short x, short y, short z)
        setValue(SoSFVec3s self, short const [3] xyz)
        """
        return _coin.SoSFVec3s_setValue(self, *args)

# Register SoSFVec3s in _coin:
_coin.SoSFVec3s_swigregister(SoSFVec3s)

def SoSFVec3s_createInstance() -> "void *":
    r"""SoSFVec3s_createInstance() -> void *"""
    return _coin.SoSFVec3s_createInstance()

def SoSFVec3s_getClassTypeId() -> "SoType":
    r"""SoSFVec3s_getClassTypeId() -> SoType"""
    return _coin.SoSFVec3s_getClassTypeId()

def SoSFVec3s_initClass() -> "void":
    r"""SoSFVec3s_initClass()"""
    return _coin.SoSFVec3s_initClass()

class SoSFVec3i32(SoSField):
    r"""Proxy of C++ SoSFVec3i32 class."""

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

    def __init__(self):
        r"""__init__(SoSFVec3i32 self) -> SoSFVec3i32"""
        _coin.SoSFVec3i32_swiginit(self, _coin.new_SoSFVec3i32())
    __swig_destroy__ = _coin.delete_SoSFVec3i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec3i32 self) -> SoType"""
        return _coin.SoSFVec3i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec3i32 self, SoField field)"""
        return _coin.SoSFVec3i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec3i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec3i32_isSame(self, field)

    def getValue(self) -> "SbVec3i32 const &":
        r"""getValue(SoSFVec3i32 self) -> SbVec3i32"""
        return _coin.SoSFVec3i32_getValue(self)

    def __eq__(self, field: "SoSFVec3i32") -> "int":
        r"""__eq__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___eq__(self, field)

    def __ne__(self, field: "SoSFVec3i32") -> "int":
        r"""__ne__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec3i32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec3i32 self, SbVec3i32 newvalue)
        setValue(SoSFVec3i32 self, int32_t x, int32_t y, int32_t z)
        setValue(SoSFVec3i32 self, int32_t const [3] xyz)
        """
        return _coin.SoSFVec3i32_setValue(self, *args)

# Register SoSFVec3i32 in _coin:
_coin.SoSFVec3i32_swigregister(SoSFVec3i32)

def SoSFVec3i32_createInstance() -> "void *":
    r"""SoSFVec3i32_createInstance() -> void *"""
    return _coin.SoSFVec3i32_createInstance()

def SoSFVec3i32_getClassTypeId() -> "SoType":
    r"""SoSFVec3i32_getClassTypeId() -> SoType"""
    return _coin.SoSFVec3i32_getClassTypeId()

def SoSFVec3i32_initClass() -> "void":
    r"""SoSFVec3i32_initClass()"""
    return _coin.SoSFVec3i32_initClass()

class SoSFVec3d(SoSField):
    r"""Proxy of C++ SoSFVec3d class."""

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

    def __init__(self):
        r"""__init__(SoSFVec3d self) -> SoSFVec3d"""
        _coin.SoSFVec3d_swiginit(self, _coin.new_SoSFVec3d())
    __swig_destroy__ = _coin.delete_SoSFVec3d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec3d self) -> SoType"""
        return _coin.SoSFVec3d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec3d self, SoField field)"""
        return _coin.SoSFVec3d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec3d self, SoField field) -> SbBool"""
        return _coin.SoSFVec3d_isSame(self, field)

    def getValue(self) -> "SbVec3d const &":
        r"""getValue(SoSFVec3d self) -> SbVec3d"""
        return _coin.SoSFVec3d_getValue(self)

    def __eq__(self, field: "SoSFVec3d") -> "int":
        r"""__eq__(SoSFVec3d self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___eq__(self, field)

    def __ne__(self, field: "SoSFVec3d") -> "int":
        r"""__ne__(SoSFVec3d self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec3d_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec3d self, SbVec3d newvalue)
        setValue(SoSFVec3d self, double x, double y, double z)
        setValue(SoSFVec3d self, double const [3] xyz)
        """
        return _coin.SoSFVec3d_setValue(self, *args)

# Register SoSFVec3d in _coin:
_coin.SoSFVec3d_swigregister(SoSFVec3d)

def SoSFVec3d_createInstance() -> "void *":
    r"""SoSFVec3d_createInstance() -> void *"""
    return _coin.SoSFVec3d_createInstance()

def SoSFVec3d_getClassTypeId() -> "SoType":
    r"""SoSFVec3d_getClassTypeId() -> SoType"""
    return _coin.SoSFVec3d_getClassTypeId()

def SoSFVec3d_initClass() -> "void":
    r"""SoSFVec3d_initClass()"""
    return _coin.SoSFVec3d_initClass()

class SbVec4b(object):
    r"""Proxy of C++ SbVec4b class."""

    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):
        r"""
        __init__(SbVec4b self) -> SbVec4b
        __init__(SbVec4b self, int8_t const [4] v) -> SbVec4b
        __init__(SbVec4b self, int8_t x, int8_t y, int8_t z, int8_t w) -> SbVec4b
        __init__(SbVec4b self, SbVec4ub v) -> SbVec4b
        __init__(SbVec4b self, SbVec4s v) -> SbVec4b
        __init__(SbVec4b self, SbVec4i32 v) -> SbVec4b
        __init__(SbVec4b self, SbVec4f v) -> SbVec4b
        __init__(SbVec4b self, SbVec4d v) -> SbVec4b
        """
        _coin.SbVec4b_swiginit(self, _coin.new_SbVec4b(*args))

    def setValue(self, *args) -> "SbVec4b &":
        r"""
        setValue(SbVec4b self, int8_t const [4] v) -> SbVec4b
        setValue(SbVec4b self, int8_t x, int8_t y, int8_t z, int8_t w) -> SbVec4b
        setValue(SbVec4b self, SbVec4ub v) -> SbVec4b
        setValue(SbVec4b self, SbVec4s v) -> SbVec4b
        setValue(SbVec4b self, SbVec4i32 v) -> SbVec4b
        setValue(SbVec4b self, SbVec4f v) -> SbVec4b
        setValue(SbVec4b self, SbVec4d v) -> SbVec4b
        """
        return _coin.SbVec4b_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec4b self) -> int8_t const
        getValue(SbVec4b self, int8_t & x, int8_t & y, int8_t & z, int8_t & w)
        """
        return _coin.SbVec4b_getValue(self, *args)

    def dot(self, v: "SbVec4b") -> "int32_t":
        r"""dot(SbVec4b self, SbVec4b v) -> int32_t"""
        return _coin.SbVec4b_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec4b self)"""
        return _coin.SbVec4b_negate(self)

    def __imul__(self, *args) -> "SbVec4b &":
        r"""
        __imul__(SbVec4b self, int d) -> SbVec4b
        __imul__(SbVec4b self, double d) -> SbVec4b
        """
        return _coin.SbVec4b___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4b___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4b") -> "SbVec4b &":
        r"""__iadd__(SbVec4b self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___iadd__(self, v)

    def __isub__(self, v: "SbVec4b") -> "SbVec4b &":
        r"""__isub__(SbVec4b self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___isub__(self, v)

    def __neg__(self) -> "SbVec4b":
        r"""__neg__(SbVec4b self) -> SbVec4b"""
        return _coin.SbVec4b___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4b

# Register SbVec4b in _coin:
_coin.SbVec4b_swigregister(SbVec4b)

class SoSFVec4b(SoSField):
    r"""Proxy of C++ SoSFVec4b class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4b self) -> SoSFVec4b"""
        _coin.SoSFVec4b_swiginit(self, _coin.new_SoSFVec4b())
    __swig_destroy__ = _coin.delete_SoSFVec4b

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4b_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4b_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4b self) -> SoType"""
        return _coin.SoSFVec4b_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4b self, SoField field)"""
        return _coin.SoSFVec4b_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4b self, SoField field) -> SbBool"""
        return _coin.SoSFVec4b_isSame(self, field)

    def getValue(self) -> "SbVec4b":
        r"""getValue(SoSFVec4b self) -> SbVec4b"""
        return _coin.SoSFVec4b_getValue(self)

    def __eq__(self, field: "SoSFVec4b") -> "int":
        r"""__eq__(SoSFVec4b self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___eq__(self, field)

    def __ne__(self, field: "SoSFVec4b") -> "int":
        r"""__ne__(SoSFVec4b self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4b_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4b self, SbVec4b newvalue)
        setValue(SoSFVec4b self, int8_t x, int8_t y, int8_t z, int8_t w)
        setValue(SoSFVec4b self, int8_t const [4] xyzw)
        """
        return _coin.SoSFVec4b_setValue(self, *args)

# Register SoSFVec4b in _coin:
_coin.SoSFVec4b_swigregister(SoSFVec4b)

def SoSFVec4b_createInstance() -> "void *":
    r"""SoSFVec4b_createInstance() -> void *"""
    return _coin.SoSFVec4b_createInstance()

def SoSFVec4b_getClassTypeId() -> "SoType":
    r"""SoSFVec4b_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4b_getClassTypeId()

def SoSFVec4b_initClass() -> "void":
    r"""SoSFVec4b_initClass()"""
    return _coin.SoSFVec4b_initClass()

class SbVec4ub(object):
    r"""Proxy of C++ SbVec4ub class."""

    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):
        r"""
        __init__(SbVec4ub self) -> SbVec4ub
        __init__(SbVec4ub self, uint8_t const [4] v) -> SbVec4ub
        __init__(SbVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w) -> SbVec4ub
        __init__(SbVec4ub self, SbVec4b v) -> SbVec4ub
        __init__(SbVec4ub self, SbVec4us v) -> SbVec4ub
        __init__(SbVec4ub self, SbVec4ui32 v) -> SbVec4ub
        """
        _coin.SbVec4ub_swiginit(self, _coin.new_SbVec4ub(*args))

    def setValue(self, *args) -> "SbVec4ub &":
        r"""
        setValue(SbVec4ub self, uint8_t const [4] v) -> SbVec4ub
        setValue(SbVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w) -> SbVec4ub
        setValue(SbVec4ub self, SbVec4b v) -> SbVec4ub
        setValue(SbVec4ub self, SbVec4us v) -> SbVec4ub
        setValue(SbVec4ub self, SbVec4ui32 v) -> SbVec4ub
        """
        return _coin.SbVec4ub_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec4ub self) -> uint8_t const
        getValue(SbVec4ub self, uint8_t & x, uint8_t & y, uint8_t & z, uint8_t & w)
        """
        return _coin.SbVec4ub_getValue(self, *args)

    def dot(self, v: "SbVec4ub") -> "int32_t":
        r"""dot(SbVec4ub self, SbVec4ub v) -> int32_t"""
        return _coin.SbVec4ub_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec4ub self)"""
        return _coin.SbVec4ub_negate(self)

    def __imul__(self, *args) -> "SbVec4ub &":
        r"""
        __imul__(SbVec4ub self, int d) -> SbVec4ub
        __imul__(SbVec4ub self, double d) -> SbVec4ub
        """
        return _coin.SbVec4ub___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4ub___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4ub") -> "SbVec4ub &":
        r"""__iadd__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___iadd__(self, v)

    def __isub__(self, v: "SbVec4ub") -> "SbVec4ub &":
        r"""__isub__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___isub__(self, v)

    def __neg__(self) -> "SbVec4ub":
        r"""__neg__(SbVec4ub self) -> SbVec4ub"""
        return _coin.SbVec4ub___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4ub

# Register SbVec4ub in _coin:
_coin.SbVec4ub_swigregister(SbVec4ub)

class SoSFVec4ub(SoSField):
    r"""Proxy of C++ SoSFVec4ub class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4ub self) -> SoSFVec4ub"""
        _coin.SoSFVec4ub_swiginit(self, _coin.new_SoSFVec4ub())
    __swig_destroy__ = _coin.delete_SoSFVec4ub

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4ub_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4ub_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4ub self) -> SoType"""
        return _coin.SoSFVec4ub_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4ub self, SoField field)"""
        return _coin.SoSFVec4ub_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4ub self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ub_isSame(self, field)

    def getValue(self) -> "SbVec4ub":
        r"""getValue(SoSFVec4ub self) -> SbVec4ub"""
        return _coin.SoSFVec4ub_getValue(self)

    def __eq__(self, field: "SoSFVec4ub") -> "int":
        r"""__eq__(SoSFVec4ub self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___eq__(self, field)

    def __ne__(self, field: "SoSFVec4ub") -> "int":
        r"""__ne__(SoSFVec4ub self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4ub_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4ub self, SbVec4ub newvalue)
        setValue(SoSFVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        setValue(SoSFVec4ub self, uint8_t const [4] xyzw)
        """
        return _coin.SoSFVec4ub_setValue(self, *args)

# Register SoSFVec4ub in _coin:
_coin.SoSFVec4ub_swigregister(SoSFVec4ub)

def SoSFVec4ub_createInstance() -> "void *":
    r"""SoSFVec4ub_createInstance() -> void *"""
    return _coin.SoSFVec4ub_createInstance()

def SoSFVec4ub_getClassTypeId() -> "SoType":
    r"""SoSFVec4ub_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4ub_getClassTypeId()

def SoSFVec4ub_initClass() -> "void":
    r"""SoSFVec4ub_initClass()"""
    return _coin.SoSFVec4ub_initClass()

class SbVec4s(object):
    r"""Proxy of C++ SbVec4s class."""

    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):
        r"""
        __init__(SbVec4s self) -> SbVec4s
        __init__(SbVec4s self, short const [4] v) -> SbVec4s
        __init__(SbVec4s self, short x, short y, short z, short w) -> SbVec4s
        __init__(SbVec4s self, SbVec4us v) -> SbVec4s
        __init__(SbVec4s self, SbVec4b v) -> SbVec4s
        __init__(SbVec4s self, SbVec4i32 v) -> SbVec4s
        __init__(SbVec4s self, SbVec4f v) -> SbVec4s
        __init__(SbVec4s self, SbVec4d v) -> SbVec4s
        """
        _coin.SbVec4s_swiginit(self, _coin.new_SbVec4s(*args))

    def setValue(self, *args) -> "SbVec4s &":
        r"""
        setValue(SbVec4s self, short const [4] v) -> SbVec4s
        setValue(SbVec4s self, short x, short y, short z, short w) -> SbVec4s
        setValue(SbVec4s self, SbVec4s v) -> SbVec4s
        setValue(SbVec4s self, SbVec4us v) -> SbVec4s
        setValue(SbVec4s self, SbVec4b v) -> SbVec4s
        setValue(SbVec4s self, SbVec4i32 v) -> SbVec4s
        setValue(SbVec4s self, SbVec4f v) -> SbVec4s
        setValue(SbVec4s self, SbVec4d v) -> SbVec4s
        """
        return _coin.SbVec4s_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec4s self) -> short const
        getValue(SbVec4s self, short & w)
        """
        return _coin.SbVec4s_getValue(self, *args)

    def dot(self, v: "SbVec4s") -> "int32_t":
        r"""dot(SbVec4s self, SbVec4s v) -> int32_t"""
        return _coin.SbVec4s_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec4s self)"""
        return _coin.SbVec4s_negate(self)

    def __imul__(self, *args) -> "SbVec4s &":
        r"""
        __imul__(SbVec4s self, int d) -> SbVec4s
        __imul__(SbVec4s self, double d) -> SbVec4s
        """
        return _coin.SbVec4s___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4s___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4s") -> "SbVec4s &":
        r"""__iadd__(SbVec4s self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___iadd__(self, v)

    def __isub__(self, v: "SbVec4s") -> "SbVec4s &":
        r"""__isub__(SbVec4s self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___isub__(self, v)

    def __neg__(self) -> "SbVec4s":
        r"""__neg__(SbVec4s self) -> SbVec4s"""
        return _coin.SbVec4s___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4s

# Register SbVec4s in _coin:
_coin.SbVec4s_swigregister(SbVec4s)

class SoSFVec4s(SoSField):
    r"""Proxy of C++ SoSFVec4s class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4s self) -> SoSFVec4s"""
        _coin.SoSFVec4s_swiginit(self, _coin.new_SoSFVec4s())
    __swig_destroy__ = _coin.delete_SoSFVec4s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4s self) -> SoType"""
        return _coin.SoSFVec4s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4s self, SoField field)"""
        return _coin.SoSFVec4s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4s self, SoField field) -> SbBool"""
        return _coin.SoSFVec4s_isSame(self, field)

    def getValue(self) -> "SbVec4s const &":
        r"""getValue(SoSFVec4s self) -> SbVec4s"""
        return _coin.SoSFVec4s_getValue(self)

    def __eq__(self, field: "SoSFVec4s") -> "int":
        r"""__eq__(SoSFVec4s self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___eq__(self, field)

    def __ne__(self, field: "SoSFVec4s") -> "int":
        r"""__ne__(SoSFVec4s self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4s_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4s self, SbVec4s newvalue)
        setValue(SoSFVec4s self, short x, short y, short z, short w)
        setValue(SoSFVec4s self, short const [4] xyzw)
        """
        return _coin.SoSFVec4s_setValue(self, *args)

# Register SoSFVec4s in _coin:
_coin.SoSFVec4s_swigregister(SoSFVec4s)

def SoSFVec4s_createInstance() -> "void *":
    r"""SoSFVec4s_createInstance() -> void *"""
    return _coin.SoSFVec4s_createInstance()

def SoSFVec4s_getClassTypeId() -> "SoType":
    r"""SoSFVec4s_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4s_getClassTypeId()

def SoSFVec4s_initClass() -> "void":
    r"""SoSFVec4s_initClass()"""
    return _coin.SoSFVec4s_initClass()

class SbVec4us(object):
    r"""Proxy of C++ SbVec4us class."""

    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):
        r"""
        __init__(SbVec4us self) -> SbVec4us
        __init__(SbVec4us self, unsigned short const [4] v) -> SbVec4us
        __init__(SbVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w) -> SbVec4us
        __init__(SbVec4us self, SbVec4s v) -> SbVec4us
        __init__(SbVec4us self, SbVec4ub v) -> SbVec4us
        __init__(SbVec4us self, SbVec4ui32 v) -> SbVec4us
        """
        _coin.SbVec4us_swiginit(self, _coin.new_SbVec4us(*args))

    def setValue(self, *args) -> "SbVec4us &":
        r"""
        setValue(SbVec4us self, unsigned short const [4] v) -> SbVec4us
        setValue(SbVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w) -> SbVec4us
        setValue(SbVec4us self, SbVec4s v) -> SbVec4us
        setValue(SbVec4us self, SbVec4ub v) -> SbVec4us
        setValue(SbVec4us self, SbVec4ui32 v) -> SbVec4us
        """
        return _coin.SbVec4us_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec4us self) -> unsigned short const
        getValue(SbVec4us self, unsigned short & x, unsigned short & y, unsigned short & z, unsigned short & w)
        """
        return _coin.SbVec4us_getValue(self, *args)

    def dot(self, v: "SbVec4us") -> "int32_t":
        r"""dot(SbVec4us self, SbVec4us v) -> int32_t"""
        return _coin.SbVec4us_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec4us self)"""
        return _coin.SbVec4us_negate(self)

    def __imul__(self, *args) -> "SbVec4us &":
        r"""
        __imul__(SbVec4us self, int d) -> SbVec4us
        __imul__(SbVec4us self, double d) -> SbVec4us
        """
        return _coin.SbVec4us___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4us___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4us") -> "SbVec4us &":
        r"""__iadd__(SbVec4us self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___iadd__(self, v)

    def __isub__(self, v: "SbVec4us") -> "SbVec4us &":
        r"""__isub__(SbVec4us self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___isub__(self, v)

    def __neg__(self) -> "SbVec4us":
        r"""__neg__(SbVec4us self) -> SbVec4us"""
        return _coin.SbVec4us___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4us

# Register SbVec4us in _coin:
_coin.SbVec4us_swigregister(SbVec4us)

class SoSFVec4us(SoSField):
    r"""Proxy of C++ SoSFVec4us class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4us self) -> SoSFVec4us"""
        _coin.SoSFVec4us_swiginit(self, _coin.new_SoSFVec4us())
    __swig_destroy__ = _coin.delete_SoSFVec4us

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4us_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4us_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4us self) -> SoType"""
        return _coin.SoSFVec4us_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4us self, SoField field)"""
        return _coin.SoSFVec4us_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4us self, SoField field) -> SbBool"""
        return _coin.SoSFVec4us_isSame(self, field)

    def getValue(self) -> "SbVec4us const &":
        r"""getValue(SoSFVec4us self) -> SbVec4us"""
        return _coin.SoSFVec4us_getValue(self)

    def __eq__(self, field: "SoSFVec4us") -> "int":
        r"""__eq__(SoSFVec4us self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___eq__(self, field)

    def __ne__(self, field: "SoSFVec4us") -> "int":
        r"""__ne__(SoSFVec4us self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4us_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4us self, SbVec4us newvalue)
        setValue(SoSFVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w)
        setValue(SoSFVec4us self, unsigned short const [4] xyzw)
        """
        return _coin.SoSFVec4us_setValue(self, *args)

# Register SoSFVec4us in _coin:
_coin.SoSFVec4us_swigregister(SoSFVec4us)

def SoSFVec4us_createInstance() -> "void *":
    r"""SoSFVec4us_createInstance() -> void *"""
    return _coin.SoSFVec4us_createInstance()

def SoSFVec4us_getClassTypeId() -> "SoType":
    r"""SoSFVec4us_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4us_getClassTypeId()

def SoSFVec4us_initClass() -> "void":
    r"""SoSFVec4us_initClass()"""
    return _coin.SoSFVec4us_initClass()

class SbVec4i32(object):
    r"""Proxy of C++ SbVec4i32 class."""

    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):
        r"""
        __init__(SbVec4i32 self) -> SbVec4i32
        __init__(SbVec4i32 self, int32_t const [4] v) -> SbVec4i32
        __init__(SbVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4ui32 v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4b v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4s v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4f v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4d v) -> SbVec4i32
        """
        _coin.SbVec4i32_swiginit(self, _coin.new_SbVec4i32(*args))

    def setValue(self, *args) -> "SbVec4i32 &":
        r"""
        setValue(SbVec4i32 self, int32_t const [4] v) -> SbVec4i32
        setValue(SbVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4ui32 v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4b v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4s v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4f v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4d v) -> SbVec4i32
        """
        return _coin.SbVec4i32_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec4i32 self) -> int32_t const
        getValue(SbVec4i32 self, int32_t & x, int32_t & y, int32_t & z, int32_t & w)
        """
        return _coin.SbVec4i32_getValue(self, *args)

    def dot(self, v: "SbVec4i32") -> "int32_t":
        r"""dot(SbVec4i32 self, SbVec4i32 v) -> int32_t"""
        return _coin.SbVec4i32_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec4i32 self)"""
        return _coin.SbVec4i32_negate(self)

    def __imul__(self, *args) -> "SbVec4i32 &":
        r"""
        __imul__(SbVec4i32 self, int d) -> SbVec4i32
        __imul__(SbVec4i32 self, double d) -> SbVec4i32
        """
        return _coin.SbVec4i32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4i32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4i32") -> "SbVec4i32 &":
        r"""__iadd__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___iadd__(self, v)

    def __isub__(self, v: "SbVec4i32") -> "SbVec4i32 &":
        r"""__isub__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___isub__(self, v)

    def __neg__(self) -> "SbVec4i32":
        r"""__neg__(SbVec4i32 self) -> SbVec4i32"""
        return _coin.SbVec4i32___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4i32

# Register SbVec4i32 in _coin:
_coin.SbVec4i32_swigregister(SbVec4i32)

class SoSFVec4i32(SoSField):
    r"""Proxy of C++ SoSFVec4i32 class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4i32 self) -> SoSFVec4i32"""
        _coin.SoSFVec4i32_swiginit(self, _coin.new_SoSFVec4i32())
    __swig_destroy__ = _coin.delete_SoSFVec4i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4i32 self) -> SoType"""
        return _coin.SoSFVec4i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4i32 self, SoField field)"""
        return _coin.SoSFVec4i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec4i32_isSame(self, field)

    def getValue(self) -> "SbVec4i32 const &":
        r"""getValue(SoSFVec4i32 self) -> SbVec4i32"""
        return _coin.SoSFVec4i32_getValue(self)

    def __eq__(self, field: "SoSFVec4i32") -> "int":
        r"""__eq__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___eq__(self, field)

    def __ne__(self, field: "SoSFVec4i32") -> "int":
        r"""__ne__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4i32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4i32 self, SbVec4i32 newvalue)
        setValue(SoSFVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w)
        setValue(SoSFVec4i32 self, int32_t const [4] xyzw)
        """
        return _coin.SoSFVec4i32_setValue(self, *args)

# Register SoSFVec4i32 in _coin:
_coin.SoSFVec4i32_swigregister(SoSFVec4i32)

def SoSFVec4i32_createInstance() -> "void *":
    r"""SoSFVec4i32_createInstance() -> void *"""
    return _coin.SoSFVec4i32_createInstance()

def SoSFVec4i32_getClassTypeId() -> "SoType":
    r"""SoSFVec4i32_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4i32_getClassTypeId()

def SoSFVec4i32_initClass() -> "void":
    r"""SoSFVec4i32_initClass()"""
    return _coin.SoSFVec4i32_initClass()

class SbVec4ui32(object):
    r"""Proxy of C++ SbVec4ui32 class."""

    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):
        r"""
        __init__(SbVec4ui32 self) -> SbVec4ui32
        __init__(SbVec4ui32 self, uint32_t const [4] v) -> SbVec4ui32
        __init__(SbVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w) -> SbVec4ui32
        __init__(SbVec4ui32 self, SbVec4i32 v) -> SbVec4ui32
        __init__(SbVec4ui32 self, SbVec4ub v) -> SbVec4ui32
        __init__(SbVec4ui32 self, SbVec4us v) -> SbVec4ui32
        """
        _coin.SbVec4ui32_swiginit(self, _coin.new_SbVec4ui32(*args))

    def setValue(self, *args) -> "SbVec4ui32 &":
        r"""
        setValue(SbVec4ui32 self, uint32_t const [4] v) -> SbVec4ui32
        setValue(SbVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w) -> SbVec4ui32
        setValue(SbVec4ui32 self, SbVec4i32 v) -> SbVec4ui32
        setValue(SbVec4ui32 self, SbVec4ub v) -> SbVec4ui32
        setValue(SbVec4ui32 self, SbVec4us v) -> SbVec4ui32
        """
        return _coin.SbVec4ui32_setValue(self, *args)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbVec4ui32 self) -> uint32_t const
        getValue(SbVec4ui32 self, uint32_t & x, uint32_t & y, uint32_t & z, uint32_t & w)
        """
        return _coin.SbVec4ui32_getValue(self, *args)

    def dot(self, v: "SbVec4ui32") -> "int32_t":
        r"""dot(SbVec4ui32 self, SbVec4ui32 v) -> int32_t"""
        return _coin.SbVec4ui32_dot(self, v)

    def negate(self) -> "void":
        r"""negate(SbVec4ui32 self)"""
        return _coin.SbVec4ui32_negate(self)

    def __imul__(self, *args) -> "SbVec4ui32 &":
        r"""
        __imul__(SbVec4ui32 self, int d) -> SbVec4ui32
        __imul__(SbVec4ui32 self, double d) -> SbVec4ui32
        """
        return _coin.SbVec4ui32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4ui32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4ui32") -> "SbVec4ui32 &":
        r"""__iadd__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___iadd__(self, v)

    def __isub__(self, v: "SbVec4ui32") -> "SbVec4ui32 &":
        r"""__isub__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___isub__(self, v)

    def __neg__(self) -> "SbVec4ui32":
        r"""__neg__(SbVec4ui32 self) -> SbVec4ui32"""
        return _coin.SbVec4ui32___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4ui32

# Register SbVec4ui32 in _coin:
_coin.SbVec4ui32_swigregister(SbVec4ui32)

class SoSFVec4ui32(SoSField):
    r"""Proxy of C++ SoSFVec4ui32 class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4ui32 self) -> SoSFVec4ui32"""
        _coin.SoSFVec4ui32_swiginit(self, _coin.new_SoSFVec4ui32())
    __swig_destroy__ = _coin.delete_SoSFVec4ui32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4ui32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4ui32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4ui32 self) -> SoType"""
        return _coin.SoSFVec4ui32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4ui32 self, SoField field)"""
        return _coin.SoSFVec4ui32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4ui32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ui32_isSame(self, field)

    def getValue(self) -> "SbVec4ui32 const &":
        r"""getValue(SoSFVec4ui32 self) -> SbVec4ui32"""
        return _coin.SoSFVec4ui32_getValue(self)

    def __eq__(self, field: "SoSFVec4ui32") -> "int":
        r"""__eq__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___eq__(self, field)

    def __ne__(self, field: "SoSFVec4ui32") -> "int":
        r"""__ne__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4ui32_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4ui32 self, SbVec4ui32 newvalue)
        setValue(SoSFVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        setValue(SoSFVec4ui32 self, uint32_t const [4] xyzw)
        """
        return _coin.SoSFVec4ui32_setValue(self, *args)

# Register SoSFVec4ui32 in _coin:
_coin.SoSFVec4ui32_swigregister(SoSFVec4ui32)

def SoSFVec4ui32_createInstance() -> "void *":
    r"""SoSFVec4ui32_createInstance() -> void *"""
    return _coin.SoSFVec4ui32_createInstance()

def SoSFVec4ui32_getClassTypeId() -> "SoType":
    r"""SoSFVec4ui32_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4ui32_getClassTypeId()

def SoSFVec4ui32_initClass() -> "void":
    r"""SoSFVec4ui32_initClass()"""
    return _coin.SoSFVec4ui32_initClass()

class SoSFVec4f(SoSField):
    r"""Proxy of C++ SoSFVec4f class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4f self) -> SoSFVec4f"""
        _coin.SoSFVec4f_swiginit(self, _coin.new_SoSFVec4f())
    __swig_destroy__ = _coin.delete_SoSFVec4f

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4f_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4f self) -> SoType"""
        return _coin.SoSFVec4f_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4f self, SoField field)"""
        return _coin.SoSFVec4f_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4f self, SoField field) -> SbBool"""
        return _coin.SoSFVec4f_isSame(self, field)

    def getValue(self) -> "SbVec4f const &":
        r"""getValue(SoSFVec4f self) -> SbVec4f"""
        return _coin.SoSFVec4f_getValue(self)

    def __eq__(self, field: "SoSFVec4f") -> "int":
        r"""__eq__(SoSFVec4f self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___eq__(self, field)

    def __ne__(self, field: "SoSFVec4f") -> "int":
        r"""__ne__(SoSFVec4f self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4f_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4f self, SbVec4f newvalue)
        setValue(SoSFVec4f self, float x, float y, float z, float w)
        setValue(SoSFVec4f self, float const [4] xyzw)
        setValue(SoSFVec4f self, SoSFVec4f other)
        """
        return _coin.SoSFVec4f_setValue(self, *args)

# Register SoSFVec4f in _coin:
_coin.SoSFVec4f_swigregister(SoSFVec4f)

def SoSFVec4f_createInstance() -> "void *":
    r"""SoSFVec4f_createInstance() -> void *"""
    return _coin.SoSFVec4f_createInstance()

def SoSFVec4f_getClassTypeId() -> "SoType":
    r"""SoSFVec4f_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4f_getClassTypeId()

def SoSFVec4f_initClass() -> "void":
    r"""SoSFVec4f_initClass()"""
    return _coin.SoSFVec4f_initClass()

class SbVec4d(object):
    r"""Proxy of C++ SbVec4d class."""

    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):
        r"""
        __init__(SbVec4d self) -> SbVec4d
        __init__(SbVec4d self, double const [4] v) -> SbVec4d
        __init__(SbVec4d self, double x, double y, double z, double w) -> SbVec4d
        __init__(SbVec4d self, SbVec4f v) -> SbVec4d
        __init__(SbVec4d self, SbVec4b v) -> SbVec4d
        __init__(SbVec4d self, SbVec4s v) -> SbVec4d
        __init__(SbVec4d self, SbVec4i32 v) -> SbVec4d
        """
        _coin.SbVec4d_swiginit(self, _coin.new_SbVec4d(*args))

    def setValue(self, *args) -> "SbVec4d &":
        r"""
        setValue(SbVec4d self, double const [4] v) -> SbVec4d
        setValue(SbVec4d self, double x, double y, double z, double w) -> SbVec4d
        setValue(SbVec4d self, SbVec4f v) -> SbVec4d
        setValue(SbVec4d self, SbVec4b v) -> SbVec4d
        setValue(SbVec4d self, SbVec4s v) -> SbVec4d
        setValue(SbVec4d self, SbVec4i32 v) -> SbVec4d
        """
        return _coin.SbVec4d_setValue(self, *args)

    def getValue(self) -> "double const *":
        r"""getValue(SbVec4d self) -> double const *"""
        return _coin.SbVec4d_getValue(self)

    def dot(self, v: "SbVec4d") -> "double":
        r"""dot(SbVec4d self, SbVec4d v) -> double"""
        return _coin.SbVec4d_dot(self, v)

    def equals(self, v: "SbVec4d", tolerance: "double") -> "SbBool":
        r"""equals(SbVec4d self, SbVec4d v, double tolerance) -> SbBool"""
        return _coin.SbVec4d_equals(self, v, tolerance)

    def getReal(self, v: "SbVec3d") -> "void":
        r"""getReal(SbVec4d self, SbVec3d v)"""
        return _coin.SbVec4d_getReal(self, v)

    def length(self) -> "double":
        r"""length(SbVec4d self) -> double"""
        return _coin.SbVec4d_length(self)

    def sqrLength(self) -> "double":
        r"""sqrLength(SbVec4d self) -> double"""
        return _coin.SbVec4d_sqrLength(self)

    def negate(self) -> "void":
        r"""negate(SbVec4d self)"""
        return _coin.SbVec4d_negate(self)

    def normalize(self) -> "double":
        r"""normalize(SbVec4d self) -> double"""
        return _coin.SbVec4d_normalize(self)

    def __imul__(self, d: "double") -> "SbVec4d &":
        r"""__imul__(SbVec4d self, double d) -> SbVec4d"""
        return _coin.SbVec4d___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec4d___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v: "SbVec4d") -> "SbVec4d &":
        r"""__iadd__(SbVec4d self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___iadd__(self, v)

    def __isub__(self, v: "SbVec4d") -> "SbVec4d &":
        r"""__isub__(SbVec4d self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___isub__(self, v)

    def __neg__(self) -> "SbVec4d":
        r"""__neg__(SbVec4d self) -> SbVec4d"""
        return _coin.SbVec4d___neg__(self)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbVec4d self, FILE * fp)"""
        return _coin.SbVec4d_output(self, fp)

    def __add__(self, u: "SbVec4d") -> "SbVec4d":
        r"""__add__(SbVec4d self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___add__(self, u)

    def __sub__(self, u: "SbVec4d") -> "SbVec4d":
        r"""__sub__(SbVec4d self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___sub__(self, u)

    def __mul__(self, *args) -> "SbVec4d":
        r"""
        __mul__(SbVec4d self, double const d) -> SbVec4d
        __mul__(SbVec4d self, SbDPMatrix m) -> SbVec4d
        """
        return _coin.SbVec4d___mul__(self, *args)

    def __rmul__(self, d: "double const") -> "SbVec4d":
        r"""__rmul__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___rmul__(self, d)

    def __div__(self, d: "double const") -> "SbVec4d":
        r"""__div__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___div__(self, d)

    def __truediv__(self, d: "double const") -> "SbVec4d":
        r"""__truediv__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___truediv__(self, d)

    def __eq__(self, u: "SbVec4d") -> "int":
        r"""__eq__(SbVec4d self, SbVec4d u) -> int"""
        return _coin.SbVec4d___eq__(self, u)

    def __nq__(self, u: "SbVec4d") -> "int":
        r"""__nq__(SbVec4d self, SbVec4d u) -> int"""
        return _coin.SbVec4d___nq__(self, u)

    def __getitem__(self, i: "int") -> "double":
        r"""__getitem__(SbVec4d self, int i) -> double"""
        return _coin.SbVec4d___getitem__(self, i)

    def __setitem__(self, i: "int", value: "double") -> "void":
        r"""__setitem__(SbVec4d self, int i, double value)"""
        return _coin.SbVec4d___setitem__(self, i, value)

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

    def __len__(self):
          return 4

    __swig_destroy__ = _coin.delete_SbVec4d

# Register SbVec4d in _coin:
_coin.SbVec4d_swigregister(SbVec4d)

class SoSFVec4d(SoSField):
    r"""Proxy of C++ SoSFVec4d class."""

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

    def __init__(self):
        r"""__init__(SoSFVec4d self) -> SoSFVec4d"""
        _coin.SoSFVec4d_swiginit(self, _coin.new_SoSFVec4d())
    __swig_destroy__ = _coin.delete_SoSFVec4d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSFVec4d self) -> SoType"""
        return _coin.SoSFVec4d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoSFVec4d self, SoField field)"""
        return _coin.SoSFVec4d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoSFVec4d self, SoField field) -> SbBool"""
        return _coin.SoSFVec4d_isSame(self, field)

    def getValue(self) -> "SbVec4d const &":
        r"""getValue(SoSFVec4d self) -> SbVec4d"""
        return _coin.SoSFVec4d_getValue(self)

    def __eq__(self, field: "SoSFVec4d") -> "int":
        r"""__eq__(SoSFVec4d self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___eq__(self, field)

    def __ne__(self, field: "SoSFVec4d") -> "int":
        r"""__ne__(SoSFVec4d self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___ne__(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSFVec4d_initClass()

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoSFVec4d self, SbVec4d newvalue)
        setValue(SoSFVec4d self, double x, double y, double z, double w)
        setValue(SoSFVec4d self, double const [4] xyzw)
        """
        return _coin.SoSFVec4d_setValue(self, *args)

# Register SoSFVec4d in _coin:
_coin.SoSFVec4d_swigregister(SoSFVec4d)

def SoSFVec4d_createInstance() -> "void *":
    r"""SoSFVec4d_createInstance() -> void *"""
    return _coin.SoSFVec4d_createInstance()

def SoSFVec4d_getClassTypeId() -> "SoType":
    r"""SoSFVec4d_getClassTypeId() -> SoType"""
    return _coin.SoSFVec4d_getClassTypeId()

def SoSFVec4d_initClass() -> "void":
    r"""SoSFVec4d_initClass()"""
    return _coin.SoSFVec4d_initClass()

class SoMFColor(SoMField):
    r"""Proxy of C++ SoMFColor class."""

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

    def __init__(self):
        r"""__init__(SoMFColor self) -> SoMFColor"""
        _coin.SoMFColor_swiginit(self, _coin.new_SoMFColor())
    __swig_destroy__ = _coin.delete_SoMFColor

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFColor_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFColor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFColor self) -> SoType"""
        return _coin.SoMFColor_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFColor self, SoField field)"""
        return _coin.SoMFColor_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFColor self, SoField field) -> SbBool"""
        return _coin.SoMFColor_isSame(self, field)

    def find(self, value: "SbColor", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFColor self, SbColor value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFColor_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFColor") -> "SbBool":
        r"""__eq__(SoMFColor self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___eq__(self, field)

    def __ne__(self, field: "SoMFColor") -> "SbBool":
        r"""__ne__(SoMFColor self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___ne__(self, field)

    def startEditing(self) -> "SbColor *":
        r"""startEditing(SoMFColor self) -> SbColor"""
        return _coin.SoMFColor_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFColor self)"""
        return _coin.SoMFColor_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFColor self, int const num, float const * userdata)
        setValuesPointer(SoMFColor self, int const num, float * userdata)
        setValuesPointer(SoMFColor self, int const num, SbColor userdata)
        setValuesPointer(SoMFColor self, int const num, SbColor userdata)
        """
        return _coin.SoMFColor_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFColor_initClass()

    def setValues(*args):
      if len(args) == 2:
        return _coin.SoMFColor_setValues(args[0], 0, len(args[1]), args[1])
      elif len(args) == 3:
        return _coin.SoMFColor_setValues(args[0], args[1], len(args[2]), args[2])

      return _coin.SoMFColor_setValues(*args)



    def setHSVValues(self, start: "int", num: "int", hsv: "float const [][3]") -> "void":
        r"""setHSVValues(SoMFColor self, int start, int num, float const [][3] hsv)"""
        return _coin.SoMFColor_setHSVValues(self, start, num, hsv)

    def setHSVValue(self, *args) -> "void":
        r"""
        setHSVValue(SoMFColor self, float h, float s, float v)
        setHSVValue(SoMFColor self, float const [3] hsv)
        """
        return _coin.SoMFColor_setHSVValue(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFColor self, int const idx, SbColor value)
        set1Value(SoMFColor self, int idx, SbVec3f vec)
        set1Value(SoMFColor self, int idx, float r, float g, float b)
        set1Value(SoMFColor self, int idx, float const [3] rgb)
        """
        return _coin.SoMFColor_set1Value(self, *args)

    def set1HSVValue(self, *args) -> "void":
        r"""
        set1HSVValue(SoMFColor self, int idx, float h, float s, float v)
        set1HSVValue(SoMFColor self, int idx, float const [3] hsv)
        """
        return _coin.SoMFColor_set1HSVValue(self, *args)

    def __getitem__(self, i: "int") -> "SbColor const &":
        r"""__getitem__(SoMFColor self, int i) -> SbColor"""
        return _coin.SoMFColor___getitem__(self, i)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(SoMFColor self, int i, SbColor value)
        __setitem__(SoMFColor self, int i, float const [3] rgb)
        """
        return _coin.SoMFColor___setitem__(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFColor self, SbColor value)
        setValue(SoMFColor self, SbVec3f vec)
        setValue(SoMFColor self, float r, float g, float b)
        setValue(SoMFColor self, float const [3] rgb)
        setValue(SoMFColor self, SoMFColor other)
        """
        return _coin.SoMFColor_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SbColor const *":
        r"""getValues(SoMFColor self, int i=0) -> SbColor"""
        return _coin.SoMFColor_getValues(self, i)

# Register SoMFColor in _coin:
_coin.SoMFColor_swigregister(SoMFColor)

def SoMFColor_createInstance() -> "void *":
    r"""SoMFColor_createInstance() -> void *"""
    return _coin.SoMFColor_createInstance()

def SoMFColor_getClassTypeId() -> "SoType":
    r"""SoMFColor_getClassTypeId() -> SoType"""
    return _coin.SoMFColor_getClassTypeId()

def SoMFColor_initClass() -> "void":
    r"""SoMFColor_initClass()"""
    return _coin.SoMFColor_initClass()

class SoMFColorRGBA(SoMField):
    r"""Proxy of C++ SoMFColorRGBA class."""

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

    def __init__(self):
        r"""__init__(SoMFColorRGBA self) -> SoMFColorRGBA"""
        _coin.SoMFColorRGBA_swiginit(self, _coin.new_SoMFColorRGBA())
    __swig_destroy__ = _coin.delete_SoMFColorRGBA

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFColorRGBA_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFColorRGBA_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFColorRGBA self) -> SoType"""
        return _coin.SoMFColorRGBA_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFColorRGBA self, SoField field)"""
        return _coin.SoMFColorRGBA_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFColorRGBA self, SoField field) -> SbBool"""
        return _coin.SoMFColorRGBA_isSame(self, field)

    def getValues(self, start: "int const") -> "SbColor4f const *":
        r"""getValues(SoMFColorRGBA self, int const start) -> SbColor4f"""
        return _coin.SoMFColorRGBA_getValues(self, start)

    def find(self, value: "SbColor4f", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFColorRGBA self, SbColor4f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFColorRGBA_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFColorRGBA") -> "SbBool":
        r"""__eq__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___eq__(self, field)

    def __ne__(self, field: "SoMFColorRGBA") -> "SbBool":
        r"""__ne__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___ne__(self, field)

    def startEditing(self) -> "SbColor4f *":
        r"""startEditing(SoMFColorRGBA self) -> SbColor4f"""
        return _coin.SoMFColorRGBA_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFColorRGBA self)"""
        return _coin.SoMFColorRGBA_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFColorRGBA self, int const num, float const * userdata)
        setValuesPointer(SoMFColorRGBA self, int const num, float * userdata)
        setValuesPointer(SoMFColorRGBA self, int const num, SbColor4f userdata)
        setValuesPointer(SoMFColorRGBA self, int const num, SbColor4f userdata)
        """
        return _coin.SoMFColorRGBA_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFColorRGBA_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFColorRGBA self, int const start, int const num, SbColor4f newvals)
        setValues(SoMFColorRGBA self, int start, int num, float const [][4] rgba)
        """
        return _coin.SoMFColorRGBA_setValues(self, *args)

    def setHSVValues(self, start: "int", num: "int", hsv: "float const [][4]") -> "void":
        r"""setHSVValues(SoMFColorRGBA self, int start, int num, float const [][4] hsv)"""
        return _coin.SoMFColorRGBA_setHSVValues(self, start, num, hsv)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFColorRGBA self, SbColor4f value)
        setValue(SoMFColorRGBA self, SbVec4f vec)
        setValue(SoMFColorRGBA self, float r, float g, float b, float a)
        setValue(SoMFColorRGBA self, float const [4] rgba)
        """
        return _coin.SoMFColorRGBA_setValue(self, *args)

    def setHSVValue(self, *args) -> "void":
        r"""
        setHSVValue(SoMFColorRGBA self, float h, float s, float v, float a)
        setHSVValue(SoMFColorRGBA self, float const [4] hsva)
        """
        return _coin.SoMFColorRGBA_setHSVValue(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFColorRGBA self, int const idx, SbColor4f value)
        set1Value(SoMFColorRGBA self, int idx, SbVec4f vec)
        set1Value(SoMFColorRGBA self, int idx, float r, float g, float b, float a)
        set1Value(SoMFColorRGBA self, int idx, float const [4] rgba)
        """
        return _coin.SoMFColorRGBA_set1Value(self, *args)

    def set1HSVValue(self, *args) -> "void":
        r"""
        set1HSVValue(SoMFColorRGBA self, int idx, float h, float s, float v, float a)
        set1HSVValue(SoMFColorRGBA self, int idx, float const [4] hsva)
        """
        return _coin.SoMFColorRGBA_set1HSVValue(self, *args)

# Register SoMFColorRGBA in _coin:
_coin.SoMFColorRGBA_swigregister(SoMFColorRGBA)

def SoMFColorRGBA_createInstance() -> "void *":
    r"""SoMFColorRGBA_createInstance() -> void *"""
    return _coin.SoMFColorRGBA_createInstance()

def SoMFColorRGBA_getClassTypeId() -> "SoType":
    r"""SoMFColorRGBA_getClassTypeId() -> SoType"""
    return _coin.SoMFColorRGBA_getClassTypeId()

def SoMFColorRGBA_initClass() -> "void":
    r"""SoMFColorRGBA_initClass()"""
    return _coin.SoMFColorRGBA_initClass()

class SoMFDouble(SoMField):
    r"""Proxy of C++ SoMFDouble class."""

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

    def __init__(self):
        r"""__init__(SoMFDouble self) -> SoMFDouble"""
        _coin.SoMFDouble_swiginit(self, _coin.new_SoMFDouble())
    __swig_destroy__ = _coin.delete_SoMFDouble

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFDouble_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFDouble_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFDouble self) -> SoType"""
        return _coin.SoMFDouble_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFDouble self, SoField field)"""
        return _coin.SoMFDouble_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFDouble self, SoField field) -> SbBool"""
        return _coin.SoMFDouble_isSame(self, field)

    def getValues(self, start: "int const") -> "double const *":
        r"""getValues(SoMFDouble self, int const start) -> double const *"""
        return _coin.SoMFDouble_getValues(self, start)

    def find(self, value: "double", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFDouble self, double value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFDouble_find(self, value, addifnotfound)

    def setValues(self, start: "int const", num: "int const", newvals: "double const *") -> "void":
        r"""setValues(SoMFDouble self, int const start, int const num, double const * newvals)"""
        return _coin.SoMFDouble_setValues(self, start, num, newvals)

    def set1Value(self, idx: "int const", value: "double") -> "void":
        r"""set1Value(SoMFDouble self, int const idx, double value)"""
        return _coin.SoMFDouble_set1Value(self, idx, value)

    def setValue(self, value: "double") -> "void":
        r"""setValue(SoMFDouble self, double value)"""
        return _coin.SoMFDouble_setValue(self, value)

    def __eq__(self, field: "SoMFDouble") -> "SbBool":
        r"""__eq__(SoMFDouble self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___eq__(self, field)

    def __ne__(self, field: "SoMFDouble") -> "SbBool":
        r"""__ne__(SoMFDouble self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___ne__(self, field)

    def startEditing(self) -> "double *":
        r"""startEditing(SoMFDouble self) -> double *"""
        return _coin.SoMFDouble_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFDouble self)"""
        return _coin.SoMFDouble_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFDouble self, int const num, double const * userdata)
        setValuesPointer(SoMFDouble self, int const num, double * userdata)
        """
        return _coin.SoMFDouble_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFDouble_initClass()

# Register SoMFDouble in _coin:
_coin.SoMFDouble_swigregister(SoMFDouble)

def SoMFDouble_createInstance() -> "void *":
    r"""SoMFDouble_createInstance() -> void *"""
    return _coin.SoMFDouble_createInstance()

def SoMFDouble_getClassTypeId() -> "SoType":
    r"""SoMFDouble_getClassTypeId() -> SoType"""
    return _coin.SoMFDouble_getClassTypeId()

def SoMFDouble_initClass() -> "void":
    r"""SoMFDouble_initClass()"""
    return _coin.SoMFDouble_initClass()

class SoMFEngine(SoMField):
    r"""Proxy of C++ SoMFEngine class."""

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

    def __init__(self):
        r"""__init__(SoMFEngine self) -> SoMFEngine"""
        _coin.SoMFEngine_swiginit(self, _coin.new_SoMFEngine())
    __swig_destroy__ = _coin.delete_SoMFEngine

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFEngine_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFEngine_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFEngine self) -> SoType"""
        return _coin.SoMFEngine_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFEngine self, SoField field)"""
        return _coin.SoMFEngine_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFEngine self, SoField field) -> SbBool"""
        return _coin.SoMFEngine_isSame(self, field)

    def find(self, value: "SoEngine", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFEngine self, SoEngine value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFEngine_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFEngine_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFEngine_setValues(args[0], args[1], len(args[2]), args[2])
       return _coin.SoMFEngine_setValues(*args)



    def set1Value(self, idx: "int const", value: "SoEngine") -> "void":
        r"""set1Value(SoMFEngine self, int const idx, SoEngine value)"""
        return _coin.SoMFEngine_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFEngine") -> "SbBool":
        r"""__eq__(SoMFEngine self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___eq__(self, field)

    def __ne__(self, field: "SoMFEngine") -> "SbBool":
        r"""__ne__(SoMFEngine self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___ne__(self, field)

    def startEditing(self) -> "SoEngine **":
        r"""startEditing(SoMFEngine self) -> SoEngine **"""
        return _coin.SoMFEngine_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFEngine self)"""
        return _coin.SoMFEngine_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFEngine_initClass()

    def fixCopy(self, copyconnections: "SbBool") -> "void":
        r"""fixCopy(SoMFEngine self, SbBool copyconnections)"""
        return _coin.SoMFEngine_fixCopy(self, copyconnections)

    def referencesCopy(self) -> "SbBool":
        r"""referencesCopy(SoMFEngine self) -> SbBool"""
        return _coin.SoMFEngine_referencesCopy(self)

    def deleteValues(self, start: "int", num: "int"=-1) -> "void":
        r"""deleteValues(SoMFEngine self, int start, int num=-1)"""
        return _coin.SoMFEngine_deleteValues(self, start, num)

    def insertSpace(self, start: "int", num: "int") -> "void":
        r"""insertSpace(SoMFEngine self, int start, int num)"""
        return _coin.SoMFEngine_insertSpace(self, start, num)

    def __getitem__(self, i: "int") -> "SoEngine const *":
        r"""__getitem__(SoMFEngine self, int i) -> SoEngine"""
        return _coin.SoMFEngine___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SoEngine") -> "void":
        r"""__setitem__(SoMFEngine self, int i, SoEngine value)"""
        return _coin.SoMFEngine___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFEngine self, SoEngine value)
        setValue(SoMFEngine self, SoMFEngine other)
        """
        return _coin.SoMFEngine_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SoEngine const **":
        r"""getValues(SoMFEngine self, int i=0) -> SoEngine"""
        return _coin.SoMFEngine_getValues(self, i)

# Register SoMFEngine in _coin:
_coin.SoMFEngine_swigregister(SoMFEngine)

def SoMFEngine_createInstance() -> "void *":
    r"""SoMFEngine_createInstance() -> void *"""
    return _coin.SoMFEngine_createInstance()

def SoMFEngine_getClassTypeId() -> "SoType":
    r"""SoMFEngine_getClassTypeId() -> SoType"""
    return _coin.SoMFEngine_getClassTypeId()

def SoMFEngine_initClass() -> "void":
    r"""SoMFEngine_initClass()"""
    return _coin.SoMFEngine_initClass()

class SoMFBitMask(SoMFEnum):
    r"""Proxy of C++ SoMFBitMask class."""

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

    def __init__(self):
        r"""__init__(SoMFBitMask self) -> SoMFBitMask"""
        _coin.SoMFBitMask_swiginit(self, _coin.new_SoMFBitMask())
    __swig_destroy__ = _coin.delete_SoMFBitMask

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFBitMask_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFBitMask_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFBitMask self) -> SoType"""
        return _coin.SoMFBitMask_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFBitMask self, SoField field)"""
        return _coin.SoMFBitMask_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFBitMask self, SoField field) -> SbBool"""
        return _coin.SoMFBitMask_isSame(self, field)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFBitMask_initClass()

# Register SoMFBitMask in _coin:
_coin.SoMFBitMask_swigregister(SoMFBitMask)

def SoMFBitMask_createInstance() -> "void *":
    r"""SoMFBitMask_createInstance() -> void *"""
    return _coin.SoMFBitMask_createInstance()

def SoMFBitMask_getClassTypeId() -> "SoType":
    r"""SoMFBitMask_getClassTypeId() -> SoType"""
    return _coin.SoMFBitMask_getClassTypeId()

def SoMFBitMask_initClass() -> "void":
    r"""SoMFBitMask_initClass()"""
    return _coin.SoMFBitMask_initClass()

class SoMFInt32(SoMField):
    r"""Proxy of C++ SoMFInt32 class."""

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

    def __init__(self):
        r"""__init__(SoMFInt32 self) -> SoMFInt32"""
        _coin.SoMFInt32_swiginit(self, _coin.new_SoMFInt32())
    __swig_destroy__ = _coin.delete_SoMFInt32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFInt32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFInt32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFInt32 self) -> SoType"""
        return _coin.SoMFInt32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFInt32 self, SoField field)"""
        return _coin.SoMFInt32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFInt32 self, SoField field) -> SbBool"""
        return _coin.SoMFInt32_isSame(self, field)

    def find(self, value: "int32_t", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFInt32 self, int32_t value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFInt32_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFInt32):
             val = args[1].getValues()
             return _coin.SoMFInt32_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFInt32_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFInt32):
             val = args[2].getValues()
             return _coin.SoMFInt32_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFInt32_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFInt32_setValues(*args)



    def set1Value(self, idx: "int const", value: "int32_t") -> "void":
        r"""set1Value(SoMFInt32 self, int const idx, int32_t value)"""
        return _coin.SoMFInt32_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFInt32") -> "SbBool":
        r"""__eq__(SoMFInt32 self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___eq__(self, field)

    def __ne__(self, field: "SoMFInt32") -> "SbBool":
        r"""__ne__(SoMFInt32 self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___ne__(self, field)

    def startEditing(self) -> "int32_t *":
        r"""startEditing(SoMFInt32 self) -> int32_t *"""
        return _coin.SoMFInt32_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFInt32 self)"""
        return _coin.SoMFInt32_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFInt32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFInt32 self, int const num, int32_t * userdata)
        """
        return _coin.SoMFInt32_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFInt32_initClass()

    def __getitem__(self, i: "int") -> "int32_t const":
        r"""__getitem__(SoMFInt32 self, int i) -> int32_t const"""
        return _coin.SoMFInt32___getitem__(self, i)

    def __setitem__(self, i: "int", value: "int32_t") -> "void":
        r"""__setitem__(SoMFInt32 self, int i, int32_t value)"""
        return _coin.SoMFInt32___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFInt32 self, int32_t value)
        setValue(SoMFInt32 self, SoMFInt32 other)
        """
        return _coin.SoMFInt32_setValue(self, *args)

    def getValues(self, i: "int32_t"=0) -> "int32_t const *":
        r"""getValues(SoMFInt32 self, int32_t i=0) -> int32_t const"""
        return _coin.SoMFInt32_getValues(self, i)

# Register SoMFInt32 in _coin:
_coin.SoMFInt32_swigregister(SoMFInt32)

def SoMFInt32_createInstance() -> "void *":
    r"""SoMFInt32_createInstance() -> void *"""
    return _coin.SoMFInt32_createInstance()

def SoMFInt32_getClassTypeId() -> "SoType":
    r"""SoMFInt32_getClassTypeId() -> SoType"""
    return _coin.SoMFInt32_getClassTypeId()

def SoMFInt32_initClass() -> "void":
    r"""SoMFInt32_initClass()"""
    return _coin.SoMFInt32_initClass()

class SoMFNode(SoMField):
    r"""Proxy of C++ SoMFNode class."""

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

    def __init__(self):
        r"""__init__(SoMFNode self) -> SoMFNode"""
        _coin.SoMFNode_swiginit(self, _coin.new_SoMFNode())
    __swig_destroy__ = _coin.delete_SoMFNode

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFNode_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFNode_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFNode self) -> SoType"""
        return _coin.SoMFNode_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFNode self, SoField field)"""
        return _coin.SoMFNode_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFNode self, SoField field) -> SbBool"""
        return _coin.SoMFNode_isSame(self, field)

    def find(self, value: "SoNode", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFNode self, SoNode value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFNode_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFNode_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFNode_setValues(args[0], args[1], len(args[2]), args[2])
       return _coin.SoMFNode_setValues(*args)



    def set1Value(self, idx: "int const", value: "SoNode") -> "void":
        r"""set1Value(SoMFNode self, int const idx, SoNode value)"""
        return _coin.SoMFNode_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFNode") -> "SbBool":
        r"""__eq__(SoMFNode self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___eq__(self, field)

    def __ne__(self, field: "SoMFNode") -> "SbBool":
        r"""__ne__(SoMFNode self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___ne__(self, field)

    def startEditing(self) -> "SoNode **":
        r"""startEditing(SoMFNode self) -> SoNode **"""
        return _coin.SoMFNode_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFNode self)"""
        return _coin.SoMFNode_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFNode_initClass()

    def fixCopy(self, copyconnections: "SbBool") -> "void":
        r"""fixCopy(SoMFNode self, SbBool copyconnections)"""
        return _coin.SoMFNode_fixCopy(self, copyconnections)

    def referencesCopy(self) -> "SbBool":
        r"""referencesCopy(SoMFNode self) -> SbBool"""
        return _coin.SoMFNode_referencesCopy(self)

    def addNode(self, node: "SoNode") -> "void":
        r"""addNode(SoMFNode self, SoNode node)"""
        return _coin.SoMFNode_addNode(self, node)

    def insertNode(self, node: "SoNode", idx: "int") -> "void":
        r"""insertNode(SoMFNode self, SoNode node, int idx)"""
        return _coin.SoMFNode_insertNode(self, node, idx)

    def getNode(self, idx: "int") -> "SoNode *":
        r"""getNode(SoMFNode self, int idx) -> SoNode"""
        return _coin.SoMFNode_getNode(self, idx)

    def findNode(self, node: "SoNode") -> "int":
        r"""findNode(SoMFNode self, SoNode node) -> int"""
        return _coin.SoMFNode_findNode(self, node)

    def getNumNodes(self) -> "int":
        r"""getNumNodes(SoMFNode self) -> int"""
        return _coin.SoMFNode_getNumNodes(self)

    def removeNode(self, *args) -> "void":
        r"""
        removeNode(SoMFNode self, int index)
        removeNode(SoMFNode self, SoNode node)
        """
        return _coin.SoMFNode_removeNode(self, *args)

    def removeAllNodes(self) -> "void":
        r"""removeAllNodes(SoMFNode self)"""
        return _coin.SoMFNode_removeAllNodes(self)

    def replaceNode(self, *args) -> "void":
        r"""
        replaceNode(SoMFNode self, int idx, SoNode newnode)
        replaceNode(SoMFNode self, SoNode oldnode, SoNode newnode)
        """
        return _coin.SoMFNode_replaceNode(self, *args)

    def deleteValues(self, start: "int", num: "int"=-1) -> "void":
        r"""deleteValues(SoMFNode self, int start, int num=-1)"""
        return _coin.SoMFNode_deleteValues(self, start, num)

    def insertSpace(self, start: "int", num: "int") -> "void":
        r"""insertSpace(SoMFNode self, int start, int num)"""
        return _coin.SoMFNode_insertSpace(self, start, num)

    def __getitem__(self, i: "int") -> "SoNode const *":
        r"""__getitem__(SoMFNode self, int i) -> SoNode"""
        return _coin.SoMFNode___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SoNode") -> "void":
        r"""__setitem__(SoMFNode self, int i, SoNode value)"""
        return _coin.SoMFNode___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFNode self, SoNode value)
        setValue(SoMFNode self, SoMFNode other)
        """
        return _coin.SoMFNode_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SoNode const **":
        r"""getValues(SoMFNode self, int i=0) -> SoNode"""
        return _coin.SoMFNode_getValues(self, i)

# Register SoMFNode in _coin:
_coin.SoMFNode_swigregister(SoMFNode)

def SoMFNode_createInstance() -> "void *":
    r"""SoMFNode_createInstance() -> void *"""
    return _coin.SoMFNode_createInstance()

def SoMFNode_getClassTypeId() -> "SoType":
    r"""SoMFNode_getClassTypeId() -> SoType"""
    return _coin.SoMFNode_getClassTypeId()

def SoMFNode_initClass() -> "void":
    r"""SoMFNode_initClass()"""
    return _coin.SoMFNode_initClass()

class SoMFPath(SoMField):
    r"""Proxy of C++ SoMFPath class."""

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

    def __init__(self):
        r"""__init__(SoMFPath self) -> SoMFPath"""
        _coin.SoMFPath_swiginit(self, _coin.new_SoMFPath())
    __swig_destroy__ = _coin.delete_SoMFPath

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFPath_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFPath_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFPath self) -> SoType"""
        return _coin.SoMFPath_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFPath self, SoField field)"""
        return _coin.SoMFPath_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFPath self, SoField field) -> SbBool"""
        return _coin.SoMFPath_isSame(self, field)

    def find(self, value: "SoPath", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFPath self, SoPath value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFPath_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFPath_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFPath_setValues(args[0], args[1], len(args[2]), args[2])
       return _coin.SoMFPath_setValues(*args)



    def set1Value(self, idx: "int const", value: "SoPath") -> "void":
        r"""set1Value(SoMFPath self, int const idx, SoPath value)"""
        return _coin.SoMFPath_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFPath") -> "SbBool":
        r"""__eq__(SoMFPath self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___eq__(self, field)

    def __ne__(self, field: "SoMFPath") -> "SbBool":
        r"""__ne__(SoMFPath self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___ne__(self, field)

    def startEditing(self) -> "SoPath **":
        r"""startEditing(SoMFPath self) -> SoPath **"""
        return _coin.SoMFPath_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFPath self)"""
        return _coin.SoMFPath_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFPath_initClass()

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoMFPath self, SoNotList l)"""
        return _coin.SoMFPath_notify(self, l)

    def fixCopy(self, copyconnections: "SbBool") -> "void":
        r"""fixCopy(SoMFPath self, SbBool copyconnections)"""
        return _coin.SoMFPath_fixCopy(self, copyconnections)

    def referencesCopy(self) -> "SbBool":
        r"""referencesCopy(SoMFPath self) -> SbBool"""
        return _coin.SoMFPath_referencesCopy(self)

    def deleteValues(self, start: "int", num: "int"=-1) -> "void":
        r"""deleteValues(SoMFPath self, int start, int num=-1)"""
        return _coin.SoMFPath_deleteValues(self, start, num)

    def insertSpace(self, start: "int", num: "int") -> "void":
        r"""insertSpace(SoMFPath self, int start, int num)"""
        return _coin.SoMFPath_insertSpace(self, start, num)

    def __getitem__(self, i: "int") -> "SoPath const *":
        r"""__getitem__(SoMFPath self, int i) -> SoPath"""
        return _coin.SoMFPath___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SoPath") -> "void":
        r"""__setitem__(SoMFPath self, int i, SoPath value)"""
        return _coin.SoMFPath___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFPath self, SoPath value)
        setValue(SoMFPath self, SoMFPath other)
        """
        return _coin.SoMFPath_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SoPath const **":
        r"""getValues(SoMFPath self, int i=0) -> SoPath"""
        return _coin.SoMFPath_getValues(self, i)

# Register SoMFPath in _coin:
_coin.SoMFPath_swigregister(SoMFPath)

def SoMFPath_createInstance() -> "void *":
    r"""SoMFPath_createInstance() -> void *"""
    return _coin.SoMFPath_createInstance()

def SoMFPath_getClassTypeId() -> "SoType":
    r"""SoMFPath_getClassTypeId() -> SoType"""
    return _coin.SoMFPath_getClassTypeId()

def SoMFPath_initClass() -> "void":
    r"""SoMFPath_initClass()"""
    return _coin.SoMFPath_initClass()

class SoMFPlane(SoMField):
    r"""Proxy of C++ SoMFPlane class."""

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

    def __init__(self):
        r"""__init__(SoMFPlane self) -> SoMFPlane"""
        _coin.SoMFPlane_swiginit(self, _coin.new_SoMFPlane())
    __swig_destroy__ = _coin.delete_SoMFPlane

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFPlane_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFPlane_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFPlane self) -> SoType"""
        return _coin.SoMFPlane_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFPlane self, SoField field)"""
        return _coin.SoMFPlane_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFPlane self, SoField field) -> SbBool"""
        return _coin.SoMFPlane_isSame(self, field)

    def find(self, value: "SbPlane", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFPlane self, SbPlane value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFPlane_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFPlane_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFPlane_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFPlane_setValues(*args)



    def set1Value(self, idx: "int const", value: "SbPlane") -> "void":
        r"""set1Value(SoMFPlane self, int const idx, SbPlane value)"""
        return _coin.SoMFPlane_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFPlane") -> "SbBool":
        r"""__eq__(SoMFPlane self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___eq__(self, field)

    def __ne__(self, field: "SoMFPlane") -> "SbBool":
        r"""__ne__(SoMFPlane self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___ne__(self, field)

    def startEditing(self) -> "SbPlane *":
        r"""startEditing(SoMFPlane self) -> SbPlane"""
        return _coin.SoMFPlane_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFPlane self)"""
        return _coin.SoMFPlane_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFPlane_initClass()

    def __getitem__(self, i: "int") -> "SbPlane const &":
        r"""__getitem__(SoMFPlane self, int i) -> SbPlane"""
        return _coin.SoMFPlane___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbPlane") -> "void":
        r"""__setitem__(SoMFPlane self, int i, SbPlane value)"""
        return _coin.SoMFPlane___setitem__(self, i, value)

    def getValues(self, i: "int"=0) -> "SbPlane const *":
        r"""getValues(SoMFPlane self, int i=0) -> SbPlane"""
        return _coin.SoMFPlane_getValues(self, i)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFPlane self, SbPlane value)
        setValue(SoMFPlane self, SoMFPlane other)
        """
        return _coin.SoMFPlane_setValue(self, *args)

# Register SoMFPlane in _coin:
_coin.SoMFPlane_swigregister(SoMFPlane)

def SoMFPlane_createInstance() -> "void *":
    r"""SoMFPlane_createInstance() -> void *"""
    return _coin.SoMFPlane_createInstance()

def SoMFPlane_getClassTypeId() -> "SoType":
    r"""SoMFPlane_getClassTypeId() -> SoType"""
    return _coin.SoMFPlane_getClassTypeId()

def SoMFPlane_initClass() -> "void":
    r"""SoMFPlane_initClass()"""
    return _coin.SoMFPlane_initClass()

class SoMFShort(SoMField):
    r"""Proxy of C++ SoMFShort class."""

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

    def __init__(self):
        r"""__init__(SoMFShort self) -> SoMFShort"""
        _coin.SoMFShort_swiginit(self, _coin.new_SoMFShort())
    __swig_destroy__ = _coin.delete_SoMFShort

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFShort_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFShort_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFShort self) -> SoType"""
        return _coin.SoMFShort_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFShort self, SoField field)"""
        return _coin.SoMFShort_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFShort self, SoField field) -> SbBool"""
        return _coin.SoMFShort_isSame(self, field)

    def find(self, value: "short", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFShort self, short value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFShort_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFShort_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFShort_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFShort_setValues(*args)



    def set1Value(self, idx: "int const", value: "short") -> "void":
        r"""set1Value(SoMFShort self, int const idx, short value)"""
        return _coin.SoMFShort_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFShort") -> "SbBool":
        r"""__eq__(SoMFShort self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___eq__(self, field)

    def __ne__(self, field: "SoMFShort") -> "SbBool":
        r"""__ne__(SoMFShort self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___ne__(self, field)

    def startEditing(self) -> "short *":
        r"""startEditing(SoMFShort self) -> short *"""
        return _coin.SoMFShort_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFShort self)"""
        return _coin.SoMFShort_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFShort self, int const num, short const * userdata)
        setValuesPointer(SoMFShort self, int const num, short * userdata)
        """
        return _coin.SoMFShort_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFShort_initClass()

    def __getitem__(self, i: "int") -> "short const":
        r"""__getitem__(SoMFShort self, int i) -> short const"""
        return _coin.SoMFShort___getitem__(self, i)

    def __setitem__(self, i: "int", value: "short") -> "void":
        r"""__setitem__(SoMFShort self, int i, short value)"""
        return _coin.SoMFShort___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFShort self, short value)
        setValue(SoMFShort self, SoMFShort other)
        """
        return _coin.SoMFShort_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "short const *":
        r"""getValues(SoMFShort self, int i=0) -> short const"""
        return _coin.SoMFShort_getValues(self, i)

# Register SoMFShort in _coin:
_coin.SoMFShort_swigregister(SoMFShort)

def SoMFShort_createInstance() -> "void *":
    r"""SoMFShort_createInstance() -> void *"""
    return _coin.SoMFShort_createInstance()

def SoMFShort_getClassTypeId() -> "SoType":
    r"""SoMFShort_getClassTypeId() -> SoType"""
    return _coin.SoMFShort_getClassTypeId()

def SoMFShort_initClass() -> "void":
    r"""SoMFShort_initClass()"""
    return _coin.SoMFShort_initClass()

class SoMFTime(SoMField):
    r"""Proxy of C++ SoMFTime class."""

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

    def __init__(self):
        r"""__init__(SoMFTime self) -> SoMFTime"""
        _coin.SoMFTime_swiginit(self, _coin.new_SoMFTime())
    __swig_destroy__ = _coin.delete_SoMFTime

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFTime_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFTime_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFTime self) -> SoType"""
        return _coin.SoMFTime_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFTime self, SoField field)"""
        return _coin.SoMFTime_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFTime self, SoField field) -> SbBool"""
        return _coin.SoMFTime_isSame(self, field)

    def find(self, value: "SbTime", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFTime self, SbTime value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFTime_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFTime_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFTime_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFTime_setValues(*args)



    def set1Value(self, idx: "int const", value: "SbTime") -> "void":
        r"""set1Value(SoMFTime self, int const idx, SbTime value)"""
        return _coin.SoMFTime_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFTime") -> "SbBool":
        r"""__eq__(SoMFTime self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___eq__(self, field)

    def __ne__(self, field: "SoMFTime") -> "SbBool":
        r"""__ne__(SoMFTime self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___ne__(self, field)

    def startEditing(self) -> "SbTime *":
        r"""startEditing(SoMFTime self) -> SbTime"""
        return _coin.SoMFTime_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFTime self)"""
        return _coin.SoMFTime_finishEditing(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFTime_initClass()

    def __getitem__(self, i: "int") -> "SbTime const &":
        r"""__getitem__(SoMFTime self, int i) -> SbTime"""
        return _coin.SoMFTime___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbTime") -> "void":
        r"""__setitem__(SoMFTime self, int i, SbTime value)"""
        return _coin.SoMFTime___setitem__(self, i, value)

    def getValues(self, i: "int"=0) -> "SbTime const *":
        r"""getValues(SoMFTime self, int i=0) -> SbTime"""
        return _coin.SoMFTime_getValues(self, i)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFTime self, SbTime value)
        setValue(SoMFTime self, SoMFTime other)
        """
        return _coin.SoMFTime_setValue(self, *args)

# Register SoMFTime in _coin:
_coin.SoMFTime_swigregister(SoMFTime)

def SoMFTime_createInstance() -> "void *":
    r"""SoMFTime_createInstance() -> void *"""
    return _coin.SoMFTime_createInstance()

def SoMFTime_getClassTypeId() -> "SoType":
    r"""SoMFTime_getClassTypeId() -> SoType"""
    return _coin.SoMFTime_getClassTypeId()

def SoMFTime_initClass() -> "void":
    r"""SoMFTime_initClass()"""
    return _coin.SoMFTime_initClass()

class SoMFUInt32(SoMField):
    r"""Proxy of C++ SoMFUInt32 class."""

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

    def __init__(self):
        r"""__init__(SoMFUInt32 self) -> SoMFUInt32"""
        _coin.SoMFUInt32_swiginit(self, _coin.new_SoMFUInt32())
    __swig_destroy__ = _coin.delete_SoMFUInt32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFUInt32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFUInt32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFUInt32 self) -> SoType"""
        return _coin.SoMFUInt32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFUInt32 self, SoField field)"""
        return _coin.SoMFUInt32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFUInt32 self, SoField field) -> SbBool"""
        return _coin.SoMFUInt32_isSame(self, field)

    def find(self, value: "uint32_t", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFUInt32 self, uint32_t value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFUInt32_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFUInt32):
             val = args[1].getValues()
             return _coin.SoMFUInt32_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFUInt32_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFUInt32):
             val = args[2].getValues()
             return _coin.SoMFUInt32_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFUInt32_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFUInt32_setValues(*args)



    def set1Value(self, idx: "int const", value: "uint32_t") -> "void":
        r"""set1Value(SoMFUInt32 self, int const idx, uint32_t value)"""
        return _coin.SoMFUInt32_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFUInt32") -> "SbBool":
        r"""__eq__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___eq__(self, field)

    def __ne__(self, field: "SoMFUInt32") -> "SbBool":
        r"""__ne__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___ne__(self, field)

    def startEditing(self) -> "uint32_t *":
        r"""startEditing(SoMFUInt32 self) -> uint32_t *"""
        return _coin.SoMFUInt32_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFUInt32 self)"""
        return _coin.SoMFUInt32_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFUInt32 self, int const num, uint32_t const * userdata)
        setValuesPointer(SoMFUInt32 self, int const num, uint32_t * userdata)
        """
        return _coin.SoMFUInt32_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFUInt32_initClass()

    def __getitem__(self, i: "int") -> "uint32_t const":
        r"""__getitem__(SoMFUInt32 self, int i) -> uint32_t const"""
        return _coin.SoMFUInt32___getitem__(self, i)

    def __setitem__(self, i: "int", value: "uint32_t") -> "void":
        r"""__setitem__(SoMFUInt32 self, int i, uint32_t value)"""
        return _coin.SoMFUInt32___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFUInt32 self, uint32_t value)
        setValue(SoMFUInt32 self, SoMFUInt32 other)
        """
        return _coin.SoMFUInt32_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "uint32_t const *":
        r"""getValues(SoMFUInt32 self, int i=0) -> uint32_t const"""
        return _coin.SoMFUInt32_getValues(self, i)

# Register SoMFUInt32 in _coin:
_coin.SoMFUInt32_swigregister(SoMFUInt32)

def SoMFUInt32_createInstance() -> "void *":
    r"""SoMFUInt32_createInstance() -> void *"""
    return _coin.SoMFUInt32_createInstance()

def SoMFUInt32_getClassTypeId() -> "SoType":
    r"""SoMFUInt32_getClassTypeId() -> SoType"""
    return _coin.SoMFUInt32_getClassTypeId()

def SoMFUInt32_initClass() -> "void":
    r"""SoMFUInt32_initClass()"""
    return _coin.SoMFUInt32_initClass()

class SoMFUShort(SoMField):
    r"""Proxy of C++ SoMFUShort class."""

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

    def __init__(self):
        r"""__init__(SoMFUShort self) -> SoMFUShort"""
        _coin.SoMFUShort_swiginit(self, _coin.new_SoMFUShort())
    __swig_destroy__ = _coin.delete_SoMFUShort

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFUShort_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFUShort_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFUShort self) -> SoType"""
        return _coin.SoMFUShort_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFUShort self, SoField field)"""
        return _coin.SoMFUShort_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFUShort self, SoField field) -> SbBool"""
        return _coin.SoMFUShort_isSame(self, field)

    def find(self, value: "unsigned short", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFUShort self, unsigned short value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFUShort_find(self, value, addifnotfound)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFUShort_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFUShort_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFUShort_setValues(*args)



    def set1Value(self, idx: "int const", value: "unsigned short") -> "void":
        r"""set1Value(SoMFUShort self, int const idx, unsigned short value)"""
        return _coin.SoMFUShort_set1Value(self, idx, value)

    def __eq__(self, field: "SoMFUShort") -> "SbBool":
        r"""__eq__(SoMFUShort self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___eq__(self, field)

    def __ne__(self, field: "SoMFUShort") -> "SbBool":
        r"""__ne__(SoMFUShort self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___ne__(self, field)

    def startEditing(self) -> "unsigned short *":
        r"""startEditing(SoMFUShort self) -> unsigned short *"""
        return _coin.SoMFUShort_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFUShort self)"""
        return _coin.SoMFUShort_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFUShort self, int const num, unsigned short const * userdata)
        setValuesPointer(SoMFUShort self, int const num, unsigned short * userdata)
        """
        return _coin.SoMFUShort_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFUShort_initClass()

    def __getitem__(self, i: "int") -> "short const":
        r"""__getitem__(SoMFUShort self, int i) -> short const"""
        return _coin.SoMFUShort___getitem__(self, i)

    def __setitem__(self, i: "int", value: "short") -> "void":
        r"""__setitem__(SoMFUShort self, int i, short value)"""
        return _coin.SoMFUShort___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFUShort self, unsigned short value)
        setValue(SoMFUShort self, SoMFUShort other)
        """
        return _coin.SoMFUShort_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "unsigned short const *":
        r"""getValues(SoMFUShort self, int i=0) -> unsigned short const"""
        return _coin.SoMFUShort_getValues(self, i)

# Register SoMFUShort in _coin:
_coin.SoMFUShort_swigregister(SoMFUShort)

def SoMFUShort_createInstance() -> "void *":
    r"""SoMFUShort_createInstance() -> void *"""
    return _coin.SoMFUShort_createInstance()

def SoMFUShort_getClassTypeId() -> "SoType":
    r"""SoMFUShort_getClassTypeId() -> SoType"""
    return _coin.SoMFUShort_getClassTypeId()

def SoMFUShort_initClass() -> "void":
    r"""SoMFUShort_initClass()"""
    return _coin.SoMFUShort_initClass()

class SoMFVec2b(SoMField):
    r"""Proxy of C++ SoMFVec2b class."""

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

    def __init__(self):
        r"""__init__(SoMFVec2b self) -> SoMFVec2b"""
        _coin.SoMFVec2b_swiginit(self, _coin.new_SoMFVec2b())
    __swig_destroy__ = _coin.delete_SoMFVec2b

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2b_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2b_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec2b self) -> SoType"""
        return _coin.SoMFVec2b_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec2b self, SoField field)"""
        return _coin.SoMFVec2b_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec2b self, SoField field) -> SbBool"""
        return _coin.SoMFVec2b_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec2b const *":
        r"""getValues(SoMFVec2b self, int const start) -> SbVec2b"""
        return _coin.SoMFVec2b_getValues(self, start)

    def find(self, value: "SbVec2b", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec2b self, SbVec2b value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2b_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec2b") -> "SbBool":
        r"""__eq__(SoMFVec2b self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___eq__(self, field)

    def __ne__(self, field: "SoMFVec2b") -> "SbBool":
        r"""__ne__(SoMFVec2b self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___ne__(self, field)

    def startEditing(self) -> "SbVec2b *":
        r"""startEditing(SoMFVec2b self) -> SbVec2b"""
        return _coin.SoMFVec2b_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec2b self)"""
        return _coin.SoMFVec2b_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec2b self, int const num, SbVec2b userdata)
        setValuesPointer(SoMFVec2b self, int const num, SbVec2b userdata)
        setValuesPointer(SoMFVec2b self, int const num, int8_t const * userdata)
        setValuesPointer(SoMFVec2b self, int const num, int8_t * userdata)
        """
        return _coin.SoMFVec2b_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec2b_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec2b self, int const start, int const num, SbVec2b newvals)
        setValues(SoMFVec2b self, int start, int num, int8_t const [][2] xy)
        """
        return _coin.SoMFVec2b_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec2b self, int const idx, SbVec2b value)
        set1Value(SoMFVec2b self, int idx, int8_t x, int8_t y)
        set1Value(SoMFVec2b self, int idx, int8_t const [2] xy)
        """
        return _coin.SoMFVec2b_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec2b self, SbVec2b value)
        setValue(SoMFVec2b self, int8_t x, int8_t y)
        setValue(SoMFVec2b self, int8_t const [2] xy)
        """
        return _coin.SoMFVec2b_setValue(self, *args)

# Register SoMFVec2b in _coin:
_coin.SoMFVec2b_swigregister(SoMFVec2b)

def SoMFVec2b_createInstance() -> "void *":
    r"""SoMFVec2b_createInstance() -> void *"""
    return _coin.SoMFVec2b_createInstance()

def SoMFVec2b_getClassTypeId() -> "SoType":
    r"""SoMFVec2b_getClassTypeId() -> SoType"""
    return _coin.SoMFVec2b_getClassTypeId()

def SoMFVec2b_initClass() -> "void":
    r"""SoMFVec2b_initClass()"""
    return _coin.SoMFVec2b_initClass()

class SoMFVec2s(SoMField):
    r"""Proxy of C++ SoMFVec2s class."""

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

    def __init__(self):
        r"""__init__(SoMFVec2s self) -> SoMFVec2s"""
        _coin.SoMFVec2s_swiginit(self, _coin.new_SoMFVec2s())
    __swig_destroy__ = _coin.delete_SoMFVec2s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec2s self) -> SoType"""
        return _coin.SoMFVec2s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec2s self, SoField field)"""
        return _coin.SoMFVec2s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec2s self, SoField field) -> SbBool"""
        return _coin.SoMFVec2s_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec2s const *":
        r"""getValues(SoMFVec2s self, int const start) -> SbVec2s"""
        return _coin.SoMFVec2s_getValues(self, start)

    def find(self, value: "SbVec2s", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec2s self, SbVec2s value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2s_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec2s") -> "SbBool":
        r"""__eq__(SoMFVec2s self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___eq__(self, field)

    def __ne__(self, field: "SoMFVec2s") -> "SbBool":
        r"""__ne__(SoMFVec2s self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___ne__(self, field)

    def startEditing(self) -> "SbVec2s *":
        r"""startEditing(SoMFVec2s self) -> SbVec2s"""
        return _coin.SoMFVec2s_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec2s self)"""
        return _coin.SoMFVec2s_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec2s self, int const num, SbVec2s userdata)
        setValuesPointer(SoMFVec2s self, int const num, SbVec2s userdata)
        setValuesPointer(SoMFVec2s self, int const num, short const * userdata)
        setValuesPointer(SoMFVec2s self, int const num, short * userdata)
        """
        return _coin.SoMFVec2s_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec2s_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec2s self, int const start, int const num, SbVec2s newvals)
        setValues(SoMFVec2s self, int start, int num, short const [][2] xy)
        """
        return _coin.SoMFVec2s_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec2s self, int const idx, SbVec2s value)
        set1Value(SoMFVec2s self, int idx, short x, short y)
        set1Value(SoMFVec2s self, int idx, short const [2] xy)
        """
        return _coin.SoMFVec2s_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec2s self, SbVec2s value)
        setValue(SoMFVec2s self, short x, short y)
        setValue(SoMFVec2s self, short const [2] xy)
        """
        return _coin.SoMFVec2s_setValue(self, *args)

# Register SoMFVec2s in _coin:
_coin.SoMFVec2s_swigregister(SoMFVec2s)

def SoMFVec2s_createInstance() -> "void *":
    r"""SoMFVec2s_createInstance() -> void *"""
    return _coin.SoMFVec2s_createInstance()

def SoMFVec2s_getClassTypeId() -> "SoType":
    r"""SoMFVec2s_getClassTypeId() -> SoType"""
    return _coin.SoMFVec2s_getClassTypeId()

def SoMFVec2s_initClass() -> "void":
    r"""SoMFVec2s_initClass()"""
    return _coin.SoMFVec2s_initClass()

class SoMFVec2i32(SoMField):
    r"""Proxy of C++ SoMFVec2i32 class."""

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

    def __init__(self):
        r"""__init__(SoMFVec2i32 self) -> SoMFVec2i32"""
        _coin.SoMFVec2i32_swiginit(self, _coin.new_SoMFVec2i32())
    __swig_destroy__ = _coin.delete_SoMFVec2i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec2i32 self) -> SoType"""
        return _coin.SoMFVec2i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec2i32 self, SoField field)"""
        return _coin.SoMFVec2i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec2i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec2i32_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec2i32 const *":
        r"""getValues(SoMFVec2i32 self, int const start) -> SbVec2i32"""
        return _coin.SoMFVec2i32_getValues(self, start)

    def find(self, value: "SbVec2i32", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec2i32 self, SbVec2i32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2i32_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec2i32") -> "SbBool":
        r"""__eq__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___eq__(self, field)

    def __ne__(self, field: "SoMFVec2i32") -> "SbBool":
        r"""__ne__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___ne__(self, field)

    def startEditing(self) -> "SbVec2i32 *":
        r"""startEditing(SoMFVec2i32 self) -> SbVec2i32"""
        return _coin.SoMFVec2i32_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec2i32 self)"""
        return _coin.SoMFVec2i32_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec2i32 self, int const num, SbVec2i32 userdata)
        setValuesPointer(SoMFVec2i32 self, int const num, SbVec2i32 userdata)
        setValuesPointer(SoMFVec2i32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFVec2i32 self, int const num, int32_t * userdata)
        """
        return _coin.SoMFVec2i32_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec2i32_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec2i32 self, int const start, int const num, SbVec2i32 newvals)
        setValues(SoMFVec2i32 self, int start, int num, int32_t const [][2] xy)
        """
        return _coin.SoMFVec2i32_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec2i32 self, int const idx, SbVec2i32 value)
        set1Value(SoMFVec2i32 self, int idx, int32_t x, int32_t y)
        set1Value(SoMFVec2i32 self, int idx, int32_t const [2] xy)
        """
        return _coin.SoMFVec2i32_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec2i32 self, SbVec2i32 value)
        setValue(SoMFVec2i32 self, int32_t x, int32_t y)
        setValue(SoMFVec2i32 self, int32_t const [2] xy)
        """
        return _coin.SoMFVec2i32_setValue(self, *args)

# Register SoMFVec2i32 in _coin:
_coin.SoMFVec2i32_swigregister(SoMFVec2i32)

def SoMFVec2i32_createInstance() -> "void *":
    r"""SoMFVec2i32_createInstance() -> void *"""
    return _coin.SoMFVec2i32_createInstance()

def SoMFVec2i32_getClassTypeId() -> "SoType":
    r"""SoMFVec2i32_getClassTypeId() -> SoType"""
    return _coin.SoMFVec2i32_getClassTypeId()

def SoMFVec2i32_initClass() -> "void":
    r"""SoMFVec2i32_initClass()"""
    return _coin.SoMFVec2i32_initClass()

class SoMFVec2d(SoMField):
    r"""Proxy of C++ SoMFVec2d class."""

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

    def __init__(self):
        r"""__init__(SoMFVec2d self) -> SoMFVec2d"""
        _coin.SoMFVec2d_swiginit(self, _coin.new_SoMFVec2d())
    __swig_destroy__ = _coin.delete_SoMFVec2d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec2d self) -> SoType"""
        return _coin.SoMFVec2d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec2d self, SoField field)"""
        return _coin.SoMFVec2d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec2d self, SoField field) -> SbBool"""
        return _coin.SoMFVec2d_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec2d const *":
        r"""getValues(SoMFVec2d self, int const start) -> SbVec2d"""
        return _coin.SoMFVec2d_getValues(self, start)

    def find(self, value: "SbVec2d", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec2d self, SbVec2d value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2d_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec2d") -> "SbBool":
        r"""__eq__(SoMFVec2d self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___eq__(self, field)

    def __ne__(self, field: "SoMFVec2d") -> "SbBool":
        r"""__ne__(SoMFVec2d self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___ne__(self, field)

    def startEditing(self) -> "SbVec2d *":
        r"""startEditing(SoMFVec2d self) -> SbVec2d"""
        return _coin.SoMFVec2d_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec2d self)"""
        return _coin.SoMFVec2d_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec2d self, int const num, SbVec2d userdata)
        setValuesPointer(SoMFVec2d self, int const num, SbVec2d userdata)
        setValuesPointer(SoMFVec2d self, int const num, double const * userdata)
        setValuesPointer(SoMFVec2d self, int const num, double * userdata)
        """
        return _coin.SoMFVec2d_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec2d_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec2d self, int const start, int const num, SbVec2d newvals)
        setValues(SoMFVec2d self, int start, int num, double const [][2] xy)
        """
        return _coin.SoMFVec2d_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec2d self, int const idx, SbVec2d value)
        set1Value(SoMFVec2d self, int idx, double x, double y)
        set1Value(SoMFVec2d self, int idx, double const [2] xy)
        """
        return _coin.SoMFVec2d_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec2d self, SbVec2d value)
        setValue(SoMFVec2d self, double x, double y)
        setValue(SoMFVec2d self, double const [2] xy)
        """
        return _coin.SoMFVec2d_setValue(self, *args)

# Register SoMFVec2d in _coin:
_coin.SoMFVec2d_swigregister(SoMFVec2d)

def SoMFVec2d_createInstance() -> "void *":
    r"""SoMFVec2d_createInstance() -> void *"""
    return _coin.SoMFVec2d_createInstance()

def SoMFVec2d_getClassTypeId() -> "SoType":
    r"""SoMFVec2d_getClassTypeId() -> SoType"""
    return _coin.SoMFVec2d_getClassTypeId()

def SoMFVec2d_initClass() -> "void":
    r"""SoMFVec2d_initClass()"""
    return _coin.SoMFVec2d_initClass()

class SoMFVec3b(SoMField):
    r"""Proxy of C++ SoMFVec3b class."""

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

    def __init__(self):
        r"""__init__(SoMFVec3b self) -> SoMFVec3b"""
        _coin.SoMFVec3b_swiginit(self, _coin.new_SoMFVec3b())
    __swig_destroy__ = _coin.delete_SoMFVec3b

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3b_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3b_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec3b self) -> SoType"""
        return _coin.SoMFVec3b_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec3b self, SoField field)"""
        return _coin.SoMFVec3b_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec3b self, SoField field) -> SbBool"""
        return _coin.SoMFVec3b_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec3b const *":
        r"""getValues(SoMFVec3b self, int const start) -> SbVec3b"""
        return _coin.SoMFVec3b_getValues(self, start)

    def find(self, value: "SbVec3b", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec3b self, SbVec3b value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3b_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec3b") -> "SbBool":
        r"""__eq__(SoMFVec3b self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___eq__(self, field)

    def __ne__(self, field: "SoMFVec3b") -> "SbBool":
        r"""__ne__(SoMFVec3b self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___ne__(self, field)

    def startEditing(self) -> "SbVec3b *":
        r"""startEditing(SoMFVec3b self) -> SbVec3b"""
        return _coin.SoMFVec3b_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec3b self)"""
        return _coin.SoMFVec3b_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec3b self, int const num, SbVec3b userdata)
        setValuesPointer(SoMFVec3b self, int const num, SbVec3b userdata)
        setValuesPointer(SoMFVec3b self, int const num, int8_t const * userdata)
        setValuesPointer(SoMFVec3b self, int const num, int8_t * userdata)
        """
        return _coin.SoMFVec3b_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec3b_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec3b self, int const start, int const num, SbVec3b newvals)
        setValues(SoMFVec3b self, int start, int num, int8_t const [][3] xyz)
        """
        return _coin.SoMFVec3b_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec3b self, int const idx, SbVec3b value)
        set1Value(SoMFVec3b self, int idx, int8_t x, int8_t y, int8_t z)
        set1Value(SoMFVec3b self, int idx, int8_t const [3] xyz)
        """
        return _coin.SoMFVec3b_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec3b self, SbVec3b value)
        setValue(SoMFVec3b self, int8_t x, int8_t y, int8_t z)
        setValue(SoMFVec3b self, int8_t const [3] xyz)
        """
        return _coin.SoMFVec3b_setValue(self, *args)

# Register SoMFVec3b in _coin:
_coin.SoMFVec3b_swigregister(SoMFVec3b)

def SoMFVec3b_createInstance() -> "void *":
    r"""SoMFVec3b_createInstance() -> void *"""
    return _coin.SoMFVec3b_createInstance()

def SoMFVec3b_getClassTypeId() -> "SoType":
    r"""SoMFVec3b_getClassTypeId() -> SoType"""
    return _coin.SoMFVec3b_getClassTypeId()

def SoMFVec3b_initClass() -> "void":
    r"""SoMFVec3b_initClass()"""
    return _coin.SoMFVec3b_initClass()

class SoMFVec3s(SoMField):
    r"""Proxy of C++ SoMFVec3s class."""

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

    def __init__(self):
        r"""__init__(SoMFVec3s self) -> SoMFVec3s"""
        _coin.SoMFVec3s_swiginit(self, _coin.new_SoMFVec3s())
    __swig_destroy__ = _coin.delete_SoMFVec3s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec3s self) -> SoType"""
        return _coin.SoMFVec3s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec3s self, SoField field)"""
        return _coin.SoMFVec3s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec3s self, SoField field) -> SbBool"""
        return _coin.SoMFVec3s_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec3s const *":
        r"""getValues(SoMFVec3s self, int const start) -> SbVec3s"""
        return _coin.SoMFVec3s_getValues(self, start)

    def find(self, value: "SbVec3s", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec3s self, SbVec3s value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3s_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec3s") -> "SbBool":
        r"""__eq__(SoMFVec3s self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___eq__(self, field)

    def __ne__(self, field: "SoMFVec3s") -> "SbBool":
        r"""__ne__(SoMFVec3s self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___ne__(self, field)

    def startEditing(self) -> "SbVec3s *":
        r"""startEditing(SoMFVec3s self) -> SbVec3s"""
        return _coin.SoMFVec3s_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec3s self)"""
        return _coin.SoMFVec3s_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec3s self, int const num, SbVec3s userdata)
        setValuesPointer(SoMFVec3s self, int const num, SbVec3s userdata)
        setValuesPointer(SoMFVec3s self, int const num, short const * userdata)
        setValuesPointer(SoMFVec3s self, int const num, short * userdata)
        """
        return _coin.SoMFVec3s_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec3s_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec3s self, int const start, int const num, SbVec3s newvals)
        setValues(SoMFVec3s self, int start, int num, short const [][3] xyz)
        """
        return _coin.SoMFVec3s_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec3s self, int const idx, SbVec3s value)
        set1Value(SoMFVec3s self, int idx, short x, short y, short z)
        set1Value(SoMFVec3s self, int idx, short const [3] xyz)
        """
        return _coin.SoMFVec3s_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec3s self, SbVec3s value)
        setValue(SoMFVec3s self, short x, short y, short z)
        setValue(SoMFVec3s self, short const [3] xyz)
        """
        return _coin.SoMFVec3s_setValue(self, *args)

# Register SoMFVec3s in _coin:
_coin.SoMFVec3s_swigregister(SoMFVec3s)

def SoMFVec3s_createInstance() -> "void *":
    r"""SoMFVec3s_createInstance() -> void *"""
    return _coin.SoMFVec3s_createInstance()

def SoMFVec3s_getClassTypeId() -> "SoType":
    r"""SoMFVec3s_getClassTypeId() -> SoType"""
    return _coin.SoMFVec3s_getClassTypeId()

def SoMFVec3s_initClass() -> "void":
    r"""SoMFVec3s_initClass()"""
    return _coin.SoMFVec3s_initClass()

class SoMFVec3i32(SoMField):
    r"""Proxy of C++ SoMFVec3i32 class."""

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

    def __init__(self):
        r"""__init__(SoMFVec3i32 self) -> SoMFVec3i32"""
        _coin.SoMFVec3i32_swiginit(self, _coin.new_SoMFVec3i32())
    __swig_destroy__ = _coin.delete_SoMFVec3i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec3i32 self) -> SoType"""
        return _coin.SoMFVec3i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec3i32 self, SoField field)"""
        return _coin.SoMFVec3i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec3i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec3i32_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec3i32 const *":
        r"""getValues(SoMFVec3i32 self, int const start) -> SbVec3i32"""
        return _coin.SoMFVec3i32_getValues(self, start)

    def find(self, value: "SbVec3i32", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec3i32 self, SbVec3i32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3i32_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec3i32") -> "SbBool":
        r"""__eq__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___eq__(self, field)

    def __ne__(self, field: "SoMFVec3i32") -> "SbBool":
        r"""__ne__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___ne__(self, field)

    def startEditing(self) -> "SbVec3i32 *":
        r"""startEditing(SoMFVec3i32 self) -> SbVec3i32"""
        return _coin.SoMFVec3i32_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec3i32 self)"""
        return _coin.SoMFVec3i32_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec3i32 self, int const num, SbVec3i32 userdata)
        setValuesPointer(SoMFVec3i32 self, int const num, SbVec3i32 userdata)
        setValuesPointer(SoMFVec3i32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFVec3i32 self, int const num, int32_t * userdata)
        """
        return _coin.SoMFVec3i32_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec3i32_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec3i32 self, int const start, int const num, SbVec3i32 newvals)
        setValues(SoMFVec3i32 self, int start, int num, int32_t const [][3] xyz)
        """
        return _coin.SoMFVec3i32_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec3i32 self, int const idx, SbVec3i32 value)
        set1Value(SoMFVec3i32 self, int idx, int32_t x, int32_t y, int32_t z)
        set1Value(SoMFVec3i32 self, int idx, int32_t const [3] xyz)
        """
        return _coin.SoMFVec3i32_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec3i32 self, SbVec3i32 value)
        setValue(SoMFVec3i32 self, int32_t x, int32_t y, int32_t z)
        setValue(SoMFVec3i32 self, int32_t const [3] xyz)
        """
        return _coin.SoMFVec3i32_setValue(self, *args)

# Register SoMFVec3i32 in _coin:
_coin.SoMFVec3i32_swigregister(SoMFVec3i32)

def SoMFVec3i32_createInstance() -> "void *":
    r"""SoMFVec3i32_createInstance() -> void *"""
    return _coin.SoMFVec3i32_createInstance()

def SoMFVec3i32_getClassTypeId() -> "SoType":
    r"""SoMFVec3i32_getClassTypeId() -> SoType"""
    return _coin.SoMFVec3i32_getClassTypeId()

def SoMFVec3i32_initClass() -> "void":
    r"""SoMFVec3i32_initClass()"""
    return _coin.SoMFVec3i32_initClass()

class SoMFVec3d(SoMField):
    r"""Proxy of C++ SoMFVec3d class."""

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

    def __init__(self):
        r"""__init__(SoMFVec3d self) -> SoMFVec3d"""
        _coin.SoMFVec3d_swiginit(self, _coin.new_SoMFVec3d())
    __swig_destroy__ = _coin.delete_SoMFVec3d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec3d self) -> SoType"""
        return _coin.SoMFVec3d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec3d self, SoField field)"""
        return _coin.SoMFVec3d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec3d self, SoField field) -> SbBool"""
        return _coin.SoMFVec3d_isSame(self, field)

    def find(self, value: "SbVec3d", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec3d self, SbVec3d value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3d_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec3d") -> "SbBool":
        r"""__eq__(SoMFVec3d self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___eq__(self, field)

    def __ne__(self, field: "SoMFVec3d") -> "SbBool":
        r"""__ne__(SoMFVec3d self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___ne__(self, field)

    def startEditing(self) -> "SbVec3d *":
        r"""startEditing(SoMFVec3d self) -> SbVec3d"""
        return _coin.SoMFVec3d_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec3d self)"""
        return _coin.SoMFVec3d_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec3d self, int const num, SbVec3d userdata)
        setValuesPointer(SoMFVec3d self, int const num, SbVec3d userdata)
        setValuesPointer(SoMFVec3d self, int const num, double const * userdata)
        setValuesPointer(SoMFVec3d self, int const num, double * userdata)
        """
        return _coin.SoMFVec3d_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec3d_initClass()

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec3d_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec3d_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec3d_setValues(*args)



    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec3d self, int const idx, SbVec3d value)
        set1Value(SoMFVec3d self, int idx, double x, double y, double z)
        set1Value(SoMFVec3d self, int idx, double const [3] xyz)
        """
        return _coin.SoMFVec3d_set1Value(self, *args)

    def __getitem__(self, i: "int") -> "SbVec3d const &":
        r"""__getitem__(SoMFVec3d self, int i) -> SbVec3d"""
        return _coin.SoMFVec3d___getitem__(self, i)

    def __setitem__(self, i: "int", value: "SbVec3d") -> "void":
        r"""__setitem__(SoMFVec3d self, int i, SbVec3d value)"""
        return _coin.SoMFVec3d___setitem__(self, i, value)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec3d self, SbVec3d value)
        setValue(SoMFVec3d self, double x, double y, double z)
        setValue(SoMFVec3d self, double const [3] xyz)
        setValue(SoMFVec3d self, SoMFVec3d other)
        """
        return _coin.SoMFVec3d_setValue(self, *args)

    def getValues(self, i: "int"=0) -> "SbVec3d const *":
        r"""getValues(SoMFVec3d self, int i=0) -> SbVec3d"""
        return _coin.SoMFVec3d_getValues(self, i)

# Register SoMFVec3d in _coin:
_coin.SoMFVec3d_swigregister(SoMFVec3d)

def SoMFVec3d_createInstance() -> "void *":
    r"""SoMFVec3d_createInstance() -> void *"""
    return _coin.SoMFVec3d_createInstance()

def SoMFVec3d_getClassTypeId() -> "SoType":
    r"""SoMFVec3d_getClassTypeId() -> SoType"""
    return _coin.SoMFVec3d_getClassTypeId()

def SoMFVec3d_initClass() -> "void":
    r"""SoMFVec3d_initClass()"""
    return _coin.SoMFVec3d_initClass()

class SoMFVec4b(SoMField):
    r"""Proxy of C++ SoMFVec4b class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4b self) -> SoMFVec4b"""
        _coin.SoMFVec4b_swiginit(self, _coin.new_SoMFVec4b())
    __swig_destroy__ = _coin.delete_SoMFVec4b

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4b_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4b_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4b self) -> SoType"""
        return _coin.SoMFVec4b_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4b self, SoField field)"""
        return _coin.SoMFVec4b_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4b self, SoField field) -> SbBool"""
        return _coin.SoMFVec4b_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec4b const *":
        r"""getValues(SoMFVec4b self, int const start) -> SbVec4b"""
        return _coin.SoMFVec4b_getValues(self, start)

    def find(self, value: "SbVec4b", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4b self, SbVec4b value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4b_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4b") -> "SbBool":
        r"""__eq__(SoMFVec4b self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___eq__(self, field)

    def __ne__(self, field: "SoMFVec4b") -> "SbBool":
        r"""__ne__(SoMFVec4b self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___ne__(self, field)

    def startEditing(self) -> "SbVec4b *":
        r"""startEditing(SoMFVec4b self) -> SbVec4b"""
        return _coin.SoMFVec4b_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4b self)"""
        return _coin.SoMFVec4b_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4b self, int const num, SbVec4b userdata)
        setValuesPointer(SoMFVec4b self, int const num, SbVec4b userdata)
        setValuesPointer(SoMFVec4b self, int const num, int8_t const * userdata)
        setValuesPointer(SoMFVec4b self, int const num, int8_t * userdata)
        """
        return _coin.SoMFVec4b_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4b_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec4b self, int const start, int const num, SbVec4b newvals)
        setValues(SoMFVec4b self, int start, int num, int8_t const [][4] xyzw)
        """
        return _coin.SoMFVec4b_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4b self, int const idx, SbVec4b value)
        set1Value(SoMFVec4b self, int idx, int8_t x, int8_t y, int8_t z, int8_t w)
        set1Value(SoMFVec4b self, int idx, int8_t const [4] xyzw)
        """
        return _coin.SoMFVec4b_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4b self, SbVec4b value)
        setValue(SoMFVec4b self, int8_t x, int8_t y, int8_t z, int8_t w)
        setValue(SoMFVec4b self, int8_t const [4] xyzw)
        """
        return _coin.SoMFVec4b_setValue(self, *args)

# Register SoMFVec4b in _coin:
_coin.SoMFVec4b_swigregister(SoMFVec4b)

def SoMFVec4b_createInstance() -> "void *":
    r"""SoMFVec4b_createInstance() -> void *"""
    return _coin.SoMFVec4b_createInstance()

def SoMFVec4b_getClassTypeId() -> "SoType":
    r"""SoMFVec4b_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4b_getClassTypeId()

def SoMFVec4b_initClass() -> "void":
    r"""SoMFVec4b_initClass()"""
    return _coin.SoMFVec4b_initClass()

class SoMFVec4ub(SoMField):
    r"""Proxy of C++ SoMFVec4ub class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4ub self) -> SoMFVec4ub"""
        _coin.SoMFVec4ub_swiginit(self, _coin.new_SoMFVec4ub())
    __swig_destroy__ = _coin.delete_SoMFVec4ub

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4ub_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4ub_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4ub self) -> SoType"""
        return _coin.SoMFVec4ub_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4ub self, SoField field)"""
        return _coin.SoMFVec4ub_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4ub self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ub_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec4ub const *":
        r"""getValues(SoMFVec4ub self, int const start) -> SbVec4ub"""
        return _coin.SoMFVec4ub_getValues(self, start)

    def find(self, value: "SbVec4ub", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4ub self, SbVec4ub value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4ub_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4ub") -> "SbBool":
        r"""__eq__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___eq__(self, field)

    def __ne__(self, field: "SoMFVec4ub") -> "SbBool":
        r"""__ne__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___ne__(self, field)

    def startEditing(self) -> "SbVec4ub *":
        r"""startEditing(SoMFVec4ub self) -> SbVec4ub"""
        return _coin.SoMFVec4ub_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4ub self)"""
        return _coin.SoMFVec4ub_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4ub self, int const num, SbVec4ub userdata)
        setValuesPointer(SoMFVec4ub self, int const num, SbVec4ub userdata)
        setValuesPointer(SoMFVec4ub self, int const num, uint8_t const * userdata)
        setValuesPointer(SoMFVec4ub self, int const num, uint8_t * userdata)
        """
        return _coin.SoMFVec4ub_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4ub_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec4ub self, int const start, int const num, SbVec4ub newvals)
        setValues(SoMFVec4ub self, int start, int num, uint8_t const [][4] xyzw)
        """
        return _coin.SoMFVec4ub_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4ub self, int const idx, SbVec4ub value)
        set1Value(SoMFVec4ub self, int idx, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        set1Value(SoMFVec4ub self, int idx, uint8_t const [4] xyzw)
        """
        return _coin.SoMFVec4ub_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4ub self, SbVec4ub value)
        setValue(SoMFVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        setValue(SoMFVec4ub self, uint8_t const [4] xyzw)
        """
        return _coin.SoMFVec4ub_setValue(self, *args)

# Register SoMFVec4ub in _coin:
_coin.SoMFVec4ub_swigregister(SoMFVec4ub)

def SoMFVec4ub_createInstance() -> "void *":
    r"""SoMFVec4ub_createInstance() -> void *"""
    return _coin.SoMFVec4ub_createInstance()

def SoMFVec4ub_getClassTypeId() -> "SoType":
    r"""SoMFVec4ub_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4ub_getClassTypeId()

def SoMFVec4ub_initClass() -> "void":
    r"""SoMFVec4ub_initClass()"""
    return _coin.SoMFVec4ub_initClass()

class SoMFVec4s(SoMField):
    r"""Proxy of C++ SoMFVec4s class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4s self) -> SoMFVec4s"""
        _coin.SoMFVec4s_swiginit(self, _coin.new_SoMFVec4s())
    __swig_destroy__ = _coin.delete_SoMFVec4s

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4s_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4s_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4s self) -> SoType"""
        return _coin.SoMFVec4s_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4s self, SoField field)"""
        return _coin.SoMFVec4s_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4s self, SoField field) -> SbBool"""
        return _coin.SoMFVec4s_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec4s const *":
        r"""getValues(SoMFVec4s self, int const start) -> SbVec4s"""
        return _coin.SoMFVec4s_getValues(self, start)

    def find(self, value: "SbVec4s", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4s self, SbVec4s value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4s_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4s") -> "SbBool":
        r"""__eq__(SoMFVec4s self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___eq__(self, field)

    def __ne__(self, field: "SoMFVec4s") -> "SbBool":
        r"""__ne__(SoMFVec4s self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___ne__(self, field)

    def startEditing(self) -> "SbVec4s *":
        r"""startEditing(SoMFVec4s self) -> SbVec4s"""
        return _coin.SoMFVec4s_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4s self)"""
        return _coin.SoMFVec4s_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4s self, int const num, SbVec4s userdata)
        setValuesPointer(SoMFVec4s self, int const num, SbVec4s userdata)
        setValuesPointer(SoMFVec4s self, int const num, short const * userdata)
        setValuesPointer(SoMFVec4s self, int const num, short * userdata)
        """
        return _coin.SoMFVec4s_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4s_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec4s self, int const start, int const num, SbVec4s newvals)
        setValues(SoMFVec4s self, int start, int num, short const [][4] xyzw)
        """
        return _coin.SoMFVec4s_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4s self, int const idx, SbVec4s value)
        set1Value(SoMFVec4s self, int idx, short x, short y, short z, short w)
        set1Value(SoMFVec4s self, int idx, short const [4] xyzw)
        """
        return _coin.SoMFVec4s_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4s self, SbVec4s value)
        setValue(SoMFVec4s self, short x, short y, short z, short w)
        setValue(SoMFVec4s self, short const [4] xyzw)
        """
        return _coin.SoMFVec4s_setValue(self, *args)

# Register SoMFVec4s in _coin:
_coin.SoMFVec4s_swigregister(SoMFVec4s)

def SoMFVec4s_createInstance() -> "void *":
    r"""SoMFVec4s_createInstance() -> void *"""
    return _coin.SoMFVec4s_createInstance()

def SoMFVec4s_getClassTypeId() -> "SoType":
    r"""SoMFVec4s_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4s_getClassTypeId()

def SoMFVec4s_initClass() -> "void":
    r"""SoMFVec4s_initClass()"""
    return _coin.SoMFVec4s_initClass()

class SoMFVec4us(SoMField):
    r"""Proxy of C++ SoMFVec4us class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4us self) -> SoMFVec4us"""
        _coin.SoMFVec4us_swiginit(self, _coin.new_SoMFVec4us())
    __swig_destroy__ = _coin.delete_SoMFVec4us

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4us_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4us_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4us self) -> SoType"""
        return _coin.SoMFVec4us_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4us self, SoField field)"""
        return _coin.SoMFVec4us_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4us self, SoField field) -> SbBool"""
        return _coin.SoMFVec4us_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec4us const *":
        r"""getValues(SoMFVec4us self, int const start) -> SbVec4us"""
        return _coin.SoMFVec4us_getValues(self, start)

    def find(self, value: "SbVec4us", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4us self, SbVec4us value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4us_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4us") -> "SbBool":
        r"""__eq__(SoMFVec4us self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___eq__(self, field)

    def __ne__(self, field: "SoMFVec4us") -> "SbBool":
        r"""__ne__(SoMFVec4us self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___ne__(self, field)

    def startEditing(self) -> "SbVec4us *":
        r"""startEditing(SoMFVec4us self) -> SbVec4us"""
        return _coin.SoMFVec4us_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4us self)"""
        return _coin.SoMFVec4us_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4us self, int const num, SbVec4us userdata)
        setValuesPointer(SoMFVec4us self, int const num, SbVec4us userdata)
        setValuesPointer(SoMFVec4us self, int const num, unsigned short const * userdata)
        setValuesPointer(SoMFVec4us self, int const num, unsigned short * userdata)
        """
        return _coin.SoMFVec4us_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4us_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec4us self, int const start, int const num, SbVec4us newvals)
        setValues(SoMFVec4us self, int start, int num, unsigned short const [][4] xyzw)
        """
        return _coin.SoMFVec4us_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4us self, int const idx, SbVec4us value)
        set1Value(SoMFVec4us self, int idx, unsigned short x, unsigned short y, unsigned short z, unsigned short w)
        set1Value(SoMFVec4us self, int idx, unsigned short const [4] xyzw)
        """
        return _coin.SoMFVec4us_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4us self, SbVec4us value)
        setValue(SoMFVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w)
        setValue(SoMFVec4us self, unsigned short const [4] xyzw)
        """
        return _coin.SoMFVec4us_setValue(self, *args)

# Register SoMFVec4us in _coin:
_coin.SoMFVec4us_swigregister(SoMFVec4us)

def SoMFVec4us_createInstance() -> "void *":
    r"""SoMFVec4us_createInstance() -> void *"""
    return _coin.SoMFVec4us_createInstance()

def SoMFVec4us_getClassTypeId() -> "SoType":
    r"""SoMFVec4us_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4us_getClassTypeId()

def SoMFVec4us_initClass() -> "void":
    r"""SoMFVec4us_initClass()"""
    return _coin.SoMFVec4us_initClass()

class SoMFVec4i32(SoMField):
    r"""Proxy of C++ SoMFVec4i32 class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4i32 self) -> SoMFVec4i32"""
        _coin.SoMFVec4i32_swiginit(self, _coin.new_SoMFVec4i32())
    __swig_destroy__ = _coin.delete_SoMFVec4i32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4i32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4i32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4i32 self) -> SoType"""
        return _coin.SoMFVec4i32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4i32 self, SoField field)"""
        return _coin.SoMFVec4i32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec4i32_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec4i32 const *":
        r"""getValues(SoMFVec4i32 self, int const start) -> SbVec4i32"""
        return _coin.SoMFVec4i32_getValues(self, start)

    def find(self, value: "SbVec4i32", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4i32 self, SbVec4i32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4i32_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4i32") -> "SbBool":
        r"""__eq__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___eq__(self, field)

    def __ne__(self, field: "SoMFVec4i32") -> "SbBool":
        r"""__ne__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___ne__(self, field)

    def startEditing(self) -> "SbVec4i32 *":
        r"""startEditing(SoMFVec4i32 self) -> SbVec4i32"""
        return _coin.SoMFVec4i32_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4i32 self)"""
        return _coin.SoMFVec4i32_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4i32 self, int const num, SbVec4i32 userdata)
        setValuesPointer(SoMFVec4i32 self, int const num, SbVec4i32 userdata)
        setValuesPointer(SoMFVec4i32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFVec4i32 self, int const num, int32_t * userdata)
        """
        return _coin.SoMFVec4i32_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4i32_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec4i32 self, int const start, int const num, SbVec4i32 newvals)
        setValues(SoMFVec4i32 self, int start, int num, int32_t const [][4] xyzw)
        """
        return _coin.SoMFVec4i32_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4i32 self, int const idx, SbVec4i32 value)
        set1Value(SoMFVec4i32 self, int idx, int32_t x, int32_t y, int32_t z, int32_t w)
        set1Value(SoMFVec4i32 self, int idx, int32_t const [4] xyzw)
        """
        return _coin.SoMFVec4i32_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4i32 self, SbVec4i32 value)
        setValue(SoMFVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w)
        setValue(SoMFVec4i32 self, int32_t const [4] xyzw)
        """
        return _coin.SoMFVec4i32_setValue(self, *args)

# Register SoMFVec4i32 in _coin:
_coin.SoMFVec4i32_swigregister(SoMFVec4i32)

def SoMFVec4i32_createInstance() -> "void *":
    r"""SoMFVec4i32_createInstance() -> void *"""
    return _coin.SoMFVec4i32_createInstance()

def SoMFVec4i32_getClassTypeId() -> "SoType":
    r"""SoMFVec4i32_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4i32_getClassTypeId()

def SoMFVec4i32_initClass() -> "void":
    r"""SoMFVec4i32_initClass()"""
    return _coin.SoMFVec4i32_initClass()

class SoMFVec4ui32(SoMField):
    r"""Proxy of C++ SoMFVec4ui32 class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4ui32 self) -> SoMFVec4ui32"""
        _coin.SoMFVec4ui32_swiginit(self, _coin.new_SoMFVec4ui32())
    __swig_destroy__ = _coin.delete_SoMFVec4ui32

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4ui32_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4ui32_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4ui32 self) -> SoType"""
        return _coin.SoMFVec4ui32_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4ui32 self, SoField field)"""
        return _coin.SoMFVec4ui32_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4ui32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ui32_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec4ui32 const *":
        r"""getValues(SoMFVec4ui32 self, int const start) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_getValues(self, start)

    def find(self, value: "SbVec4ui32", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4ui32 self, SbVec4ui32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4ui32_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4ui32") -> "SbBool":
        r"""__eq__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___eq__(self, field)

    def __ne__(self, field: "SoMFVec4ui32") -> "SbBool":
        r"""__ne__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___ne__(self, field)

    def startEditing(self) -> "SbVec4ui32 *":
        r"""startEditing(SoMFVec4ui32 self) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4ui32 self)"""
        return _coin.SoMFVec4ui32_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4ui32 self, int const num, SbVec4ui32 userdata)
        setValuesPointer(SoMFVec4ui32 self, int const num, SbVec4ui32 userdata)
        setValuesPointer(SoMFVec4ui32 self, int const num, uint32_t const * userdata)
        setValuesPointer(SoMFVec4ui32 self, int const num, uint32_t * userdata)
        """
        return _coin.SoMFVec4ui32_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4ui32_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec4ui32 self, int const start, int const num, SbVec4ui32 newvals)
        setValues(SoMFVec4ui32 self, int start, int num, uint32_t const [][4] xyzw)
        """
        return _coin.SoMFVec4ui32_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4ui32 self, int const idx, SbVec4ui32 value)
        set1Value(SoMFVec4ui32 self, int idx, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        set1Value(SoMFVec4ui32 self, int idx, uint32_t const [4] xyzw)
        """
        return _coin.SoMFVec4ui32_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4ui32 self, SbVec4ui32 value)
        setValue(SoMFVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        setValue(SoMFVec4ui32 self, uint32_t const [4] xyzw)
        """
        return _coin.SoMFVec4ui32_setValue(self, *args)

# Register SoMFVec4ui32 in _coin:
_coin.SoMFVec4ui32_swigregister(SoMFVec4ui32)

def SoMFVec4ui32_createInstance() -> "void *":
    r"""SoMFVec4ui32_createInstance() -> void *"""
    return _coin.SoMFVec4ui32_createInstance()

def SoMFVec4ui32_getClassTypeId() -> "SoType":
    r"""SoMFVec4ui32_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4ui32_getClassTypeId()

def SoMFVec4ui32_initClass() -> "void":
    r"""SoMFVec4ui32_initClass()"""
    return _coin.SoMFVec4ui32_initClass()

class SoMFVec4d(SoMField):
    r"""Proxy of C++ SoMFVec4d class."""

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

    def __init__(self):
        r"""__init__(SoMFVec4d self) -> SoMFVec4d"""
        _coin.SoMFVec4d_swiginit(self, _coin.new_SoMFVec4d())
    __swig_destroy__ = _coin.delete_SoMFVec4d

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4d_createInstance()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4d_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMFVec4d self) -> SoType"""
        return _coin.SoMFVec4d_getTypeId(self)

    def copyFrom(self, field: "SoField") -> "void":
        r"""copyFrom(SoMFVec4d self, SoField field)"""
        return _coin.SoMFVec4d_copyFrom(self, field)

    def isSame(self, field: "SoField") -> "SbBool":
        r"""isSame(SoMFVec4d self, SoField field) -> SbBool"""
        return _coin.SoMFVec4d_isSame(self, field)

    def getValues(self, start: "int const") -> "SbVec4d const *":
        r"""getValues(SoMFVec4d self, int const start) -> SbVec4d"""
        return _coin.SoMFVec4d_getValues(self, start)

    def find(self, value: "SbVec4d", addifnotfound: "SbBool"=0) -> "int":
        r"""find(SoMFVec4d self, SbVec4d value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4d_find(self, value, addifnotfound)

    def __eq__(self, field: "SoMFVec4d") -> "SbBool":
        r"""__eq__(SoMFVec4d self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___eq__(self, field)

    def __ne__(self, field: "SoMFVec4d") -> "SbBool":
        r"""__ne__(SoMFVec4d self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___ne__(self, field)

    def startEditing(self) -> "SbVec4d *":
        r"""startEditing(SoMFVec4d self) -> SbVec4d"""
        return _coin.SoMFVec4d_startEditing(self)

    def finishEditing(self) -> "void":
        r"""finishEditing(SoMFVec4d self)"""
        return _coin.SoMFVec4d_finishEditing(self)

    def setValuesPointer(self, *args) -> "void":
        r"""
        setValuesPointer(SoMFVec4d self, int const num, SbVec4d userdata)
        setValuesPointer(SoMFVec4d self, int const num, SbVec4d userdata)
        setValuesPointer(SoMFVec4d self, int const num, double const * userdata)
        setValuesPointer(SoMFVec4d self, int const num, double * userdata)
        """
        return _coin.SoMFVec4d_setValuesPointer(self, *args)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMFVec4d_initClass()

    def setValues(self, *args) -> "void":
        r"""
        setValues(SoMFVec4d self, int const start, int const num, SbVec4d newvals)
        setValues(SoMFVec4d self, int start, int num, double const [][4] xyzw)
        """
        return _coin.SoMFVec4d_setValues(self, *args)

    def set1Value(self, *args) -> "void":
        r"""
        set1Value(SoMFVec4d self, int const idx, SbVec4d value)
        set1Value(SoMFVec4d self, int idx, double x, double y, double z, double w)
        set1Value(SoMFVec4d self, int idx, double const [4] xyzw)
        """
        return _coin.SoMFVec4d_set1Value(self, *args)

    def setValue(self, *args) -> "void":
        r"""
        setValue(SoMFVec4d self, SbVec4d value)
        setValue(SoMFVec4d self, double x, double y, double z, double w)
        setValue(SoMFVec4d self, double const [4] xyzw)
        """
        return _coin.SoMFVec4d_setValue(self, *args)

# Register SoMFVec4d in _coin:
_coin.SoMFVec4d_swigregister(SoMFVec4d)

def SoMFVec4d_createInstance() -> "void *":
    r"""SoMFVec4d_createInstance() -> void *"""
    return _coin.SoMFVec4d_createInstance()

def SoMFVec4d_getClassTypeId() -> "SoType":
    r"""SoMFVec4d_getClassTypeId() -> SoType"""
    return _coin.SoMFVec4d_getClassTypeId()

def SoMFVec4d_initClass() -> "void":
    r"""SoMFVec4d_initClass()"""
    return _coin.SoMFVec4d_initClass()

class SbStringList(SbPList):
    r"""Proxy of C++ SbStringList class."""

    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):
        r"""
        __init__(SbStringList self) -> SbStringList
        __init__(SbStringList self, int const sizehint) -> SbStringList
        """
        _coin.SbStringList_swiginit(self, _coin.new_SbStringList(*args))

    def append(self, string: "SbString") -> "void":
        r"""append(SbStringList self, SbString string)"""
        return _coin.SbStringList_append(self, string)

    def find(self, string: "SbString") -> "int":
        r"""find(SbStringList self, SbString string) -> int"""
        return _coin.SbStringList_find(self, string)

    def insert(self, string: "SbString", insertbefore: "int") -> "void":
        r"""insert(SbStringList self, SbString string, int insertbefore)"""
        return _coin.SbStringList_insert(self, string, insertbefore)

    def getArrayPtr(self) -> "SbString const **":
        r"""getArrayPtr(SbStringList self) -> SbString const **"""
        return _coin.SbStringList_getArrayPtr(self)

    def __setitem__(self, i: "int const", value: "SbString") -> "void":
        r"""__setitem__(SbStringList self, int const i, SbString value)"""
        return _coin.SbStringList___setitem__(self, i, value)

    def __getitem__(self, i: "int") -> "SbString *":
        r"""__getitem__(SbStringList self, int i) -> SbString"""
        return _coin.SbStringList___getitem__(self, i)

    def get(self, i: "int const") -> "SbString *":
        r"""get(SbStringList self, int const i) -> SbString"""
        return _coin.SbStringList_get(self, i)
    __swig_destroy__ = _coin.delete_SbStringList

# Register SbStringList in _coin:
_coin.SbStringList_swigregister(SbStringList)

class SbVec3fList(SbPList):
    r"""Proxy of C++ SbVec3fList class."""

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

    def __init__(self):
        r"""__init__(SbVec3fList self) -> SbVec3fList"""
        _coin.SbVec3fList_swiginit(self, _coin.new_SbVec3fList())
    __swig_destroy__ = _coin.delete_SbVec3fList

    def append(self, item: "SbVec3f") -> "void":
        r"""append(SbVec3fList self, SbVec3f item)"""
        return _coin.SbVec3fList_append(self, item)

    def insert(self, item: "SbVec3f", insertbefore: "int const") -> "void":
        r"""insert(SbVec3fList self, SbVec3f item, int const insertbefore)"""
        return _coin.SbVec3fList_insert(self, item, insertbefore)

    def __setitem__(self, i: "int const", value: "SbVec3f") -> "void":
        r"""__setitem__(SbVec3fList self, int const i, SbVec3f value)"""
        return _coin.SbVec3fList___setitem__(self, i, value)

    def __getitem__(self, i: "int") -> "SbVec3f *":
        r"""__getitem__(SbVec3fList self, int i) -> SbVec3f"""
        return _coin.SbVec3fList___getitem__(self, i)

    def get(self, i: "int const") -> "SbVec3f *":
        r"""get(SbVec3fList self, int const i) -> SbVec3f"""
        return _coin.SbVec3fList_get(self, i)

# Register SbVec3fList in _coin:
_coin.SbVec3fList_swigregister(SbVec3fList)

class SoLockManager(object):
    r"""Proxy of C++ SoLockManager class."""

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

    @staticmethod
    def SetUnlockString(unlockstr: "char *") -> "void":
        r"""SetUnlockString(char * unlockstr)"""
        return _coin.SoLockManager_SetUnlockString(unlockstr)

    @staticmethod
    def GetUnlockString() -> "char *":
        r"""GetUnlockString() -> char *"""
        return _coin.SoLockManager_GetUnlockString()

    def __init__(self):
        r"""__init__(SoLockManager self) -> SoLockManager"""
        _coin.SoLockManager_swiginit(self, _coin.new_SoLockManager())
    __swig_destroy__ = _coin.delete_SoLockManager

# Register SoLockManager in _coin:
_coin.SoLockManager_swigregister(SoLockManager)

def SoLockManager_SetUnlockString(unlockstr: "char *") -> "void":
    r"""SoLockManager_SetUnlockString(char * unlockstr)"""
    return _coin.SoLockManager_SetUnlockString(unlockstr)

def SoLockManager_GetUnlockString() -> "char *":
    r"""SoLockManager_GetUnlockString() -> char *"""
    return _coin.SoLockManager_GetUnlockString()

class SoTransform(SoTransformation):
    r"""Proxy of C++ SoTransform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransform self) -> SoType"""
        return _coin.SoTransform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransform_initClass()

    def __init__(self):
        r"""__init__(SoTransform self) -> SoTransform"""
        _coin.SoTransform_swiginit(self, _coin.new_SoTransform())
    translation = property(_coin.SoTransform_translation_get, _coin.SoTransform_translation_set, doc=r"""translation : SoSFVec3f""")
    rotation = property(_coin.SoTransform_rotation_get, _coin.SoTransform_rotation_set, doc=r"""rotation : SoSFRotation""")
    scaleFactor = property(_coin.SoTransform_scaleFactor_get, _coin.SoTransform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    scaleOrientation = property(_coin.SoTransform_scaleOrientation_get, _coin.SoTransform_scaleOrientation_set, doc=r"""scaleOrientation : SoSFRotation""")
    center = property(_coin.SoTransform_center_get, _coin.SoTransform_center_set, doc=r"""center : SoSFVec3f""")

    def pointAt(self, frompoint: "SbVec3f", topoint: "SbVec3f") -> "void":
        r"""pointAt(SoTransform self, SbVec3f frompoint, SbVec3f topoint)"""
        return _coin.SoTransform_pointAt(self, frompoint, topoint)

    def getScaleSpaceMatrix(self, mat: "SbMatrix", inv: "SbMatrix") -> "void":
        r"""getScaleSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getScaleSpaceMatrix(self, mat, inv)

    def getRotationSpaceMatrix(self, mat: "SbMatrix", inv: "SbMatrix") -> "void":
        r"""getRotationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getRotationSpaceMatrix(self, mat, inv)

    def getTranslationSpaceMatrix(self, mat: "SbMatrix", inv: "SbMatrix") -> "void":
        r"""getTranslationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getTranslationSpaceMatrix(self, mat, inv)

    def multLeft(self, mat: "SbMatrix") -> "void":
        r"""multLeft(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_multLeft(self, mat)

    def multRight(self, mat: "SbMatrix") -> "void":
        r"""multRight(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_multRight(self, mat)

    def combineLeft(self, nodeonright: "SoTransformation") -> "void":
        r"""combineLeft(SoTransform self, SoTransformation nodeonright)"""
        return _coin.SoTransform_combineLeft(self, nodeonright)

    def combineRight(self, nodeonleft: "SoTransformation") -> "void":
        r"""combineRight(SoTransform self, SoTransformation nodeonleft)"""
        return _coin.SoTransform_combineRight(self, nodeonleft)

    def setMatrix(self, mat: "SbMatrix") -> "void":
        r"""setMatrix(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_setMatrix(self, mat)

    def recenter(self, newcenter: "SbVec3f") -> "void":
        r"""recenter(SoTransform self, SbVec3f newcenter)"""
        return _coin.SoTransform_recenter(self, newcenter)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTransform self, SoAction action)"""
        return _coin.SoTransform_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTransform self, SoGLRenderAction action)"""
        return _coin.SoTransform_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTransform self, SoCallbackAction action)"""
        return _coin.SoTransform_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransform_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTransform self, SoGetMatrixAction action)"""
        return _coin.SoTransform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTransform self, SoPickAction action)"""
        return _coin.SoTransform_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransform_getPrimitiveCount(self, action)

# Register SoTransform in _coin:
_coin.SoTransform_swigregister(SoTransform)

def SoTransform_getClassTypeId() -> "SoType":
    r"""SoTransform_getClassTypeId() -> SoType"""
    return _coin.SoTransform_getClassTypeId()

def SoTransform_initClass() -> "void":
    r"""SoTransform_initClass()"""
    return _coin.SoTransform_initClass()

class SoTransformManip(SoTransform):
    r"""Proxy of C++ SoTransformManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformManip self) -> SoType"""
        return _coin.SoTransformManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformManip_initClass()

    def __init__(self):
        r"""__init__(SoTransformManip self) -> SoTransformManip"""
        _coin.SoTransformManip_swiginit(self, _coin.new_SoTransformManip())

    def getDragger(self) -> "SoDragger *":
        r"""getDragger(SoTransformManip self) -> SoDragger"""
        return _coin.SoTransformManip_getDragger(self)

    def replaceNode(self, p: "SoPath") -> "SbBool":
        r"""replaceNode(SoTransformManip self, SoPath p) -> SbBool"""
        return _coin.SoTransformManip_replaceNode(self, p)

    def replaceManip(self, p: "SoPath", newone: "SoTransform") -> "SbBool":
        r"""replaceManip(SoTransformManip self, SoPath p, SoTransform newone) -> SbBool"""
        return _coin.SoTransformManip_replaceManip(self, p, newone)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTransformManip self, SoAction action)"""
        return _coin.SoTransformManip_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTransformManip self, SoCallbackAction action)"""
        return _coin.SoTransformManip_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTransformManip self, SoGLRenderAction action)"""
        return _coin.SoTransformManip_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoTransformManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformManip_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTransformManip self, SoGetMatrixAction action)"""
        return _coin.SoTransformManip_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoTransformManip self, SoHandleEventAction action)"""
        return _coin.SoTransformManip_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTransformManip self, SoPickAction action)"""
        return _coin.SoTransformManip_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoTransformManip self, SoSearchAction action)"""
        return _coin.SoTransformManip_search(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoTransformManip self) -> SoChildList"""
        return _coin.SoTransformManip_getChildren(self)

# Register SoTransformManip in _coin:
_coin.SoTransformManip_swigregister(SoTransformManip)

def SoTransformManip_getClassTypeId() -> "SoType":
    r"""SoTransformManip_getClassTypeId() -> SoType"""
    return _coin.SoTransformManip_getClassTypeId()

def SoTransformManip_initClass() -> "void":
    r"""SoTransformManip_initClass()"""
    return _coin.SoTransformManip_initClass()

class SoCenterballManip(SoTransformManip):
    r"""Proxy of C++ SoCenterballManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCenterballManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCenterballManip self) -> SoType"""
        return _coin.SoCenterballManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCenterballManip_initClass()

    def __init__(self):
        r"""__init__(SoCenterballManip self) -> SoCenterballManip"""
        _coin.SoCenterballManip_swiginit(self, _coin.new_SoCenterballManip())

# Register SoCenterballManip in _coin:
_coin.SoCenterballManip_swigregister(SoCenterballManip)

def SoCenterballManip_getClassTypeId() -> "SoType":
    r"""SoCenterballManip_getClassTypeId() -> SoType"""
    return _coin.SoCenterballManip_getClassTypeId()

def SoCenterballManip_initClass() -> "void":
    r"""SoCenterballManip_initClass()"""
    return _coin.SoCenterballManip_initClass()

class SoClipPlane(SoNode):
    r"""Proxy of C++ SoClipPlane class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoClipPlane_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoClipPlane self) -> SoType"""
        return _coin.SoClipPlane_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoClipPlane_initClass()

    def __init__(self):
        r"""__init__(SoClipPlane self) -> SoClipPlane"""
        _coin.SoClipPlane_swiginit(self, _coin.new_SoClipPlane())
    plane = property(_coin.SoClipPlane_plane_get, _coin.SoClipPlane_plane_set, doc=r"""plane : SoSFPlane""")
    on = property(_coin.SoClipPlane_on_get, _coin.SoClipPlane_on_set, doc=r"""on : SoSFBool""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoClipPlane self, SoAction action)"""
        return _coin.SoClipPlane_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoClipPlane self, SoGLRenderAction action)"""
        return _coin.SoClipPlane_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoClipPlane self, SoCallbackAction action)"""
        return _coin.SoClipPlane_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoClipPlane self, SoPickAction action)"""
        return _coin.SoClipPlane_pick(self, action)

# Register SoClipPlane in _coin:
_coin.SoClipPlane_swigregister(SoClipPlane)

def SoClipPlane_getClassTypeId() -> "SoType":
    r"""SoClipPlane_getClassTypeId() -> SoType"""
    return _coin.SoClipPlane_getClassTypeId()

def SoClipPlane_initClass() -> "void":
    r"""SoClipPlane_initClass()"""
    return _coin.SoClipPlane_initClass()

class SoClipPlaneManip(SoClipPlane):
    r"""Proxy of C++ SoClipPlaneManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoClipPlaneManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoClipPlaneManip self) -> SoType"""
        return _coin.SoClipPlaneManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoClipPlaneManip_initClass()

    def __init__(self):
        r"""__init__(SoClipPlaneManip self) -> SoClipPlaneManip"""
        _coin.SoClipPlaneManip_swiginit(self, _coin.new_SoClipPlaneManip())

    def getDragger(self) -> "SoDragger *":
        r"""getDragger(SoClipPlaneManip self) -> SoDragger"""
        return _coin.SoClipPlaneManip_getDragger(self)

    def setValue(self, box: "SbBox3f", planenormal: "SbVec3f", draggerscalefactor: "float") -> "void":
        r"""setValue(SoClipPlaneManip self, SbBox3f box, SbVec3f planenormal, float draggerscalefactor)"""
        return _coin.SoClipPlaneManip_setValue(self, box, planenormal, draggerscalefactor)

    def replaceNode(self, p: "SoPath") -> "SbBool":
        r"""replaceNode(SoClipPlaneManip self, SoPath p) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceNode(self, p)

    def replaceManip(self, p: "SoPath", newone: "SoClipPlane") -> "SbBool":
        r"""replaceManip(SoClipPlaneManip self, SoPath p, SoClipPlane newone) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceManip(self, p, newone)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoClipPlaneManip self, SoAction action)"""
        return _coin.SoClipPlaneManip_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoClipPlaneManip self, SoCallbackAction action)"""
        return _coin.SoClipPlaneManip_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoClipPlaneManip self, SoGLRenderAction action)"""
        return _coin.SoClipPlaneManip_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoClipPlaneManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoClipPlaneManip_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoClipPlaneManip self, SoGetMatrixAction action)"""
        return _coin.SoClipPlaneManip_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoClipPlaneManip self, SoHandleEventAction action)"""
        return _coin.SoClipPlaneManip_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoClipPlaneManip self, SoPickAction action)"""
        return _coin.SoClipPlaneManip_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoClipPlaneManip self, SoSearchAction action)"""
        return _coin.SoClipPlaneManip_search(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoClipPlaneManip self) -> SoChildList"""
        return _coin.SoClipPlaneManip_getChildren(self)
    draggerPosition = property(_coin.SoClipPlaneManip_draggerPosition_get, _coin.SoClipPlaneManip_draggerPosition_set, doc=r"""draggerPosition : SoSFVec3f""")

# Register SoClipPlaneManip in _coin:
_coin.SoClipPlaneManip_swigregister(SoClipPlaneManip)

def SoClipPlaneManip_getClassTypeId() -> "SoType":
    r"""SoClipPlaneManip_getClassTypeId() -> SoType"""
    return _coin.SoClipPlaneManip_getClassTypeId()

def SoClipPlaneManip_initClass() -> "void":
    r"""SoClipPlaneManip_initClass()"""
    return _coin.SoClipPlaneManip_initClass()

class SoLight(SoNode):
    r"""Proxy of C++ SoLight class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLight self) -> SoType"""
        return _coin.SoLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLight_initClass()
    on = property(_coin.SoLight_on_get, _coin.SoLight_on_set, doc=r"""on : SoSFBool""")
    intensity = property(_coin.SoLight_intensity_get, _coin.SoLight_intensity_set, doc=r"""intensity : SoSFFloat""")
    color = property(_coin.SoLight_color_get, _coin.SoLight_color_set, doc=r"""color : SoSFColor""")

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoLight self, SoCallbackAction action)"""
        return _coin.SoLight_callback(self, action)

# Register SoLight in _coin:
_coin.SoLight_swigregister(SoLight)

def SoLight_getClassTypeId() -> "SoType":
    r"""SoLight_getClassTypeId() -> SoType"""
    return _coin.SoLight_getClassTypeId()

def SoLight_initClass() -> "void":
    r"""SoLight_initClass()"""
    return _coin.SoLight_initClass()

class SoDirectionalLight(SoLight):
    r"""Proxy of C++ SoDirectionalLight class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDirectionalLight self) -> SoType"""
        return _coin.SoDirectionalLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDirectionalLight_initClass()

    def __init__(self):
        r"""__init__(SoDirectionalLight self) -> SoDirectionalLight"""
        _coin.SoDirectionalLight_swiginit(self, _coin.new_SoDirectionalLight())
    direction = property(_coin.SoDirectionalLight_direction_get, _coin.SoDirectionalLight_direction_set, doc=r"""direction : SoSFVec3f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoDirectionalLight self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLight_GLRender(self, action)

# Register SoDirectionalLight in _coin:
_coin.SoDirectionalLight_swigregister(SoDirectionalLight)

def SoDirectionalLight_getClassTypeId() -> "SoType":
    r"""SoDirectionalLight_getClassTypeId() -> SoType"""
    return _coin.SoDirectionalLight_getClassTypeId()

def SoDirectionalLight_initClass() -> "void":
    r"""SoDirectionalLight_initClass()"""
    return _coin.SoDirectionalLight_initClass()

class SoDirectionalLightManip(SoDirectionalLight):
    r"""Proxy of C++ SoDirectionalLightManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLightManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDirectionalLightManip self) -> SoType"""
        return _coin.SoDirectionalLightManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDirectionalLightManip_initClass()

    def __init__(self):
        r"""__init__(SoDirectionalLightManip self) -> SoDirectionalLightManip"""
        _coin.SoDirectionalLightManip_swiginit(self, _coin.new_SoDirectionalLightManip())

    def getDragger(self) -> "SoDragger *":
        r"""getDragger(SoDirectionalLightManip self) -> SoDragger"""
        return _coin.SoDirectionalLightManip_getDragger(self)

    def replaceNode(self, path: "SoPath") -> "SbBool":
        r"""replaceNode(SoDirectionalLightManip self, SoPath path) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceNode(self, path)

    def replaceManip(self, path: "SoPath", newone: "SoDirectionalLight") -> "SbBool":
        r"""replaceManip(SoDirectionalLightManip self, SoPath path, SoDirectionalLight newone) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceManip(self, path, newone)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoDirectionalLightManip self, SoAction action)"""
        return _coin.SoDirectionalLightManip_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoDirectionalLightManip self, SoCallbackAction action)"""
        return _coin.SoDirectionalLightManip_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoDirectionalLightManip self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLightManip_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoDirectionalLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoDirectionalLightManip_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoDirectionalLightManip self, SoGetMatrixAction action)"""
        return _coin.SoDirectionalLightManip_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoDirectionalLightManip self, SoHandleEventAction action)"""
        return _coin.SoDirectionalLightManip_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoDirectionalLightManip self, SoPickAction action)"""
        return _coin.SoDirectionalLightManip_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoDirectionalLightManip self, SoSearchAction action)"""
        return _coin.SoDirectionalLightManip_search(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoDirectionalLightManip self) -> SoChildList"""
        return _coin.SoDirectionalLightManip_getChildren(self)

# Register SoDirectionalLightManip in _coin:
_coin.SoDirectionalLightManip_swigregister(SoDirectionalLightManip)

def SoDirectionalLightManip_getClassTypeId() -> "SoType":
    r"""SoDirectionalLightManip_getClassTypeId() -> SoType"""
    return _coin.SoDirectionalLightManip_getClassTypeId()

def SoDirectionalLightManip_initClass() -> "void":
    r"""SoDirectionalLightManip_initClass()"""
    return _coin.SoDirectionalLightManip_initClass()

class SoHandleBoxManip(SoTransformManip):
    r"""Proxy of C++ SoHandleBoxManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHandleBoxManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoHandleBoxManip self) -> SoType"""
        return _coin.SoHandleBoxManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoHandleBoxManip_initClass()

    def __init__(self):
        r"""__init__(SoHandleBoxManip self) -> SoHandleBoxManip"""
        _coin.SoHandleBoxManip_swiginit(self, _coin.new_SoHandleBoxManip())

# Register SoHandleBoxManip in _coin:
_coin.SoHandleBoxManip_swigregister(SoHandleBoxManip)

def SoHandleBoxManip_getClassTypeId() -> "SoType":
    r"""SoHandleBoxManip_getClassTypeId() -> SoType"""
    return _coin.SoHandleBoxManip_getClassTypeId()

def SoHandleBoxManip_initClass() -> "void":
    r"""SoHandleBoxManip_initClass()"""
    return _coin.SoHandleBoxManip_initClass()

class SoJackManip(SoTransformManip):
    r"""Proxy of C++ SoJackManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoJackManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoJackManip self) -> SoType"""
        return _coin.SoJackManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoJackManip_initClass()

    def __init__(self):
        r"""__init__(SoJackManip self) -> SoJackManip"""
        _coin.SoJackManip_swiginit(self, _coin.new_SoJackManip())

# Register SoJackManip in _coin:
_coin.SoJackManip_swigregister(SoJackManip)

def SoJackManip_getClassTypeId() -> "SoType":
    r"""SoJackManip_getClassTypeId() -> SoType"""
    return _coin.SoJackManip_getClassTypeId()

def SoJackManip_initClass() -> "void":
    r"""SoJackManip_initClass()"""
    return _coin.SoJackManip_initClass()

class SoPointLight(SoLight):
    r"""Proxy of C++ SoPointLight class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPointLight self) -> SoType"""
        return _coin.SoPointLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPointLight_initClass()

    def __init__(self):
        r"""__init__(SoPointLight self) -> SoPointLight"""
        _coin.SoPointLight_swiginit(self, _coin.new_SoPointLight())
    location = property(_coin.SoPointLight_location_get, _coin.SoPointLight_location_set, doc=r"""location : SoSFVec3f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoPointLight self, SoGLRenderAction action)"""
        return _coin.SoPointLight_GLRender(self, action)

# Register SoPointLight in _coin:
_coin.SoPointLight_swigregister(SoPointLight)

def SoPointLight_getClassTypeId() -> "SoType":
    r"""SoPointLight_getClassTypeId() -> SoType"""
    return _coin.SoPointLight_getClassTypeId()

def SoPointLight_initClass() -> "void":
    r"""SoPointLight_initClass()"""
    return _coin.SoPointLight_initClass()

class SoPointLightManip(SoPointLight):
    r"""Proxy of C++ SoPointLightManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointLightManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPointLightManip self) -> SoType"""
        return _coin.SoPointLightManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPointLightManip_initClass()

    def __init__(self):
        r"""__init__(SoPointLightManip self) -> SoPointLightManip"""
        _coin.SoPointLightManip_swiginit(self, _coin.new_SoPointLightManip())

    def getDragger(self) -> "SoDragger *":
        r"""getDragger(SoPointLightManip self) -> SoDragger"""
        return _coin.SoPointLightManip_getDragger(self)

    def replaceNode(self, path: "SoPath") -> "SbBool":
        r"""replaceNode(SoPointLightManip self, SoPath path) -> SbBool"""
        return _coin.SoPointLightManip_replaceNode(self, path)

    def replaceManip(self, path: "SoPath", newone: "SoPointLight") -> "SbBool":
        r"""replaceManip(SoPointLightManip self, SoPath path, SoPointLight newone) -> SbBool"""
        return _coin.SoPointLightManip_replaceManip(self, path, newone)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoPointLightManip self, SoAction action)"""
        return _coin.SoPointLightManip_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoPointLightManip self, SoCallbackAction action)"""
        return _coin.SoPointLightManip_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoPointLightManip self, SoGLRenderAction action)"""
        return _coin.SoPointLightManip_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoPointLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointLightManip_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoPointLightManip self, SoGetMatrixAction action)"""
        return _coin.SoPointLightManip_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoPointLightManip self, SoHandleEventAction action)"""
        return _coin.SoPointLightManip_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoPointLightManip self, SoPickAction action)"""
        return _coin.SoPointLightManip_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoPointLightManip self, SoSearchAction action)"""
        return _coin.SoPointLightManip_search(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoPointLightManip self) -> SoChildList"""
        return _coin.SoPointLightManip_getChildren(self)

# Register SoPointLightManip in _coin:
_coin.SoPointLightManip_swigregister(SoPointLightManip)

def SoPointLightManip_getClassTypeId() -> "SoType":
    r"""SoPointLightManip_getClassTypeId() -> SoType"""
    return _coin.SoPointLightManip_getClassTypeId()

def SoPointLightManip_initClass() -> "void":
    r"""SoPointLightManip_initClass()"""
    return _coin.SoPointLightManip_initClass()

class SoSpotLight(SoLight):
    r"""Proxy of C++ SoSpotLight class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpotLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSpotLight self) -> SoType"""
        return _coin.SoSpotLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSpotLight_initClass()

    def __init__(self):
        r"""__init__(SoSpotLight self) -> SoSpotLight"""
        _coin.SoSpotLight_swiginit(self, _coin.new_SoSpotLight())
    location = property(_coin.SoSpotLight_location_get, _coin.SoSpotLight_location_set, doc=r"""location : SoSFVec3f""")
    direction = property(_coin.SoSpotLight_direction_get, _coin.SoSpotLight_direction_set, doc=r"""direction : SoSFVec3f""")
    dropOffRate = property(_coin.SoSpotLight_dropOffRate_get, _coin.SoSpotLight_dropOffRate_set, doc=r"""dropOffRate : SoSFFloat""")
    cutOffAngle = property(_coin.SoSpotLight_cutOffAngle_get, _coin.SoSpotLight_cutOffAngle_set, doc=r"""cutOffAngle : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoSpotLight self, SoGLRenderAction action)"""
        return _coin.SoSpotLight_GLRender(self, action)

# Register SoSpotLight in _coin:
_coin.SoSpotLight_swigregister(SoSpotLight)

def SoSpotLight_getClassTypeId() -> "SoType":
    r"""SoSpotLight_getClassTypeId() -> SoType"""
    return _coin.SoSpotLight_getClassTypeId()

def SoSpotLight_initClass() -> "void":
    r"""SoSpotLight_initClass()"""
    return _coin.SoSpotLight_initClass()

class SoSpotLightManip(SoSpotLight):
    r"""Proxy of C++ SoSpotLightManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpotLightManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSpotLightManip self) -> SoType"""
        return _coin.SoSpotLightManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSpotLightManip_initClass()

    def __init__(self):
        r"""__init__(SoSpotLightManip self) -> SoSpotLightManip"""
        _coin.SoSpotLightManip_swiginit(self, _coin.new_SoSpotLightManip())

    def getDragger(self) -> "SoDragger *":
        r"""getDragger(SoSpotLightManip self) -> SoDragger"""
        return _coin.SoSpotLightManip_getDragger(self)

    def replaceNode(self, p: "SoPath") -> "SbBool":
        r"""replaceNode(SoSpotLightManip self, SoPath p) -> SbBool"""
        return _coin.SoSpotLightManip_replaceNode(self, p)

    def replaceManip(self, p: "SoPath", newone: "SoSpotLight") -> "SbBool":
        r"""replaceManip(SoSpotLightManip self, SoPath p, SoSpotLight newone) -> SbBool"""
        return _coin.SoSpotLightManip_replaceManip(self, p, newone)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoSpotLightManip self, SoAction action)"""
        return _coin.SoSpotLightManip_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoSpotLightManip self, SoCallbackAction action)"""
        return _coin.SoSpotLightManip_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoSpotLightManip self, SoGLRenderAction action)"""
        return _coin.SoSpotLightManip_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoSpotLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoSpotLightManip_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoSpotLightManip self, SoGetMatrixAction action)"""
        return _coin.SoSpotLightManip_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoSpotLightManip self, SoHandleEventAction action)"""
        return _coin.SoSpotLightManip_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoSpotLightManip self, SoPickAction action)"""
        return _coin.SoSpotLightManip_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoSpotLightManip self, SoSearchAction action)"""
        return _coin.SoSpotLightManip_search(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoSpotLightManip self) -> SoChildList"""
        return _coin.SoSpotLightManip_getChildren(self)

# Register SoSpotLightManip in _coin:
_coin.SoSpotLightManip_swigregister(SoSpotLightManip)

def SoSpotLightManip_getClassTypeId() -> "SoType":
    r"""SoSpotLightManip_getClassTypeId() -> SoType"""
    return _coin.SoSpotLightManip_getClassTypeId()

def SoSpotLightManip_initClass() -> "void":
    r"""SoSpotLightManip_initClass()"""
    return _coin.SoSpotLightManip_initClass()

class SoTabBoxManip(SoTransformManip):
    r"""Proxy of C++ SoTabBoxManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTabBoxManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTabBoxManip self) -> SoType"""
        return _coin.SoTabBoxManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTabBoxManip_initClass()

    def __init__(self):
        r"""__init__(SoTabBoxManip self) -> SoTabBoxManip"""
        _coin.SoTabBoxManip_swiginit(self, _coin.new_SoTabBoxManip())

# Register SoTabBoxManip in _coin:
_coin.SoTabBoxManip_swigregister(SoTabBoxManip)

def SoTabBoxManip_getClassTypeId() -> "SoType":
    r"""SoTabBoxManip_getClassTypeId() -> SoType"""
    return _coin.SoTabBoxManip_getClassTypeId()

def SoTabBoxManip_initClass() -> "void":
    r"""SoTabBoxManip_initClass()"""
    return _coin.SoTabBoxManip_initClass()

class SoTrackballManip(SoTransformManip):
    r"""Proxy of C++ SoTrackballManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTrackballManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTrackballManip self) -> SoType"""
        return _coin.SoTrackballManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTrackballManip_initClass()

    def __init__(self):
        r"""__init__(SoTrackballManip self) -> SoTrackballManip"""
        _coin.SoTrackballManip_swiginit(self, _coin.new_SoTrackballManip())

# Register SoTrackballManip in _coin:
_coin.SoTrackballManip_swigregister(SoTrackballManip)

def SoTrackballManip_getClassTypeId() -> "SoType":
    r"""SoTrackballManip_getClassTypeId() -> SoType"""
    return _coin.SoTrackballManip_getClassTypeId()

def SoTrackballManip_initClass() -> "void":
    r"""SoTrackballManip_initClass()"""
    return _coin.SoTrackballManip_initClass()

class SoTransformBoxManip(SoTransformManip):
    r"""Proxy of C++ SoTransformBoxManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformBoxManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformBoxManip self) -> SoType"""
        return _coin.SoTransformBoxManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformBoxManip_initClass()

    def __init__(self):
        r"""__init__(SoTransformBoxManip self) -> SoTransformBoxManip"""
        _coin.SoTransformBoxManip_swiginit(self, _coin.new_SoTransformBoxManip())

# Register SoTransformBoxManip in _coin:
_coin.SoTransformBoxManip_swigregister(SoTransformBoxManip)

def SoTransformBoxManip_getClassTypeId() -> "SoType":
    r"""SoTransformBoxManip_getClassTypeId() -> SoType"""
    return _coin.SoTransformBoxManip_getClassTypeId()

def SoTransformBoxManip_initClass() -> "void":
    r"""SoTransformBoxManip_initClass()"""
    return _coin.SoTransformBoxManip_initClass()

class SoTransformerManip(SoTransformManip):
    r"""Proxy of C++ SoTransformerManip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformerManip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformerManip self) -> SoType"""
        return _coin.SoTransformerManip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformerManip_initClass()

    def __init__(self):
        r"""__init__(SoTransformerManip self) -> SoTransformerManip"""
        _coin.SoTransformerManip_swiginit(self, _coin.new_SoTransformerManip())

    def isLocateHighlighting(self) -> "SbBool":
        r"""isLocateHighlighting(SoTransformerManip self) -> SbBool"""
        return _coin.SoTransformerManip_isLocateHighlighting(self)

    def setLocateHighlighting(self, onoff: "SbBool") -> "void":
        r"""setLocateHighlighting(SoTransformerManip self, SbBool onoff)"""
        return _coin.SoTransformerManip_setLocateHighlighting(self, onoff)

    def unsquishKnobs(self) -> "void":
        r"""unsquishKnobs(SoTransformerManip self)"""
        return _coin.SoTransformerManip_unsquishKnobs(self)

# Register SoTransformerManip in _coin:
_coin.SoTransformerManip_swigregister(SoTransformerManip)

def SoTransformerManip_getClassTypeId() -> "SoType":
    r"""SoTransformerManip_getClassTypeId() -> SoType"""
    return _coin.SoTransformerManip_getClassTypeId()

def SoTransformerManip_initClass() -> "void":
    r"""SoTransformerManip_initClass()"""
    return _coin.SoTransformerManip_initClass()

class SoAudioDevice(object):
    r"""Proxy of C++ SoAudioDevice class."""

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

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

    @staticmethod
    def instance() -> "SoAudioDevice *":
        r"""instance() -> SoAudioDevice"""
        return _coin.SoAudioDevice_instance()

    def init(self, devicetype: "SbString", devicename: "SbString") -> "SbBool":
        r"""init(SoAudioDevice self, SbString devicetype, SbString devicename) -> SbBool"""
        return _coin.SoAudioDevice_init(self, devicetype, devicename)

    def enable(self) -> "SbBool":
        r"""enable(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_enable(self)

    def disable(self) -> "void":
        r"""disable(SoAudioDevice self)"""
        return _coin.SoAudioDevice_disable(self)

    def isEnabled(self) -> "SbBool":
        r"""isEnabled(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_isEnabled(self)

    def haveSound(self) -> "SbBool":
        r"""haveSound(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_haveSound(self)

    def setGain(self, gain: "float") -> "void":
        r"""setGain(SoAudioDevice self, float gain)"""
        return _coin.SoAudioDevice_setGain(self, gain)

    def mute(self, mute: "SbBool"=1) -> "void":
        r"""mute(SoAudioDevice self, SbBool mute=1)"""
        return _coin.SoAudioDevice_mute(self, mute)

# Register SoAudioDevice in _coin:
_coin.SoAudioDevice_swigregister(SoAudioDevice)

def SoAudioDevice_instance() -> "SoAudioDevice *":
    r"""SoAudioDevice_instance() -> SoAudioDevice"""
    return _coin.SoAudioDevice_instance()

class SoByteStream(object):
    r"""Proxy of C++ SoByteStream class."""

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

    def __init__(self):
        r"""__init__(SoByteStream self) -> SoByteStream"""
        _coin.SoByteStream_swiginit(self, _coin.new_SoByteStream())
    __swig_destroy__ = _coin.delete_SoByteStream

    def convert(self, *args) -> "void":
        r"""
        convert(SoByteStream self, SoNode node, SbBool binary=1)
        convert(SoByteStream self, SoPath path, SbBool binary=1)
        convert(SoByteStream self, SoPathList pl, SbBool binary=1)
        """
        return _coin.SoByteStream_convert(self, *args)

    def getData(self) -> "void *":
        r"""getData(SoByteStream self) -> void *"""
        return _coin.SoByteStream_getData(self)

    def getNumBytes(self) -> "uint32_t":
        r"""getNumBytes(SoByteStream self) -> uint32_t"""
        return _coin.SoByteStream_getNumBytes(self)

    @staticmethod
    def unconvert(*args) -> "SoPathList *":
        r"""
        unconvert(SoByteStream stream) -> SoPathList
        unconvert(void * data, uint32_t bytesinstream) -> SoPathList
        """
        return _coin.SoByteStream_unconvert(*args)

    def copy(self, d: "void *", len: "size_t") -> "void":
        r"""copy(SoByteStream self, void * d, size_t len)"""
        return _coin.SoByteStream_copy(self, d, len)

    def isRawData(self) -> "SbBool":
        r"""isRawData(SoByteStream self) -> SbBool"""
        return _coin.SoByteStream_isRawData(self)

# Register SoByteStream in _coin:
_coin.SoByteStream_swigregister(SoByteStream)

def SoByteStream_unconvert(*args) -> "SoPathList *":
    r"""
    SoByteStream_unconvert(SoByteStream stream) -> SoPathList
    SoByteStream_unconvert(void * data, uint32_t bytesinstream) -> SoPathList
    """
    return _coin.SoByteStream_unconvert(*args)

class SoContextHandler(object):
    r"""Proxy of C++ SoContextHandler class."""

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

    @staticmethod
    def destructingContext(contextid: "uint32_t") -> "void":
        r"""destructingContext(uint32_t contextid)"""
        return _coin.SoContextHandler_destructingContext(contextid)

    @staticmethod
    def addContextDestructionCallback(func: "SoContextHandler::ContextDestructionCB *", closure: "void *") -> "void":
        r"""addContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
        return _coin.SoContextHandler_addContextDestructionCallback(func, closure)

    @staticmethod
    def removeContextDestructionCallback(func: "SoContextHandler::ContextDestructionCB *", closure: "void *") -> "void":
        r"""removeContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
        return _coin.SoContextHandler_removeContextDestructionCallback(func, closure)

    def __init__(self):
        r"""__init__(SoContextHandler self) -> SoContextHandler"""
        _coin.SoContextHandler_swiginit(self, _coin.new_SoContextHandler())
    __swig_destroy__ = _coin.delete_SoContextHandler

# Register SoContextHandler in _coin:
_coin.SoContextHandler_swigregister(SoContextHandler)

def SoContextHandler_destructingContext(contextid: "uint32_t") -> "void":
    r"""SoContextHandler_destructingContext(uint32_t contextid)"""
    return _coin.SoContextHandler_destructingContext(contextid)

def SoContextHandler_addContextDestructionCallback(func: "SoContextHandler::ContextDestructionCB *", closure: "void *") -> "void":
    r"""SoContextHandler_addContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
    return _coin.SoContextHandler_addContextDestructionCallback(func, closure)

def SoContextHandler_removeContextDestructionCallback(func: "SoContextHandler::ContextDestructionCB *", closure: "void *") -> "void":
    r"""SoContextHandler_removeContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
    return _coin.SoContextHandler_removeContextDestructionCallback(func, closure)

class SoGLImage(object):
    r"""Proxy of C++ SoGLImage class."""

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

    def __init__(self):
        r"""__init__(SoGLImage self) -> SoGLImage"""
        _coin.SoGLImage_swiginit(self, _coin.new_SoGLImage())

    def unref(self, state: "SoState"=None) -> "void":
        r"""unref(SoGLImage self, SoState state=None)"""
        return _coin.SoGLImage_unref(self, state)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLImage_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGLImage self) -> SoType"""
        return _coin.SoGLImage_getTypeId(self)

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(SoGLImage self, SoType type) -> SbBool"""
        return _coin.SoGLImage_isOfType(self, type)
    REPEAT = _coin.SoGLImage_REPEAT
    
    CLAMP = _coin.SoGLImage_CLAMP
    
    CLAMP_TO_EDGE = _coin.SoGLImage_CLAMP_TO_EDGE
    
    CLAMP_TO_BORDER = _coin.SoGLImage_CLAMP_TO_BORDER
    
    IMAGE = _coin.SoGLImage_IMAGE
    
    SUBIMAGE = _coin.SoGLImage_SUBIMAGE
    
    MIPMAP = _coin.SoGLImage_MIPMAP
    

    def setGLDisplayList(self, *args) -> "void":
        r"""setGLDisplayList(SoGLImage self, SoGLDisplayList dl, SoState state, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5)"""
        return _coin.SoGLImage_setGLDisplayList(self, *args)

    def setPBuffer(self, *args) -> "void":
        r"""setPBuffer(SoGLImage self, SoState state, void * context, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5)"""
        return _coin.SoGLImage_setPBuffer(self, *args)

    def setData(self, *args) -> "void":
        r"""
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, SoGLImage::Wrap const wrapr=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0, SoState createinstate=None)
        """
        return _coin.SoGLImage_setData(self, *args)
    SCALE_DOWN = _coin.SoGLImage_SCALE_DOWN
    
    NO_MIPMAP = _coin.SoGLImage_NO_MIPMAP
    
    LINEAR_MAG_FILTER = _coin.SoGLImage_LINEAR_MAG_FILTER
    
    LINEAR_MIN_FILTER = _coin.SoGLImage_LINEAR_MIN_FILTER
    
    LINEAR_MIPMAP_FILTER = _coin.SoGLImage_LINEAR_MIPMAP_FILTER
    
    FORCE_TRANSPARENCY_TRUE = _coin.SoGLImage_FORCE_TRANSPARENCY_TRUE
    
    FORCE_TRANSPARENCY_FALSE = _coin.SoGLImage_FORCE_TRANSPARENCY_FALSE
    
    FORCE_ALPHA_TEST_TRUE = _coin.SoGLImage_FORCE_ALPHA_TEST_TRUE
    
    FORCE_ALPHA_TEST_FALSE = _coin.SoGLImage_FORCE_ALPHA_TEST_FALSE
    
    INVINCIBLE = _coin.SoGLImage_INVINCIBLE
    
    RECTANGLE = _coin.SoGLImage_RECTANGLE
    
    COMPRESSED = _coin.SoGLImage_COMPRESSED
    
    USE_QUALITY_VALUE = _coin.SoGLImage_USE_QUALITY_VALUE
    

    def setFlags(self, flags: "uint32_t const") -> "void":
        r"""setFlags(SoGLImage self, uint32_t const flags)"""
        return _coin.SoGLImage_setFlags(self, flags)

    def getFlags(self) -> "uint32_t":
        r"""getFlags(SoGLImage self) -> uint32_t"""
        return _coin.SoGLImage_getFlags(self)

    def getImage(self) -> "SbImage const *":
        r"""getImage(SoGLImage self) -> SbImage"""
        return _coin.SoGLImage_getImage(self)

    def getGLDisplayList(self, state: "SoState") -> "SoGLDisplayList *":
        r"""getGLDisplayList(SoGLImage self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLImage_getGLDisplayList(self, state)

    def hasTransparency(self) -> "SbBool":
        r"""hasTransparency(SoGLImage self) -> SbBool"""
        return _coin.SoGLImage_hasTransparency(self)

    def useAlphaTest(self) -> "SbBool":
        r"""useAlphaTest(SoGLImage self) -> SbBool"""
        return _coin.SoGLImage_useAlphaTest(self)

    def getWrapS(self) -> "SoGLImage::Wrap":
        r"""getWrapS(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapS(self)

    def getWrapT(self) -> "SoGLImage::Wrap":
        r"""getWrapT(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapT(self)

    def getWrapR(self) -> "SoGLImage::Wrap":
        r"""getWrapR(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapR(self)

    def getQuality(self) -> "float":
        r"""getQuality(SoGLImage self) -> float"""
        return _coin.SoGLImage_getQuality(self)

    def getGLImageId(self) -> "uint32_t":
        r"""getGLImageId(SoGLImage self) -> uint32_t"""
        return _coin.SoGLImage_getGLImageId(self)

    @staticmethod
    def beginFrame(state: "SoState") -> "void":
        r"""beginFrame(SoState state)"""
        return _coin.SoGLImage_beginFrame(state)

    @staticmethod
    def tagImage(state: "SoState", image: "SoGLImage") -> "void":
        r"""tagImage(SoState state, SoGLImage image)"""
        return _coin.SoGLImage_tagImage(state, image)

    @staticmethod
    def endFrame(state: "SoState") -> "void":
        r"""endFrame(SoState state)"""
        return _coin.SoGLImage_endFrame(state)

    @staticmethod
    def setDisplayListMaxAge(maxage: "uint32_t const") -> "void":
        r"""setDisplayListMaxAge(uint32_t const maxage)"""
        return _coin.SoGLImage_setDisplayListMaxAge(maxage)

    @staticmethod
    def freeAllImages(state: "SoState"=None) -> "void":
        r"""freeAllImages(SoState state=None)"""
        return _coin.SoGLImage_freeAllImages(state)

    def setEndFrameCallback(self, cb: "void (*)(void *)", closure: "void *") -> "void":
        r"""setEndFrameCallback(SoGLImage self, void (*)(void *) cb, void * closure)"""
        return _coin.SoGLImage_setEndFrameCallback(self, cb, closure)

    def getNumFramesSinceUsed(self) -> "int":
        r"""getNumFramesSinceUsed(SoGLImage self) -> int"""
        return _coin.SoGLImage_getNumFramesSinceUsed(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLImage_initClass()

    @staticmethod
    def setResizeCallback(f: "SoGLImage::SoGLImageResizeCB *", closure: "void *") -> "void":
        r"""setResizeCallback(SoGLImage::SoGLImageResizeCB * f, void * closure)"""
        return _coin.SoGLImage_setResizeCallback(f, closure)

# Register SoGLImage in _coin:
_coin.SoGLImage_swigregister(SoGLImage)

def SoGLImage_getClassTypeId() -> "SoType":
    r"""SoGLImage_getClassTypeId() -> SoType"""
    return _coin.SoGLImage_getClassTypeId()

def SoGLImage_beginFrame(state: "SoState") -> "void":
    r"""SoGLImage_beginFrame(SoState state)"""
    return _coin.SoGLImage_beginFrame(state)

def SoGLImage_tagImage(state: "SoState", image: "SoGLImage") -> "void":
    r"""SoGLImage_tagImage(SoState state, SoGLImage image)"""
    return _coin.SoGLImage_tagImage(state, image)

def SoGLImage_endFrame(state: "SoState") -> "void":
    r"""SoGLImage_endFrame(SoState state)"""
    return _coin.SoGLImage_endFrame(state)

def SoGLImage_setDisplayListMaxAge(maxage: "uint32_t const") -> "void":
    r"""SoGLImage_setDisplayListMaxAge(uint32_t const maxage)"""
    return _coin.SoGLImage_setDisplayListMaxAge(maxage)

def SoGLImage_freeAllImages(state: "SoState"=None) -> "void":
    r"""SoGLImage_freeAllImages(SoState state=None)"""
    return _coin.SoGLImage_freeAllImages(state)

def SoGLImage_initClass() -> "void":
    r"""SoGLImage_initClass()"""
    return _coin.SoGLImage_initClass()

def SoGLImage_setResizeCallback(f: "SoGLImage::SoGLImageResizeCB *", closure: "void *") -> "void":
    r"""SoGLImage_setResizeCallback(SoGLImage::SoGLImageResizeCB * f, void * closure)"""
    return _coin.SoGLImage_setResizeCallback(f, closure)

class SoGLBigImage(SoGLImage):
    r"""Proxy of C++ SoGLBigImage class."""

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

    def __init__(self):
        r"""__init__(SoGLBigImage self) -> SoGLBigImage"""
        _coin.SoGLBigImage_swiginit(self, _coin.new_SoGLBigImage())

    def unref(self, state: "SoState"=None) -> "void":
        r"""unref(SoGLBigImage self, SoState state=None)"""
        return _coin.SoGLBigImage_unref(self, state)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLBigImage_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGLBigImage self) -> SoType"""
        return _coin.SoGLBigImage_getTypeId(self)

    def setData(self, *args) -> "void":
        r"""
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0, SoState createinstate=None)
        """
        return _coin.SoGLBigImage_setData(self, *args)

    def initSubImages(self, subimagesize: "SbVec2s") -> "int":
        r"""initSubImages(SoGLBigImage self, SbVec2s subimagesize) -> int"""
        return _coin.SoGLBigImage_initSubImages(self, subimagesize)

    def handleSubImage(self, idx: "int const", start: "SbVec2f", end: "SbVec2f", tcmul: "SbVec2f") -> "void":
        r"""handleSubImage(SoGLBigImage self, int const idx, SbVec2f start, SbVec2f end, SbVec2f tcmul)"""
        return _coin.SoGLBigImage_handleSubImage(self, idx, start, end, tcmul)

    def applySubImage(self, state: "SoState", idx: "int const", quality: "float const", projsize: "SbVec2s") -> "void":
        r"""applySubImage(SoGLBigImage self, SoState state, int const idx, float const quality, SbVec2s projsize)"""
        return _coin.SoGLBigImage_applySubImage(self, state, idx, quality, projsize)

    def exceededChangeLimit(self) -> "SbBool":
        r"""exceededChangeLimit(SoGLBigImage self) -> SbBool"""
        return _coin.SoGLBigImage_exceededChangeLimit(self)

    @staticmethod
    def setChangeLimit(limit: "int const") -> "int":
        r"""setChangeLimit(int const limit) -> int"""
        return _coin.SoGLBigImage_setChangeLimit(limit)

    def getGLDisplayList(self, state: "SoState") -> "SoGLDisplayList *":
        r"""getGLDisplayList(SoGLBigImage self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLBigImage_getGLDisplayList(self, state)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGLBigImage_initClass()

# Register SoGLBigImage in _coin:
_coin.SoGLBigImage_swigregister(SoGLBigImage)

def SoGLBigImage_getClassTypeId() -> "SoType":
    r"""SoGLBigImage_getClassTypeId() -> SoType"""
    return _coin.SoGLBigImage_getClassTypeId()

def SoGLBigImage_setChangeLimit(limit: "int const") -> "int":
    r"""SoGLBigImage_setChangeLimit(int const limit) -> int"""
    return _coin.SoGLBigImage_setChangeLimit(limit)

def SoGLBigImage_initClass() -> "void":
    r"""SoGLBigImage_initClass()"""
    return _coin.SoGLBigImage_initClass()

class SoGlyph(object):
    r"""Proxy of C++ SoGlyph class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    FONT2D = _coin.SoGlyph_FONT2D
    
    FONT3D = _coin.SoGlyph_FONT3D
    

    def unref(self) -> "void":
        r"""unref(SoGlyph self)"""
        return _coin.SoGlyph_unref(self)

    def getCoords(self) -> "SbVec2f const *":
        r"""getCoords(SoGlyph self) -> SbVec2f"""
        return _coin.SoGlyph_getCoords(self)

    def getFaceIndices(self) -> "int const *":
        r"""getFaceIndices(SoGlyph self) -> int const *"""
        return _coin.SoGlyph_getFaceIndices(self)

    def getEdgeIndices(self) -> "int const *":
        r"""getEdgeIndices(SoGlyph self) -> int const *"""
        return _coin.SoGlyph_getEdgeIndices(self)

    def getNextCWEdge(self, edgeidx: "int const") -> "int const *":
        r"""getNextCWEdge(SoGlyph self, int const edgeidx) -> int const *"""
        return _coin.SoGlyph_getNextCWEdge(self, edgeidx)

    def getNextCCWEdge(self, edgeidx: "int const") -> "int const *":
        r"""getNextCCWEdge(SoGlyph self, int const edgeidx) -> int const *"""
        return _coin.SoGlyph_getNextCCWEdge(self, edgeidx)

    def getWidth(self) -> "float":
        r"""getWidth(SoGlyph self) -> float"""
        return _coin.SoGlyph_getWidth(self)

    def getBoundingBox(self) -> "SbBox2f const &":
        r"""getBoundingBox(SoGlyph self) -> SbBox2f"""
        return _coin.SoGlyph_getBoundingBox(self)

    @staticmethod
    def getGlyph(*args) -> "SoGlyph const *":
        r"""
        getGlyph(char const character, SbName font) -> SoGlyph
        getGlyph(SoState state, unsigned int const character, SbVec2s size, float const angle) -> SoGlyph
        """
        return _coin.SoGlyph_getGlyph(*args)

    def getAdvance(self) -> "SbVec2s":
        r"""getAdvance(SoGlyph self) -> SbVec2s"""
        return _coin.SoGlyph_getAdvance(self)

    def getKerning(self, rightglyph: "SoGlyph") -> "SbVec2s":
        r"""getKerning(SoGlyph self, SoGlyph rightglyph) -> SbVec2s"""
        return _coin.SoGlyph_getKerning(self, rightglyph)

    def getBitmap(self, size: "SbVec2s", pos: "SbVec2s", antialiased: "SbBool const") -> "unsigned char *":
        r"""getBitmap(SoGlyph self, SbVec2s size, SbVec2s pos, SbBool const antialiased) -> unsigned char *"""
        return _coin.SoGlyph_getBitmap(self, size, pos, antialiased)

# Register SoGlyph in _coin:
_coin.SoGlyph_swigregister(SoGlyph)

def SoGlyph_getGlyph(*args) -> "SoGlyph const *":
    r"""
    SoGlyph_getGlyph(char const character, SbName font) -> SoGlyph
    SoGlyph_getGlyph(SoState state, unsigned int const character, SbVec2s size, float const angle) -> SoGlyph
    """
    return _coin.SoGlyph_getGlyph(*args)

class SbDPMatrix(object):
    r"""Proxy of C++ SbDPMatrix class."""

    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):
        r"""
        __init__(SbDPMatrix self) -> SbDPMatrix
        __init__(SbDPMatrix self, double const a11, double const a12, double const a13, double const a14, double const a21, double const a22, double const a23, double const a24, double const a31, double const a32, double const a33, double const a34, double const a41, double const a42, double const a43, double const a44) -> SbDPMatrix
        __init__(SbDPMatrix self, SbDPMat const & matrix) -> SbDPMatrix
        __init__(SbDPMatrix self, SbDPMat const * matrix) -> SbDPMatrix
        __init__(SbDPMatrix self) -> SbDPMatrix
        """
        _coin.SbDPMatrix_swiginit(self, _coin.new_SbDPMatrix(*args))
    __swig_destroy__ = _coin.delete_SbDPMatrix

    def setValue(self, *args) -> "void":
        r"""
        setValue(SbDPMatrix self, SbDPMat const & m)
        setValue(SbDPMatrix self, SbMatrix m)
        setValue(SbDPMatrix self, double const * pMat)
        """
        return _coin.SbDPMatrix_setValue(self, *args)

    def makeIdentity(self) -> "void":
        r"""makeIdentity(SbDPMatrix self)"""
        return _coin.SbDPMatrix_makeIdentity(self)

    def setRotate(self, q: "SbDPRotation") -> "void":
        r"""setRotate(SbDPMatrix self, SbDPRotation q)"""
        return _coin.SbDPMatrix_setRotate(self, q)

    def inverse(self) -> "SbDPMatrix":
        r"""inverse(SbDPMatrix self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_inverse(self)

    def det3(self, *args) -> "double":
        r"""
        det3(SbDPMatrix self, int r1, int r2, int r3, int c1, int c2, int c3) -> double
        det3(SbDPMatrix self) -> double
        """
        return _coin.SbDPMatrix_det3(self, *args)

    def det4(self) -> "double":
        r"""det4(SbDPMatrix self) -> double"""
        return _coin.SbDPMatrix_det4(self)

    def equals(self, m: "SbDPMatrix", tolerance: "double") -> "SbBool":
        r"""equals(SbDPMatrix self, SbDPMatrix m, double tolerance) -> SbBool"""
        return _coin.SbDPMatrix_equals(self, m, tolerance)

    def getValue(self, *args) -> "void":
        r"""
        getValue(SbDPMatrix self) -> SbDPMat const
        getValue(SbDPMatrix self, SbDPMat & m)
        """
        return _coin.SbDPMatrix_getValue(self, *args)

    @staticmethod
    def identity() -> "SbDPMatrix":
        r"""identity() -> SbDPMatrix"""
        return _coin.SbDPMatrix_identity()

    def setScale(self, *args) -> "void":
        r"""
        setScale(SbDPMatrix self, double const s)
        setScale(SbDPMatrix self, SbVec3d s)
        """
        return _coin.SbDPMatrix_setScale(self, *args)

    def setTranslate(self, t: "SbVec3d") -> "void":
        r"""setTranslate(SbDPMatrix self, SbVec3d t)"""
        return _coin.SbDPMatrix_setTranslate(self, t)

    def setTransform(self, *args) -> "void":
        r"""
        setTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s)
        setTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)
        setTransform(SbDPMatrix self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, SbDPRotation scaleOrientation, SbVec3d center)
        """
        return _coin.SbDPMatrix_setTransform(self, *args)

    def getTransform(self, *args) -> "void":
        r"""
        getTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)
        getTransform(SbDPMatrix self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, SbDPRotation scaleOrientation, SbVec3d center)
        """
        return _coin.SbDPMatrix_getTransform(self, *args)

    def factor(self, r: "SbDPMatrix", s: "SbVec3d", u: "SbDPMatrix", t: "SbVec3d", proj: "SbDPMatrix") -> "SbBool":
        r"""factor(SbDPMatrix self, SbDPMatrix r, SbVec3d s, SbDPMatrix u, SbVec3d t, SbDPMatrix proj) -> SbBool"""
        return _coin.SbDPMatrix_factor(self, r, s, u, t, proj)

    def LUDecomposition(self, index: "int [4]", d: "double &") -> "SbBool":
        r"""LUDecomposition(SbDPMatrix self, int [4] index, double & d) -> SbBool"""
        return _coin.SbDPMatrix_LUDecomposition(self, index, d)

    def LUBackSubstitution(self, index: "int [4]", b: "double [4]") -> "void":
        r"""LUBackSubstitution(SbDPMatrix self, int [4] index, double [4] b)"""
        return _coin.SbDPMatrix_LUBackSubstitution(self, index, b)

    def transpose(self) -> "SbDPMatrix":
        r"""transpose(SbDPMatrix self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_transpose(self)

    def multRight(self, m: "SbDPMatrix") -> "SbDPMatrix &":
        r"""multRight(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multRight(self, m)

    def multLeft(self, m: "SbDPMatrix") -> "SbDPMatrix &":
        r"""multLeft(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multLeft(self, m)

    def multMatrixVec(self, src: "SbVec3d", dst: "SbVec3d") -> "void":
        r"""multMatrixVec(SbDPMatrix self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multMatrixVec(self, src, dst)

    def multDirMatrix(self, src: "SbVec3d", dst: "SbVec3d") -> "void":
        r"""multDirMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multDirMatrix(self, src, dst)

    def multLineMatrix(self, src: "SbDPLine", dst: "SbDPLine") -> "void":
        r"""multLineMatrix(SbDPMatrix self, SbDPLine src, SbDPLine dst)"""
        return _coin.SbDPMatrix_multLineMatrix(self, src, dst)

    def multVecMatrix(self, *args) -> "void":
        r"""
        multVecMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)
        multVecMatrix(SbDPMatrix self, SbVec4d src, SbVec4d dst)
        """
        return _coin.SbDPMatrix_multVecMatrix(self, *args)

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbDPMatrix self, FILE * fp)"""
        return _coin.SbDPMatrix_output(self, fp)

    def __imul__(self, m: "SbDPMatrix") -> "SbDPMatrix &":
        r"""__imul__(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix___imul__(self, m)

    def __mul__(self, *args) -> "SbVec3d":
        r"""
        __mul__(SbDPMatrix self, SbDPMatrix u) -> SbDPMatrix
        __mul__(SbDPMatrix self, SbVec3d u) -> SbVec3d
        """
        return _coin.SbDPMatrix___mul__(self, *args)

    def __rmul__(self, u: "SbVec3d") -> "SbVec3d":
        r"""__rmul__(SbDPMatrix self, SbVec3d u) -> SbVec3d"""
        return _coin.SbDPMatrix___rmul__(self, u)

    def __eq__(self, u: "SbDPMatrix") -> "int":
        r"""__eq__(SbDPMatrix self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___eq__(self, u)

    def __ne__(self, u: "SbDPMatrix") -> "int":
        r"""__ne__(SbDPMatrix self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___ne__(self, u)

# Register SbDPMatrix in _coin:
_coin.SbDPMatrix_swigregister(SbDPMatrix)

def SbDPMatrix_identity() -> "SbDPMatrix":
    r"""SbDPMatrix_identity() -> SbDPMatrix"""
    return _coin.SbDPMatrix_identity()

class SoGeo(object):
    r"""Proxy of C++ SoGeo class."""

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

    @staticmethod
    def init() -> "void":
        r"""init()"""
        return _coin.SoGeo_init()

    @staticmethod
    def toGD(originsystem: "SbString", numoriginsys: "int const", origincoords: "SbVec3d") -> "SbVec3d":
        r"""toGD(SbString originsystem, int const numoriginsys, SbVec3d origincoords) -> SbVec3d"""
        return _coin.SoGeo_toGD(originsystem, numoriginsys, origincoords)

    @staticmethod
    def fromGD(gd: "SbVec3d", tosystem: "SbString", numtosys: "int const") -> "SbVec3d":
        r"""fromGD(SbVec3d gd, SbString tosystem, int const numtosys) -> SbVec3d"""
        return _coin.SoGeo_fromGD(gd, tosystem, numtosys)

    @staticmethod
    def calculateDPTransform(originsystem: "SbString", numoriginsys: "int const", origincoords: "SbVec3d", localsystem: "SbString", numlocalsys: "int const", localcoords: "SbVec3d") -> "SbDPMatrix":
        r"""calculateDPTransform(SbString originsystem, int const numoriginsys, SbVec3d origincoords, SbString localsystem, int const numlocalsys, SbVec3d localcoords) -> SbDPMatrix"""
        return _coin.SoGeo_calculateDPTransform(originsystem, numoriginsys, origincoords, localsystem, numlocalsys, localcoords)

    @staticmethod
    def calculateTransform(originsystem: "SbString", numoriginsys: "int const", origincoords: "SbVec3d", localsystem: "SbString", numlocalsys: "int const", localcoords: "SbVec3d") -> "SbMatrix":
        r"""calculateTransform(SbString originsystem, int const numoriginsys, SbVec3d origincoords, SbString localsystem, int const numlocalsys, SbVec3d localcoords) -> SbMatrix"""
        return _coin.SoGeo_calculateTransform(originsystem, numoriginsys, origincoords, localsystem, numlocalsys, localcoords)

    def __init__(self):
        r"""__init__(SoGeo self) -> SoGeo"""
        _coin.SoGeo_swiginit(self, _coin.new_SoGeo())
    __swig_destroy__ = _coin.delete_SoGeo

# Register SoGeo in _coin:
_coin.SoGeo_swigregister(SoGeo)

def SoGeo_init() -> "void":
    r"""SoGeo_init()"""
    return _coin.SoGeo_init()

def SoGeo_toGD(originsystem: "SbString", numoriginsys: "int const", origincoords: "SbVec3d") -> "SbVec3d":
    r"""SoGeo_toGD(SbString originsystem, int const numoriginsys, SbVec3d origincoords) -> SbVec3d"""
    return _coin.SoGeo_toGD(originsystem, numoriginsys, origincoords)

def SoGeo_fromGD(gd: "SbVec3d", tosystem: "SbString", numtosys: "int const") -> "SbVec3d":
    r"""SoGeo_fromGD(SbVec3d gd, SbString tosystem, int const numtosys) -> SbVec3d"""
    return _coin.SoGeo_fromGD(gd, tosystem, numtosys)

def SoGeo_calculateDPTransform(originsystem: "SbString", numoriginsys: "int const", origincoords: "SbVec3d", localsystem: "SbString", numlocalsys: "int const", localcoords: "SbVec3d") -> "SbDPMatrix":
    r"""SoGeo_calculateDPTransform(SbString originsystem, int const numoriginsys, SbVec3d origincoords, SbString localsystem, int const numlocalsys, SbVec3d localcoords) -> SbDPMatrix"""
    return _coin.SoGeo_calculateDPTransform(originsystem, numoriginsys, origincoords, localsystem, numlocalsys, localcoords)

def SoGeo_calculateTransform(originsystem: "SbString", numoriginsys: "int const", origincoords: "SbVec3d", localsystem: "SbString", numlocalsys: "int const", localcoords: "SbVec3d") -> "SbMatrix":
    r"""SoGeo_calculateTransform(SbString originsystem, int const numoriginsys, SbVec3d origincoords, SbString localsystem, int const numlocalsys, SbVec3d localcoords) -> SbMatrix"""
    return _coin.SoGeo_calculateTransform(originsystem, numoriginsys, origincoords, localsystem, numlocalsys, localcoords)

class SoProto(SoNode):
    r"""Proxy of C++ SoProto class."""

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

    def __init__(self, externproto: "SbBool const"=0):
        r"""__init__(SoProto self, SbBool const externproto=0) -> SoProto"""
        _coin.SoProto_swiginit(self, _coin.new_SoProto(externproto))

    @staticmethod
    def setFetchExternProtoCallback(cb: "SoFetchExternProtoCB *", closure: "void *") -> "void":
        r"""setFetchExternProtoCallback(SoFetchExternProtoCB * cb, void * closure)"""
        return _coin.SoProto_setFetchExternProtoCallback(cb, closure)

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoProto self) -> SoType"""
        return _coin.SoProto_getTypeId(self)

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProto_getClassTypeId()

    @staticmethod
    def findProto(name: "SbName") -> "SoProto *":
        r"""findProto(SbName name) -> SoProto"""
        return _coin.SoProto_findProto(name)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProto_initClass()

    def createProtoInstance(self) -> "SoProtoInstance *":
        r"""createProtoInstance(SoProto self) -> SoProtoInstance"""
        return _coin.SoProto_createProtoInstance(self)

    def addISReference(self, container: "SoNode", fieldname: "SbName", interfacename: "SbName") -> "void":
        r"""addISReference(SoProto self, SoNode container, SbName fieldname, SbName interfacename)"""
        return _coin.SoProto_addISReference(self, container, fieldname, interfacename)

    def findISReference(self, container: "SoFieldContainer", fieldname: "SbName") -> "SbName":
        r"""findISReference(SoProto self, SoFieldContainer container, SbName fieldname) -> SbName"""
        return _coin.SoProto_findISReference(self, container, fieldname)

    def addReference(self, name: "SbName", base: "SoBase") -> "void":
        r"""addReference(SoProto self, SbName name, SoBase base)"""
        return _coin.SoProto_addReference(self, name, base)

    def removeReference(self, name: "SbName") -> "void":
        r"""removeReference(SoProto self, SbName name)"""
        return _coin.SoProto_removeReference(self, name)

    def findReference(self, name: "SbName") -> "SoBase *":
        r"""findReference(SoProto self, SbName name) -> SoBase"""
        return _coin.SoProto_findReference(self, name)

    def addRoute(self, fromnode: "SbName", fromfield: "SbName", tonode: "SbName", tofield: "SbName") -> "void":
        r"""addRoute(SoProto self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
        return _coin.SoProto_addRoute(self, fromnode, fromfield, tonode, tofield)

    def getProtoName(self) -> "SbName":
        r"""getProtoName(SoProto self) -> SbName"""
        return _coin.SoProto_getProtoName(self)

    def readInstance(self, input: "SoInput", flags: "unsigned short") -> "SbBool":
        r"""readInstance(SoProto self, SoInput input, unsigned short flags) -> SbBool"""
        return _coin.SoProto_readInstance(self, input, flags)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoProto self, SoWriteAction action)"""
        return _coin.SoProto_write(self, action)

# Register SoProto in _coin:
_coin.SoProto_swigregister(SoProto)

def SoProto_setFetchExternProtoCallback(cb: "SoFetchExternProtoCB *", closure: "void *") -> "void":
    r"""SoProto_setFetchExternProtoCallback(SoFetchExternProtoCB * cb, void * closure)"""
    return _coin.SoProto_setFetchExternProtoCallback(cb, closure)

def SoProto_getClassTypeId() -> "SoType":
    r"""SoProto_getClassTypeId() -> SoType"""
    return _coin.SoProto_getClassTypeId()

def SoProto_findProto(name: "SbName") -> "SoProto *":
    r"""SoProto_findProto(SbName name) -> SoProto"""
    return _coin.SoProto_findProto(name)

def SoProto_initClass() -> "void":
    r"""SoProto_initClass()"""
    return _coin.SoProto_initClass()

class SoProtoInstance(SoNode):
    r"""Proxy of C++ SoProtoInstance class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProtoInstance_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoProtoInstance self) -> SoType"""
        return _coin.SoProtoInstance_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProtoInstance_initClass()

    def __init__(self, proto: "SoProto", deffielddata: "SoFieldData"):
        r"""__init__(SoProtoInstance self, SoProto proto, SoFieldData deffielddata) -> SoProtoInstance"""
        _coin.SoProtoInstance_swiginit(self, _coin.new_SoProtoInstance(proto, deffielddata))

    @staticmethod
    def findProtoInstance(rootnode: "SoNode") -> "SoProtoInstance *":
        r"""findProtoInstance(SoNode rootnode) -> SoProtoInstance"""
        return _coin.SoProtoInstance_findProtoInstance(rootnode)

    def setRootNode(self, root: "SoNode") -> "void":
        r"""setRootNode(SoProtoInstance self, SoNode root)"""
        return _coin.SoProtoInstance_setRootNode(self, root)

    def getRootNode(self) -> "SoNode *":
        r"""getRootNode(SoProtoInstance self) -> SoNode"""
        return _coin.SoProtoInstance_getRootNode(self)

    def getProtoDefinition(self) -> "SoProto *":
        r"""getProtoDefinition(SoProtoInstance self) -> SoProto"""
        return _coin.SoProtoInstance_getProtoDefinition(self)

    def getProtoName(self) -> "SbName":
        r"""getProtoName(SoProtoInstance self) -> SbName"""
        return _coin.SoProtoInstance_getProtoName(self)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoProtoInstance self, SoWriteAction action)"""
        return _coin.SoProtoInstance_write(self, action)

# Register SoProtoInstance in _coin:
_coin.SoProtoInstance_swigregister(SoProtoInstance)

def SoProtoInstance_getClassTypeId() -> "SoType":
    r"""SoProtoInstance_getClassTypeId() -> SoType"""
    return _coin.SoProtoInstance_getClassTypeId()

def SoProtoInstance_initClass() -> "void":
    r"""SoProtoInstance_initClass()"""
    return _coin.SoProtoInstance_initClass()

def SoProtoInstance_findProtoInstance(rootnode: "SoNode") -> "SoProtoInstance *":
    r"""SoProtoInstance_findProtoInstance(SoNode rootnode) -> SoProtoInstance"""
    return _coin.SoProtoInstance_findProtoInstance(rootnode)

class SoTranReceiver(object):
    r"""Proxy of C++ SoTranReceiver class."""

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

    def __init__(self, root: "SoGroup"):
        r"""__init__(SoTranReceiver self, SoGroup root) -> SoTranReceiver"""
        _coin.SoTranReceiver_swiginit(self, _coin.new_SoTranReceiver(root))
    __swig_destroy__ = _coin.delete_SoTranReceiver

    def interpret(self, input: "SoInput") -> "SbBool":
        r"""interpret(SoTranReceiver self, SoInput input) -> SbBool"""
        return _coin.SoTranReceiver_interpret(self, input)

# Register SoTranReceiver in _coin:
_coin.SoTranReceiver_swigregister(SoTranReceiver)

class SoTranSender(object):
    r"""Proxy of C++ SoTranSender class."""

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

    def __init__(self, output: "SoOutput"):
        r"""__init__(SoTranSender self, SoOutput output) -> SoTranSender"""
        _coin.SoTranSender_swiginit(self, _coin.new_SoTranSender(output))
    __swig_destroy__ = _coin.delete_SoTranSender

    def getOutput(self) -> "SoOutput *":
        r"""getOutput(SoTranSender self) -> SoOutput"""
        return _coin.SoTranSender_getOutput(self)

    def insert(self, *args) -> "void":
        r"""
        insert(SoTranSender self, SoNode node)
        insert(SoTranSender self, SoNode node, SoNode parent, int n)
        """
        return _coin.SoTranSender_insert(self, *args)

    def remove(self, parent: "SoNode", n: "int") -> "void":
        r"""remove(SoTranSender self, SoNode parent, int n)"""
        return _coin.SoTranSender_remove(self, parent, n)

    def replace(self, parent: "SoNode", n: "int", newnode: "SoNode") -> "void":
        r"""replace(SoTranSender self, SoNode parent, int n, SoNode newnode)"""
        return _coin.SoTranSender_replace(self, parent, n, newnode)

    def modify(self, node: "SoNode") -> "void":
        r"""modify(SoTranSender self, SoNode node)"""
        return _coin.SoTranSender_modify(self, node)

    def prepareToSend(self) -> "void":
        r"""prepareToSend(SoTranSender self)"""
        return _coin.SoTranSender_prepareToSend(self)

# Register SoTranSender in _coin:
_coin.SoTranSender_swigregister(SoTranSender)

class SoAppearanceKit(SoBaseKit):
    r"""Proxy of C++ SoAppearanceKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAppearanceKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoAppearanceKit self) -> SoType"""
        return _coin.SoAppearanceKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoAppearanceKit self) -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoAppearanceKit self) -> SoAppearanceKit"""
        _coin.SoAppearanceKit_swiginit(self, _coin.new_SoAppearanceKit())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAppearanceKit_initClass()

# Register SoAppearanceKit in _coin:
_coin.SoAppearanceKit_swigregister(SoAppearanceKit)

def SoAppearanceKit_getClassTypeId() -> "SoType":
    r"""SoAppearanceKit_getClassTypeId() -> SoType"""
    return _coin.SoAppearanceKit_getClassTypeId()

def SoAppearanceKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoAppearanceKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoAppearanceKit_getClassNodekitCatalog()

def SoAppearanceKit_initClass() -> "void":
    r"""SoAppearanceKit_initClass()"""
    return _coin.SoAppearanceKit_initClass()

class SoCameraKit(SoBaseKit):
    r"""Proxy of C++ SoCameraKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCameraKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCameraKit self) -> SoType"""
        return _coin.SoCameraKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoCameraKit self) -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoCameraKit self) -> SoCameraKit"""
        _coin.SoCameraKit_swiginit(self, _coin.new_SoCameraKit())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCameraKit_initClass()

# Register SoCameraKit in _coin:
_coin.SoCameraKit_swigregister(SoCameraKit)

def SoCameraKit_getClassTypeId() -> "SoType":
    r"""SoCameraKit_getClassTypeId() -> SoType"""
    return _coin.SoCameraKit_getClassTypeId()

def SoCameraKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoCameraKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoCameraKit_getClassNodekitCatalog()

def SoCameraKit_initClass() -> "void":
    r"""SoCameraKit_initClass()"""
    return _coin.SoCameraKit_initClass()

class SoLightKit(SoBaseKit):
    r"""Proxy of C++ SoLightKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLightKit self) -> SoType"""
        return _coin.SoLightKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoLightKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoLightKit self) -> SoNodekitCatalog"""
        return _coin.SoLightKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoLightKit self) -> SoLightKit"""
        _coin.SoLightKit_swiginit(self, _coin.new_SoLightKit())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLightKit_initClass()

# Register SoLightKit in _coin:
_coin.SoLightKit_swigregister(SoLightKit)

def SoLightKit_getClassTypeId() -> "SoType":
    r"""SoLightKit_getClassTypeId() -> SoType"""
    return _coin.SoLightKit_getClassTypeId()

def SoLightKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoLightKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoLightKit_getClassNodekitCatalog()

def SoLightKit_initClass() -> "void":
    r"""SoLightKit_initClass()"""
    return _coin.SoLightKit_initClass()

class SoNodeKit(object):
    r"""Proxy of C++ SoNodeKit class."""

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

    @staticmethod
    def init() -> "void":
        r"""init()"""
        return _coin.SoNodeKit_init()

    def __init__(self):
        r"""__init__(SoNodeKit self) -> SoNodeKit"""
        _coin.SoNodeKit_swiginit(self, _coin.new_SoNodeKit())
    __swig_destroy__ = _coin.delete_SoNodeKit

# Register SoNodeKit in _coin:
_coin.SoNodeKit_swigregister(SoNodeKit)

def SoNodeKit_init() -> "void":
    r"""SoNodeKit_init()"""
    return _coin.SoNodeKit_init()

class SoSceneKit(SoBaseKit):
    r"""Proxy of C++ SoSceneKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSceneKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSceneKit self) -> SoType"""
        return _coin.SoSceneKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoSceneKit self) -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getNodekitCatalog(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSceneKit_initClass()

    def __init__(self):
        r"""__init__(SoSceneKit self) -> SoSceneKit"""
        _coin.SoSceneKit_swiginit(self, _coin.new_SoSceneKit())

    def getCameraNumber(self) -> "int":
        r"""getCameraNumber(SoSceneKit self) -> int"""
        return _coin.SoSceneKit_getCameraNumber(self)

    def setCameraNumber(self, camNum: "int") -> "void":
        r"""setCameraNumber(SoSceneKit self, int camNum)"""
        return _coin.SoSceneKit_setCameraNumber(self, camNum)

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoSceneKit self) -> SbBool"""
        return _coin.SoSceneKit_affectsState(self)

# Register SoSceneKit in _coin:
_coin.SoSceneKit_swigregister(SoSceneKit)

def SoSceneKit_getClassTypeId() -> "SoType":
    r"""SoSceneKit_getClassTypeId() -> SoType"""
    return _coin.SoSceneKit_getClassTypeId()

def SoSceneKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoSceneKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoSceneKit_getClassNodekitCatalog()

def SoSceneKit_initClass() -> "void":
    r"""SoSceneKit_initClass()"""
    return _coin.SoSceneKit_initClass()

class SoSeparatorKit(SoBaseKit):
    r"""Proxy of C++ SoSeparatorKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSeparatorKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSeparatorKit self) -> SoType"""
        return _coin.SoSeparatorKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoSeparatorKit self) -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoSeparatorKit self) -> SoSeparatorKit"""
        _coin.SoSeparatorKit_swiginit(self, _coin.new_SoSeparatorKit())
    OFF = _coin.SoSeparatorKit_OFF
    
    ON = _coin.SoSeparatorKit_ON
    
    AUTO = _coin.SoSeparatorKit_AUTO
    
    renderCaching = property(_coin.SoSeparatorKit_renderCaching_get, _coin.SoSeparatorKit_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoSeparatorKit_boundingBoxCaching_get, _coin.SoSeparatorKit_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoSeparatorKit_renderCulling_get, _coin.SoSeparatorKit_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoSeparatorKit_pickCulling_get, _coin.SoSeparatorKit_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSeparatorKit_initClass()

# Register SoSeparatorKit in _coin:
_coin.SoSeparatorKit_swigregister(SoSeparatorKit)

def SoSeparatorKit_getClassTypeId() -> "SoType":
    r"""SoSeparatorKit_getClassTypeId() -> SoType"""
    return _coin.SoSeparatorKit_getClassTypeId()

def SoSeparatorKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoSeparatorKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoSeparatorKit_getClassNodekitCatalog()

def SoSeparatorKit_initClass() -> "void":
    r"""SoSeparatorKit_initClass()"""
    return _coin.SoSeparatorKit_initClass()

class SoShapeKit(SoSeparatorKit):
    r"""Proxy of C++ SoShapeKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShapeKit self) -> SoType"""
        return _coin.SoShapeKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoShapeKit self) -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoShapeKit self) -> SoShapeKit"""
        _coin.SoShapeKit_swiginit(self, _coin.new_SoShapeKit())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShapeKit_initClass()

# Register SoShapeKit in _coin:
_coin.SoShapeKit_swigregister(SoShapeKit)

def SoShapeKit_getClassTypeId() -> "SoType":
    r"""SoShapeKit_getClassTypeId() -> SoType"""
    return _coin.SoShapeKit_getClassTypeId()

def SoShapeKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoShapeKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoShapeKit_getClassNodekitCatalog()

def SoShapeKit_initClass() -> "void":
    r"""SoShapeKit_initClass()"""
    return _coin.SoShapeKit_initClass()

class SoWrapperKit(SoSeparatorKit):
    r"""Proxy of C++ SoWrapperKit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWrapperKit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoWrapperKit self) -> SoType"""
        return _coin.SoWrapperKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog() -> "SoNodekitCatalog const *":
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getClassNodekitCatalog()

    def getNodekitCatalog(self) -> "SoNodekitCatalog const *":
        r"""getNodekitCatalog(SoWrapperKit self) -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoWrapperKit self) -> SoWrapperKit"""
        _coin.SoWrapperKit_swiginit(self, _coin.new_SoWrapperKit())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoWrapperKit_initClass()

# Register SoWrapperKit in _coin:
_coin.SoWrapperKit_swigregister(SoWrapperKit)

def SoWrapperKit_getClassTypeId() -> "SoType":
    r"""SoWrapperKit_getClassTypeId() -> SoType"""
    return _coin.SoWrapperKit_getClassTypeId()

def SoWrapperKit_getClassNodekitCatalog() -> "SoNodekitCatalog const *":
    r"""SoWrapperKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
    return _coin.SoWrapperKit_getClassNodekitCatalog()

def SoWrapperKit_initClass() -> "void":
    r"""SoWrapperKit_initClass()"""
    return _coin.SoWrapperKit_initClass()

class SoGroup(SoNode):
    r"""Proxy of C++ SoGroup class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGroup_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGroup self) -> SoType"""
        return _coin.SoGroup_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGroup_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoGroup self) -> SoGroup
        __init__(SoGroup self, int nchildren) -> SoGroup
        """
        _coin.SoGroup_swiginit(self, _coin.new_SoGroup(*args))

    def addChild(self, node: "SoNode") -> "void":
        r"""addChild(SoGroup self, SoNode node)"""
        return _coin.SoGroup_addChild(self, node)

    def insertChild(self, child: "SoNode", newchildindex: "int") -> "void":
        r"""insertChild(SoGroup self, SoNode child, int newchildindex)"""
        return _coin.SoGroup_insertChild(self, child, newchildindex)

    def getChild(self, index: "int") -> "SoNode *":
        r"""getChild(SoGroup self, int index) -> SoNode"""
        return _coin.SoGroup_getChild(self, index)

    def findChild(self, node: "SoNode") -> "int":
        r"""findChild(SoGroup self, SoNode node) -> int"""
        return _coin.SoGroup_findChild(self, node)

    def getNumChildren(self) -> "int":
        r"""getNumChildren(SoGroup self) -> int"""
        return _coin.SoGroup_getNumChildren(self)

    def removeChild(self, *args) -> "void":
        r"""
        removeChild(SoGroup self, int childindex)
        removeChild(SoGroup self, SoNode child)
        """
        return _coin.SoGroup_removeChild(self, *args)

    def removeAllChildren(self) -> "void":
        r"""removeAllChildren(SoGroup self)"""
        return _coin.SoGroup_removeAllChildren(self)

    def replaceChild(self, *args) -> "void":
        r"""
        replaceChild(SoGroup self, int index, SoNode newchild)
        replaceChild(SoGroup self, SoNode oldchild, SoNode newchild)
        """
        return _coin.SoGroup_replaceChild(self, *args)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoGroup self, SoAction action)"""
        return _coin.SoGroup_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoGroup self, SoGLRenderAction action)"""
        return _coin.SoGroup_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoGroup self, SoCallbackAction action)"""
        return _coin.SoGroup_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoGroup self, SoGetBoundingBoxAction action)"""
        return _coin.SoGroup_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoGroup self, SoGetMatrixAction action)"""
        return _coin.SoGroup_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoGroup self, SoHandleEventAction action)"""
        return _coin.SoGroup_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoGroup self, SoPickAction action)"""
        return _coin.SoGroup_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoGroup self, SoSearchAction action)"""
        return _coin.SoGroup_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoGroup self, SoWriteAction action)"""
        return _coin.SoGroup_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoGroup self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGroup_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoGroup self, SoAudioRenderAction action)"""
        return _coin.SoGroup_audioRender(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoGroup self) -> SoChildList"""
        return _coin.SoGroup_getChildren(self)

    def addWriteReference(self, out: "SoOutput", isfromfield: "SbBool"=0) -> "void":
        r"""addWriteReference(SoGroup self, SoOutput out, SbBool isfromfield=0)"""
        return _coin.SoGroup_addWriteReference(self, out, isfromfield)

    def __iter__(self):
        i = 0
        while i < self.getNumChildren():
            yield self.getChild(i)
            i += 1

    def __iadd__(self, other):
        if isinstance(other, (list, tuple)):
            for other_i in other:
                self.__iadd__(other_i)
            return self
        else:
            try:
                self.addChild(other)
                return self
            except TypeError as e:
                raise TypeError(str(self.__class__) + " accepts only objects of type pivy.coin.SoNode")

    def __isub__(self, other):
        if isinstance(other, (list, tuple)):
            for other_i in other:
                self.__isub__(other_i)
            return self
        else:
            try:
                self.removeChild(other)
                return self
            except TypeError as e:
                raise TypeError(str(self.__class__) + " can't remove child of type " + str(type(other)))

    def getByName(self, name):
        for child in self:
            if name == child.getName():
                return child
        return None

    def __bool__(self):
        return True


    def __len__(self) -> "int":
        r"""__len__(SoGroup self) -> int"""
        return _coin.SoGroup___len__(self)

    def __contains__(self, node: "SoNode") -> "int":
        r"""__contains__(SoGroup self, SoNode node) -> int"""
        return _coin.SoGroup___contains__(self, node)

    def __getitem__(self, index: "int") -> "SoNode *":
        r"""__getitem__(SoGroup self, int index) -> SoNode"""
        return _coin.SoGroup___getitem__(self, index)

# Register SoGroup in _coin:
_coin.SoGroup_swigregister(SoGroup)

def SoGroup_getClassTypeId() -> "SoType":
    r"""SoGroup_getClassTypeId() -> SoType"""
    return _coin.SoGroup_getClassTypeId()

def SoGroup_initClass() -> "void":
    r"""SoGroup_initClass()"""
    return _coin.SoGroup_initClass()

class SoSeparator(SoGroup):
    r"""Proxy of C++ SoSeparator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSeparator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSeparator self) -> SoType"""
        return _coin.SoSeparator_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSeparator_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoSeparator self) -> SoSeparator
        __init__(SoSeparator self, int const nchildren) -> SoSeparator
        """
        _coin.SoSeparator_swiginit(self, _coin.new_SoSeparator(*args))
    OFF = _coin.SoSeparator_OFF
    
    ON = _coin.SoSeparator_ON
    
    AUTO = _coin.SoSeparator_AUTO
    
    renderCaching = property(_coin.SoSeparator_renderCaching_get, _coin.SoSeparator_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoSeparator_boundingBoxCaching_get, _coin.SoSeparator_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoSeparator_renderCulling_get, _coin.SoSeparator_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoSeparator_pickCulling_get, _coin.SoSeparator_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoSeparator self, SoAction action)"""
        return _coin.SoSeparator_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRender(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderOffPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderOffPath(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoSeparator self, SoCallbackAction action)"""
        return _coin.SoSeparator_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoSeparator self, SoGetBoundingBoxAction action)"""
        return _coin.SoSeparator_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoSeparator self, SoGetMatrixAction action)"""
        return _coin.SoSeparator_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoSeparator self, SoHandleEventAction action)"""
        return _coin.SoSeparator_handleEvent(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoSeparator self, SoRayPickAction action)"""
        return _coin.SoSeparator_rayPick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoSeparator self, SoSearchAction action)"""
        return _coin.SoSeparator_search(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoSeparator self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSeparator_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoSeparator self, SoAudioRenderAction action)"""
        return _coin.SoSeparator_audioRender(self, action)

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoSeparator self, SoNotList nl)"""
        return _coin.SoSeparator_notify(self, nl)

    @staticmethod
    def setNumRenderCaches(howmany: "int const") -> "void":
        r"""setNumRenderCaches(int const howmany)"""
        return _coin.SoSeparator_setNumRenderCaches(howmany)

    @staticmethod
    def getNumRenderCaches() -> "int":
        r"""getNumRenderCaches() -> int"""
        return _coin.SoSeparator_getNumRenderCaches()

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoSeparator self) -> SbBool"""
        return _coin.SoSeparator_affectsState(self)

# Register SoSeparator in _coin:
_coin.SoSeparator_swigregister(SoSeparator)

def SoSeparator_getClassTypeId() -> "SoType":
    r"""SoSeparator_getClassTypeId() -> SoType"""
    return _coin.SoSeparator_getClassTypeId()

def SoSeparator_initClass() -> "void":
    r"""SoSeparator_initClass()"""
    return _coin.SoSeparator_initClass()

def SoSeparator_setNumRenderCaches(howmany: "int const") -> "void":
    r"""SoSeparator_setNumRenderCaches(int const howmany)"""
    return _coin.SoSeparator_setNumRenderCaches(howmany)

def SoSeparator_getNumRenderCaches() -> "int":
    r"""SoSeparator_getNumRenderCaches() -> int"""
    return _coin.SoSeparator_getNumRenderCaches()

class SoAnnotation(SoSeparator):
    r"""Proxy of C++ SoAnnotation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnotation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoAnnotation self) -> SoType"""
        return _coin.SoAnnotation_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAnnotation_initClass()

    def __init__(self):
        r"""__init__(SoAnnotation self) -> SoAnnotation"""
        _coin.SoAnnotation_swiginit(self, _coin.new_SoAnnotation())

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRender(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderOffPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderOffPath(self, action)

# Register SoAnnotation in _coin:
_coin.SoAnnotation_swigregister(SoAnnotation)

def SoAnnotation_getClassTypeId() -> "SoType":
    r"""SoAnnotation_getClassTypeId() -> SoType"""
    return _coin.SoAnnotation_getClassTypeId()

def SoAnnotation_initClass() -> "void":
    r"""SoAnnotation_initClass()"""
    return _coin.SoAnnotation_initClass()

class SoAntiSquish(SoTransformation):
    r"""Proxy of C++ SoAntiSquish class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAntiSquish_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoAntiSquish self) -> SoType"""
        return _coin.SoAntiSquish_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAntiSquish_initClass()

    def __init__(self):
        r"""__init__(SoAntiSquish self) -> SoAntiSquish"""
        _coin.SoAntiSquish_swiginit(self, _coin.new_SoAntiSquish())
    X = _coin.SoAntiSquish_X
    
    Y = _coin.SoAntiSquish_Y
    
    Z = _coin.SoAntiSquish_Z
    
    AVERAGE_DIMENSION = _coin.SoAntiSquish_AVERAGE_DIMENSION
    
    BIGGEST_DIMENSION = _coin.SoAntiSquish_BIGGEST_DIMENSION
    
    SMALLEST_DIMENSION = _coin.SoAntiSquish_SMALLEST_DIMENSION
    
    LONGEST_DIAGONAL = _coin.SoAntiSquish_LONGEST_DIAGONAL
    
    sizing = property(_coin.SoAntiSquish_sizing_get, _coin.SoAntiSquish_sizing_set, doc=r"""sizing : SoSFEnum""")
    recalcAlways = property(_coin.SoAntiSquish_recalcAlways_get, _coin.SoAntiSquish_recalcAlways_set, doc=r"""recalcAlways : SoSFBool""")

    def recalc(self) -> "void":
        r"""recalc(SoAntiSquish self)"""
        return _coin.SoAntiSquish_recalc(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoAntiSquish self, SoAction action)"""
        return _coin.SoAntiSquish_doAction(self, action)

# Register SoAntiSquish in _coin:
_coin.SoAntiSquish_swigregister(SoAntiSquish)

def SoAntiSquish_getClassTypeId() -> "SoType":
    r"""SoAntiSquish_getClassTypeId() -> SoType"""
    return _coin.SoAntiSquish_getClassTypeId()

def SoAntiSquish_initClass() -> "void":
    r"""SoAntiSquish_initClass()"""
    return _coin.SoAntiSquish_initClass()

class SoArray(SoGroup):
    r"""Proxy of C++ SoArray class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoArray_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoArray self) -> SoType"""
        return _coin.SoArray_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoArray_initClass()

    def __init__(self):
        r"""__init__(SoArray self) -> SoArray"""
        _coin.SoArray_swiginit(self, _coin.new_SoArray())
    FIRST = _coin.SoArray_FIRST
    
    CENTER = _coin.SoArray_CENTER
    
    LAST = _coin.SoArray_LAST
    
    origin = property(_coin.SoArray_origin_get, _coin.SoArray_origin_set, doc=r"""origin : SoSFEnum""")
    numElements1 = property(_coin.SoArray_numElements1_get, _coin.SoArray_numElements1_set, doc=r"""numElements1 : SoSFShort""")
    numElements2 = property(_coin.SoArray_numElements2_get, _coin.SoArray_numElements2_set, doc=r"""numElements2 : SoSFShort""")
    numElements3 = property(_coin.SoArray_numElements3_get, _coin.SoArray_numElements3_set, doc=r"""numElements3 : SoSFShort""")
    separation1 = property(_coin.SoArray_separation1_get, _coin.SoArray_separation1_set, doc=r"""separation1 : SoSFVec3f""")
    separation2 = property(_coin.SoArray_separation2_get, _coin.SoArray_separation2_set, doc=r"""separation2 : SoSFVec3f""")
    separation3 = property(_coin.SoArray_separation3_get, _coin.SoArray_separation3_set, doc=r"""separation3 : SoSFVec3f""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoArray self) -> SbBool"""
        return _coin.SoArray_affectsState(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoArray self, SoAction action)"""
        return _coin.SoArray_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoArray self, SoCallbackAction action)"""
        return _coin.SoArray_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoArray self, SoGLRenderAction action)"""
        return _coin.SoArray_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoArray self, SoPickAction action)"""
        return _coin.SoArray_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoArray self, SoGetBoundingBoxAction action)"""
        return _coin.SoArray_getBoundingBox(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoArray self, SoHandleEventAction action)"""
        return _coin.SoArray_handleEvent(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoArray self, SoGetMatrixAction action)"""
        return _coin.SoArray_getMatrix(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoArray self, SoSearchAction action)"""
        return _coin.SoArray_search(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoArray self, SoGetPrimitiveCountAction action)"""
        return _coin.SoArray_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoArray self, SoAudioRenderAction action)"""
        return _coin.SoArray_audioRender(self, action)

# Register SoArray in _coin:
_coin.SoArray_swigregister(SoArray)

def SoArray_getClassTypeId() -> "SoType":
    r"""SoArray_getClassTypeId() -> SoType"""
    return _coin.SoArray_getClassTypeId()

def SoArray_initClass() -> "void":
    r"""SoArray_initClass()"""
    return _coin.SoArray_initClass()

class SoAsciiText(SoShape):
    r"""Proxy of C++ SoAsciiText class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAsciiText_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoAsciiText self) -> SoType"""
        return _coin.SoAsciiText_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAsciiText_initClass()

    def __init__(self):
        r"""__init__(SoAsciiText self) -> SoAsciiText"""
        _coin.SoAsciiText_swiginit(self, _coin.new_SoAsciiText())
    LEFT = _coin.SoAsciiText_LEFT
    
    RIGHT = _coin.SoAsciiText_RIGHT
    
    CENTER = _coin.SoAsciiText_CENTER
    
    string = property(_coin.SoAsciiText_string_get, _coin.SoAsciiText_string_set, doc=r"""string : SoMFString""")
    spacing = property(_coin.SoAsciiText_spacing_get, _coin.SoAsciiText_spacing_set, doc=r"""spacing : SoSFFloat""")
    justification = property(_coin.SoAsciiText_justification_get, _coin.SoAsciiText_justification_set, doc=r"""justification : SoSFEnum""")
    width = property(_coin.SoAsciiText_width_get, _coin.SoAsciiText_width_set, doc=r"""width : SoMFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoAsciiText self, SoGLRenderAction action)"""
        return _coin.SoAsciiText_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoAsciiText self, SoGetPrimitiveCountAction action)"""
        return _coin.SoAsciiText_getPrimitiveCount(self, action)

# Register SoAsciiText in _coin:
_coin.SoAsciiText_swigregister(SoAsciiText)

def SoAsciiText_getClassTypeId() -> "SoType":
    r"""SoAsciiText_getClassTypeId() -> SoType"""
    return _coin.SoAsciiText_getClassTypeId()

def SoAsciiText_initClass() -> "void":
    r"""SoAsciiText_initClass()"""
    return _coin.SoAsciiText_initClass()

class SoBaseColor(SoNode):
    r"""Proxy of C++ SoBaseColor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBaseColor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBaseColor self) -> SoType"""
        return _coin.SoBaseColor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBaseColor_initClass()

    def __init__(self):
        r"""__init__(SoBaseColor self) -> SoBaseColor"""
        _coin.SoBaseColor_swiginit(self, _coin.new_SoBaseColor())
    rgb = property(_coin.SoBaseColor_rgb_get, _coin.SoBaseColor_rgb_set, doc=r"""rgb : SoMFColor""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoBaseColor self, SoAction action)"""
        return _coin.SoBaseColor_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoBaseColor self, SoGLRenderAction action)"""
        return _coin.SoBaseColor_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoBaseColor self, SoCallbackAction action)"""
        return _coin.SoBaseColor_callback(self, action)

# Register SoBaseColor in _coin:
_coin.SoBaseColor_swigregister(SoBaseColor)

def SoBaseColor_getClassTypeId() -> "SoType":
    r"""SoBaseColor_getClassTypeId() -> SoType"""
    return _coin.SoBaseColor_getClassTypeId()

def SoBaseColor_initClass() -> "void":
    r"""SoBaseColor_initClass()"""
    return _coin.SoBaseColor_initClass()

SO_SWITCH_NONE = _coin.SO_SWITCH_NONE

SO_SWITCH_INHERIT = _coin.SO_SWITCH_INHERIT

SO_SWITCH_ALL = _coin.SO_SWITCH_ALL

class SoSwitch(SoGroup):
    r"""Proxy of C++ SoSwitch class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSwitch_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSwitch self) -> SoType"""
        return _coin.SoSwitch_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSwitch_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoSwitch self) -> SoSwitch
        __init__(SoSwitch self, int numchildren) -> SoSwitch
        """
        _coin.SoSwitch_swiginit(self, _coin.new_SoSwitch(*args))
    whichChild = property(_coin.SoSwitch_whichChild_get, _coin.SoSwitch_whichChild_set, doc=r"""whichChild : SoSFInt32""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoSwitch self) -> SbBool"""
        return _coin.SoSwitch_affectsState(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoSwitch self, SoAction action)"""
        return _coin.SoSwitch_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoSwitch self, SoCallbackAction action)"""
        return _coin.SoSwitch_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoSwitch self, SoGLRenderAction action)"""
        return _coin.SoSwitch_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoSwitch self, SoPickAction action)"""
        return _coin.SoSwitch_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoSwitch_getBoundingBox(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoSwitch self, SoHandleEventAction action)"""
        return _coin.SoSwitch_handleEvent(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoSwitch self, SoGetMatrixAction action)"""
        return _coin.SoSwitch_getMatrix(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoSwitch self, SoSearchAction action)"""
        return _coin.SoSwitch_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoSwitch self, SoWriteAction action)"""
        return _coin.SoSwitch_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoSwitch self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSwitch_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoSwitch self, SoAudioRenderAction action)"""
        return _coin.SoSwitch_audioRender(self, action)

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoSwitch self, SoNotList nl)"""
        return _coin.SoSwitch_notify(self, nl)

# Register SoSwitch in _coin:
_coin.SoSwitch_swigregister(SoSwitch)

def SoSwitch_getClassTypeId() -> "SoType":
    r"""SoSwitch_getClassTypeId() -> SoType"""
    return _coin.SoSwitch_getClassTypeId()

def SoSwitch_initClass() -> "void":
    r"""SoSwitch_initClass()"""
    return _coin.SoSwitch_initClass()

class SoBlinker(SoSwitch):
    r"""Proxy of C++ SoBlinker class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBlinker_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBlinker self) -> SoType"""
        return _coin.SoBlinker_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBlinker_initClass()

    def __init__(self):
        r"""__init__(SoBlinker self) -> SoBlinker"""
        _coin.SoBlinker_swiginit(self, _coin.new_SoBlinker())
    speed = property(_coin.SoBlinker_speed_get, _coin.SoBlinker_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoBlinker_on_get, _coin.SoBlinker_on_set, doc=r"""on : SoSFBool""")

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoBlinker self, SoGetBoundingBoxAction action)"""
        return _coin.SoBlinker_getBoundingBox(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoBlinker self, SoWriteAction action)"""
        return _coin.SoBlinker_write(self, action)

# Register SoBlinker in _coin:
_coin.SoBlinker_swigregister(SoBlinker)

def SoBlinker_getClassTypeId() -> "SoType":
    r"""SoBlinker_getClassTypeId() -> SoType"""
    return _coin.SoBlinker_getClassTypeId()

def SoBlinker_initClass() -> "void":
    r"""SoBlinker_initClass()"""
    return _coin.SoBlinker_initClass()

class SoBumpMapCoordinate(SoNode):
    r"""Proxy of C++ SoBumpMapCoordinate class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapCoordinate_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBumpMapCoordinate self) -> SoType"""
        return _coin.SoBumpMapCoordinate_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBumpMapCoordinate_initClass()

    def __init__(self):
        r"""__init__(SoBumpMapCoordinate self) -> SoBumpMapCoordinate"""
        _coin.SoBumpMapCoordinate_swiginit(self, _coin.new_SoBumpMapCoordinate())
    point = property(_coin.SoBumpMapCoordinate_point_get, _coin.SoBumpMapCoordinate_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoBumpMapCoordinate self, SoAction action)"""
        return _coin.SoBumpMapCoordinate_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoBumpMapCoordinate self, SoGLRenderAction action)"""
        return _coin.SoBumpMapCoordinate_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoBumpMapCoordinate self, SoCallbackAction action)"""
        return _coin.SoBumpMapCoordinate_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoBumpMapCoordinate self, SoPickAction action)"""
        return _coin.SoBumpMapCoordinate_pick(self, action)

# Register SoBumpMapCoordinate in _coin:
_coin.SoBumpMapCoordinate_swigregister(SoBumpMapCoordinate)

def SoBumpMapCoordinate_getClassTypeId() -> "SoType":
    r"""SoBumpMapCoordinate_getClassTypeId() -> SoType"""
    return _coin.SoBumpMapCoordinate_getClassTypeId()

def SoBumpMapCoordinate_initClass() -> "void":
    r"""SoBumpMapCoordinate_initClass()"""
    return _coin.SoBumpMapCoordinate_initClass()

class SoBumpMap(SoNode):
    r"""Proxy of C++ SoBumpMap class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMap_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBumpMap self) -> SoType"""
        return _coin.SoBumpMap_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBumpMap_initClass()

    def __init__(self):
        r"""__init__(SoBumpMap self) -> SoBumpMap"""
        _coin.SoBumpMap_swiginit(self, _coin.new_SoBumpMap())
    REPEAT = _coin.SoBumpMap_REPEAT
    
    CLAMP = _coin.SoBumpMap_CLAMP
    
    filename = property(_coin.SoBumpMap_filename_get, _coin.SoBumpMap_filename_set, doc=r"""filename : SoSFString""")
    image = property(_coin.SoBumpMap_image_get, _coin.SoBumpMap_image_set, doc=r"""image : SoSFImage""")
    wrapS = property(_coin.SoBumpMap_wrapS_get, _coin.SoBumpMap_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoBumpMap_wrapT_get, _coin.SoBumpMap_wrapT_set, doc=r"""wrapT : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoBumpMap self, SoAction action)"""
        return _coin.SoBumpMap_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoBumpMap self, SoGLRenderAction action)"""
        return _coin.SoBumpMap_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoBumpMap self, SoCallbackAction action)"""
        return _coin.SoBumpMap_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoBumpMap self, SoRayPickAction action)"""
        return _coin.SoBumpMap_rayPick(self, action)

# Register SoBumpMap in _coin:
_coin.SoBumpMap_swigregister(SoBumpMap)

def SoBumpMap_getClassTypeId() -> "SoType":
    r"""SoBumpMap_getClassTypeId() -> SoType"""
    return _coin.SoBumpMap_getClassTypeId()

def SoBumpMap_initClass() -> "void":
    r"""SoBumpMap_initClass()"""
    return _coin.SoBumpMap_initClass()

class SoBumpMapTransform(SoNode):
    r"""Proxy of C++ SoBumpMapTransform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapTransform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoBumpMapTransform self) -> SoType"""
        return _coin.SoBumpMapTransform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoBumpMapTransform_initClass()

    def __init__(self):
        r"""__init__(SoBumpMapTransform self) -> SoBumpMapTransform"""
        _coin.SoBumpMapTransform_swiginit(self, _coin.new_SoBumpMapTransform())
    translation = property(_coin.SoBumpMapTransform_translation_get, _coin.SoBumpMapTransform_translation_set, doc=r"""translation : SoSFVec2f""")
    rotation = property(_coin.SoBumpMapTransform_rotation_get, _coin.SoBumpMapTransform_rotation_set, doc=r"""rotation : SoSFFloat""")
    scaleFactor = property(_coin.SoBumpMapTransform_scaleFactor_get, _coin.SoBumpMapTransform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec2f""")
    center = property(_coin.SoBumpMapTransform_center_get, _coin.SoBumpMapTransform_center_set, doc=r"""center : SoSFVec2f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoBumpMapTransform self, SoAction action)"""
        return _coin.SoBumpMapTransform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoBumpMapTransform self, SoCallbackAction action)"""
        return _coin.SoBumpMapTransform_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoBumpMapTransform self, SoGLRenderAction action)"""
        return _coin.SoBumpMapTransform_GLRender(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoBumpMapTransform self, SoGetMatrixAction action)"""
        return _coin.SoBumpMapTransform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoBumpMapTransform self, SoPickAction action)"""
        return _coin.SoBumpMapTransform_pick(self, action)

# Register SoBumpMapTransform in _coin:
_coin.SoBumpMapTransform_swigregister(SoBumpMapTransform)

def SoBumpMapTransform_getClassTypeId() -> "SoType":
    r"""SoBumpMapTransform_getClassTypeId() -> SoType"""
    return _coin.SoBumpMapTransform_getClassTypeId()

def SoBumpMapTransform_initClass() -> "void":
    r"""SoBumpMapTransform_initClass()"""
    return _coin.SoBumpMapTransform_initClass()

class SoCallback(SoNode):
    r"""Proxy of C++ SoCallback class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCallback_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCallback self) -> SoType"""
        return _coin.SoCallback_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCallback_initClass()

    def __init__(self):
        r"""__init__(SoCallback self) -> SoCallback"""
        _coin.SoCallback_swiginit(self, _coin.new_SoCallback())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoCallback self, SoAction action)"""
        return _coin.SoCallback_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoCallback self, SoCallbackAction action)"""
        return _coin.SoCallback_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCallback self, SoGLRenderAction action)"""
        return _coin.SoCallback_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoCallback self, SoGetBoundingBoxAction action)"""
        return _coin.SoCallback_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoCallback self, SoGetMatrixAction action)"""
        return _coin.SoCallback_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoCallback self, SoHandleEventAction action)"""
        return _coin.SoCallback_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoCallback self, SoPickAction action)"""
        return _coin.SoCallback_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoCallback self, SoSearchAction action)"""
        return _coin.SoCallback_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoCallback self, SoWriteAction action)"""
        return _coin.SoCallback_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoCallback self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCallback_getPrimitiveCount(self, action)

    def setCallback(self, *args) -> "void":
        r"""
        setCallback(SoCallback self, SoCallbackCB * function, void * userdata=None)
        setCallback(SoCallback self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoCallback_setCallback(self, *args)

# Register SoCallback in _coin:
_coin.SoCallback_swigregister(SoCallback)

def SoCallback_getClassTypeId() -> "SoType":
    r"""SoCallback_getClassTypeId() -> SoType"""
    return _coin.SoCallback_getClassTypeId()

def SoCallback_initClass() -> "void":
    r"""SoCallback_initClass()"""
    return _coin.SoCallback_initClass()

SO_ASPECT_SQUARE = _coin.SO_ASPECT_SQUARE

SO_ASPECT_VIDEO = _coin.SO_ASPECT_VIDEO

SO_ASPECT_35mm_ACADEMY = _coin.SO_ASPECT_35mm_ACADEMY

SO_ASPECT_16mm = _coin.SO_ASPECT_16mm

SO_ASPECT_35mm_FULL = _coin.SO_ASPECT_35mm_FULL

SO_ASPECT_70mm = _coin.SO_ASPECT_70mm

SO_ASPECT_CINEMASCOPE = _coin.SO_ASPECT_CINEMASCOPE

SO_ASPECT_HDTV = _coin.SO_ASPECT_HDTV

SO_ASPECT_PANAVISION = _coin.SO_ASPECT_PANAVISION

SO_ASPECT_35mm = _coin.SO_ASPECT_35mm

SO_ASPECT_VISTAVISION = _coin.SO_ASPECT_VISTAVISION

class SoCamera(SoNode):
    r"""Proxy of C++ SoCamera class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCamera_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCamera self) -> SoType"""
        return _coin.SoCamera_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCamera_initClass()
    CROP_VIEWPORT_FILL_FRAME = _coin.SoCamera_CROP_VIEWPORT_FILL_FRAME
    
    CROP_VIEWPORT_LINE_FRAME = _coin.SoCamera_CROP_VIEWPORT_LINE_FRAME
    
    CROP_VIEWPORT_NO_FRAME = _coin.SoCamera_CROP_VIEWPORT_NO_FRAME
    
    ADJUST_CAMERA = _coin.SoCamera_ADJUST_CAMERA
    
    LEAVE_ALONE = _coin.SoCamera_LEAVE_ALONE
    
    viewportMapping = property(_coin.SoCamera_viewportMapping_get, _coin.SoCamera_viewportMapping_set, doc=r"""viewportMapping : SoSFEnum""")
    position = property(_coin.SoCamera_position_get, _coin.SoCamera_position_set, doc=r"""position : SoSFVec3f""")
    orientation = property(_coin.SoCamera_orientation_get, _coin.SoCamera_orientation_set, doc=r"""orientation : SoSFRotation""")
    aspectRatio = property(_coin.SoCamera_aspectRatio_get, _coin.SoCamera_aspectRatio_set, doc=r"""aspectRatio : SoSFFloat""")
    nearDistance = property(_coin.SoCamera_nearDistance_get, _coin.SoCamera_nearDistance_set, doc=r"""nearDistance : SoSFFloat""")
    farDistance = property(_coin.SoCamera_farDistance_get, _coin.SoCamera_farDistance_set, doc=r"""farDistance : SoSFFloat""")
    focalDistance = property(_coin.SoCamera_focalDistance_get, _coin.SoCamera_focalDistance_set, doc=r"""focalDistance : SoSFFloat""")

    def pointAt(self, *args) -> "void":
        r"""
        pointAt(SoCamera self, SbVec3f targetpoint)
        pointAt(SoCamera self, SbVec3f targetpoint, SbVec3f upvector)
        """
        return _coin.SoCamera_pointAt(self, *args)

    def scaleHeight(self, scalefactor: "float") -> "void":
        r"""scaleHeight(SoCamera self, float scalefactor)"""
        return _coin.SoCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, *args) -> "SbViewVolume":
        r"""
        getViewVolume(SoCamera self, SbViewportRegion vp, SbViewportRegion resultvp, SbMatrix mm=SbMatrix::identity()) -> SbViewVolume
        getViewVolume(SoCamera self, float useaspectratio=0.0) -> SbViewVolume
        """
        return _coin.SoCamera_getViewVolume(self, *args)

    def viewAll(self, *args) -> "void":
        r"""
        viewAll(SoCamera self, SoNode sceneroot, SbViewportRegion vpregion, float const slack=1.0)
        viewAll(SoCamera self, SoPath path, SbViewportRegion vpregion, float const slack=1.0)
        """
        return _coin.SoCamera_viewAll(self, *args)

    def getViewportBounds(self, region: "SbViewportRegion") -> "SbViewportRegion":
        r"""getViewportBounds(SoCamera self, SbViewportRegion region) -> SbViewportRegion"""
        return _coin.SoCamera_getViewportBounds(self, region)
    MONOSCOPIC = _coin.SoCamera_MONOSCOPIC
    
    LEFT_VIEW = _coin.SoCamera_LEFT_VIEW
    
    RIGHT_VIEW = _coin.SoCamera_RIGHT_VIEW
    

    def setStereoMode(self, mode: "SoCamera::StereoMode") -> "void":
        r"""setStereoMode(SoCamera self, SoCamera::StereoMode mode)"""
        return _coin.SoCamera_setStereoMode(self, mode)

    def getStereoMode(self) -> "SoCamera::StereoMode":
        r"""getStereoMode(SoCamera self) -> SoCamera::StereoMode"""
        return _coin.SoCamera_getStereoMode(self)

    def setStereoAdjustment(self, adjustment: "float") -> "void":
        r"""setStereoAdjustment(SoCamera self, float adjustment)"""
        return _coin.SoCamera_setStereoAdjustment(self, adjustment)

    def getStereoAdjustment(self) -> "float":
        r"""getStereoAdjustment(SoCamera self) -> float"""
        return _coin.SoCamera_getStereoAdjustment(self)

    def setBalanceAdjustment(self, adjustment: "float") -> "void":
        r"""setBalanceAdjustment(SoCamera self, float adjustment)"""
        return _coin.SoCamera_setBalanceAdjustment(self, adjustment)

    def getBalanceAdjustment(self) -> "float":
        r"""getBalanceAdjustment(SoCamera self) -> float"""
        return _coin.SoCamera_getBalanceAdjustment(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoCamera self, SoAction action)"""
        return _coin.SoCamera_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoCamera self, SoCallbackAction action)"""
        return _coin.SoCamera_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCamera self, SoGLRenderAction action)"""
        return _coin.SoCamera_GLRender(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoCamera self, SoAudioRenderAction action)"""
        return _coin.SoCamera_audioRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoCamera self, SoGetBoundingBoxAction action)"""
        return _coin.SoCamera_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoCamera self, SoGetMatrixAction action)"""
        return _coin.SoCamera_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoCamera self, SoHandleEventAction action)"""
        return _coin.SoCamera_handleEvent(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoCamera self, SoRayPickAction action)"""
        return _coin.SoCamera_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoCamera self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCamera_getPrimitiveCount(self, action)

    def viewBoundingBox(self, box: "SbBox3f", aspect: "float", slack: "float") -> "void":
        r"""viewBoundingBox(SoCamera self, SbBox3f box, float aspect, float slack)"""
        return _coin.SoCamera_viewBoundingBox(self, box, aspect, slack)

# Register SoCamera in _coin:
_coin.SoCamera_swigregister(SoCamera)

def SoCamera_getClassTypeId() -> "SoType":
    r"""SoCamera_getClassTypeId() -> SoType"""
    return _coin.SoCamera_getClassTypeId()

def SoCamera_initClass() -> "void":
    r"""SoCamera_initClass()"""
    return _coin.SoCamera_initClass()

class SoColorIndex(SoNode):
    r"""Proxy of C++ SoColorIndex class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoColorIndex_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoColorIndex self) -> SoType"""
        return _coin.SoColorIndex_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoColorIndex_initClass()

    def __init__(self):
        r"""__init__(SoColorIndex self) -> SoColorIndex"""
        _coin.SoColorIndex_swiginit(self, _coin.new_SoColorIndex())
    index = property(_coin.SoColorIndex_index_get, _coin.SoColorIndex_index_set, doc=r"""index : SoMFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoColorIndex self, SoGLRenderAction action)"""
        return _coin.SoColorIndex_GLRender(self, action)

# Register SoColorIndex in _coin:
_coin.SoColorIndex_swigregister(SoColorIndex)

def SoColorIndex_getClassTypeId() -> "SoType":
    r"""SoColorIndex_getClassTypeId() -> SoType"""
    return _coin.SoColorIndex_getClassTypeId()

def SoColorIndex_initClass() -> "void":
    r"""SoColorIndex_initClass()"""
    return _coin.SoColorIndex_initClass()

class SoCone(SoShape):
    r"""Proxy of C++ SoCone class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCone_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCone self) -> SoType"""
        return _coin.SoCone_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCone_initClass()

    def __init__(self):
        r"""__init__(SoCone self) -> SoCone"""
        _coin.SoCone_swiginit(self, _coin.new_SoCone())
    SIDES = _coin.SoCone_SIDES
    
    BOTTOM = _coin.SoCone_BOTTOM
    
    ALL = _coin.SoCone_ALL
    
    parts = property(_coin.SoCone_parts_get, _coin.SoCone_parts_set, doc=r"""parts : SoSFBitMask""")
    bottomRadius = property(_coin.SoCone_bottomRadius_get, _coin.SoCone_bottomRadius_set, doc=r"""bottomRadius : SoSFFloat""")
    height = property(_coin.SoCone_height_get, _coin.SoCone_height_set, doc=r"""height : SoSFFloat""")

    def addPart(self, part: "SoCone::Part") -> "void":
        r"""addPart(SoCone self, SoCone::Part part)"""
        return _coin.SoCone_addPart(self, part)

    def removePart(self, part: "SoCone::Part") -> "void":
        r"""removePart(SoCone self, SoCone::Part part)"""
        return _coin.SoCone_removePart(self, part)

    def hasPart(self, part: "SoCone::Part") -> "SbBool":
        r"""hasPart(SoCone self, SoCone::Part part) -> SbBool"""
        return _coin.SoCone_hasPart(self, part)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCone self, SoGLRenderAction action)"""
        return _coin.SoCone_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoCone self, SoRayPickAction action)"""
        return _coin.SoCone_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoCone self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCone_getPrimitiveCount(self, action)

# Register SoCone in _coin:
_coin.SoCone_swigregister(SoCone)

def SoCone_getClassTypeId() -> "SoType":
    r"""SoCone_getClassTypeId() -> SoType"""
    return _coin.SoCone_getClassTypeId()

def SoCone_initClass() -> "void":
    r"""SoCone_initClass()"""
    return _coin.SoCone_initClass()

class SoCoordinate3(SoNode):
    r"""Proxy of C++ SoCoordinate3 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCoordinate3_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCoordinate3 self) -> SoType"""
        return _coin.SoCoordinate3_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCoordinate3_initClass()

    def __init__(self):
        r"""__init__(SoCoordinate3 self) -> SoCoordinate3"""
        _coin.SoCoordinate3_swiginit(self, _coin.new_SoCoordinate3())
    point = property(_coin.SoCoordinate3_point_get, _coin.SoCoordinate3_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoCoordinate3 self, SoAction action)"""
        return _coin.SoCoordinate3_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoCoordinate3_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoCoordinate3_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoCoordinate3 self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate3_getBoundingBox(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoCoordinate3 self, SoPickAction action)"""
        return _coin.SoCoordinate3_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoCoordinate3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate3_getPrimitiveCount(self, action)

# Register SoCoordinate3 in _coin:
_coin.SoCoordinate3_swigregister(SoCoordinate3)

def SoCoordinate3_getClassTypeId() -> "SoType":
    r"""SoCoordinate3_getClassTypeId() -> SoType"""
    return _coin.SoCoordinate3_getClassTypeId()

def SoCoordinate3_initClass() -> "void":
    r"""SoCoordinate3_initClass()"""
    return _coin.SoCoordinate3_initClass()

class SoCoordinate4(SoNode):
    r"""Proxy of C++ SoCoordinate4 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCoordinate4_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCoordinate4 self) -> SoType"""
        return _coin.SoCoordinate4_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCoordinate4_initClass()

    def __init__(self):
        r"""__init__(SoCoordinate4 self) -> SoCoordinate4"""
        _coin.SoCoordinate4_swiginit(self, _coin.new_SoCoordinate4())
    point = property(_coin.SoCoordinate4_point_get, _coin.SoCoordinate4_point_set, doc=r"""point : SoMFVec4f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoCoordinate4 self, SoAction action)"""
        return _coin.SoCoordinate4_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCoordinate4 self, SoGLRenderAction action)"""
        return _coin.SoCoordinate4_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoCoordinate4 self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate4_getBoundingBox(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoCoordinate4 self, SoCallbackAction action)"""
        return _coin.SoCoordinate4_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoCoordinate4 self, SoPickAction action)"""
        return _coin.SoCoordinate4_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoCoordinate4 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate4_getPrimitiveCount(self, action)

# Register SoCoordinate4 in _coin:
_coin.SoCoordinate4_swigregister(SoCoordinate4)

def SoCoordinate4_getClassTypeId() -> "SoType":
    r"""SoCoordinate4_getClassTypeId() -> SoType"""
    return _coin.SoCoordinate4_getClassTypeId()

def SoCoordinate4_initClass() -> "void":
    r"""SoCoordinate4_initClass()"""
    return _coin.SoCoordinate4_initClass()

class SoCube(SoShape):
    r"""Proxy of C++ SoCube class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCube_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCube self) -> SoType"""
        return _coin.SoCube_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCube_initClass()

    def __init__(self):
        r"""__init__(SoCube self) -> SoCube"""
        _coin.SoCube_swiginit(self, _coin.new_SoCube())
    width = property(_coin.SoCube_width_get, _coin.SoCube_width_set, doc=r"""width : SoSFFloat""")
    height = property(_coin.SoCube_height_get, _coin.SoCube_height_set, doc=r"""height : SoSFFloat""")
    depth = property(_coin.SoCube_depth_get, _coin.SoCube_depth_set, doc=r"""depth : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCube self, SoGLRenderAction action)"""
        return _coin.SoCube_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoCube self, SoRayPickAction action)"""
        return _coin.SoCube_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoCube self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCube_getPrimitiveCount(self, action)

# Register SoCube in _coin:
_coin.SoCube_swigregister(SoCube)

def SoCube_getClassTypeId() -> "SoType":
    r"""SoCube_getClassTypeId() -> SoType"""
    return _coin.SoCube_getClassTypeId()

def SoCube_initClass() -> "void":
    r"""SoCube_initClass()"""
    return _coin.SoCube_initClass()

class SoCylinder(SoShape):
    r"""Proxy of C++ SoCylinder class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCylinder_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCylinder self) -> SoType"""
        return _coin.SoCylinder_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCylinder_initClass()

    def __init__(self):
        r"""__init__(SoCylinder self) -> SoCylinder"""
        _coin.SoCylinder_swiginit(self, _coin.new_SoCylinder())
    SIDES = _coin.SoCylinder_SIDES
    
    TOP = _coin.SoCylinder_TOP
    
    BOTTOM = _coin.SoCylinder_BOTTOM
    
    ALL = _coin.SoCylinder_ALL
    
    radius = property(_coin.SoCylinder_radius_get, _coin.SoCylinder_radius_set, doc=r"""radius : SoSFFloat""")
    height = property(_coin.SoCylinder_height_get, _coin.SoCylinder_height_set, doc=r"""height : SoSFFloat""")
    parts = property(_coin.SoCylinder_parts_get, _coin.SoCylinder_parts_set, doc=r"""parts : SoSFBitMask""")

    def addPart(self, part: "SoCylinder::Part") -> "void":
        r"""addPart(SoCylinder self, SoCylinder::Part part)"""
        return _coin.SoCylinder_addPart(self, part)

    def removePart(self, part: "SoCylinder::Part") -> "void":
        r"""removePart(SoCylinder self, SoCylinder::Part part)"""
        return _coin.SoCylinder_removePart(self, part)

    def hasPart(self, part: "SoCylinder::Part") -> "SbBool":
        r"""hasPart(SoCylinder self, SoCylinder::Part part) -> SbBool"""
        return _coin.SoCylinder_hasPart(self, part)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoCylinder self, SoRayPickAction action)"""
        return _coin.SoCylinder_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoCylinder self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCylinder_getPrimitiveCount(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCylinder self, SoGLRenderAction action)"""
        return _coin.SoCylinder_GLRender(self, action)

# Register SoCylinder in _coin:
_coin.SoCylinder_swigregister(SoCylinder)

def SoCylinder_getClassTypeId() -> "SoType":
    r"""SoCylinder_getClassTypeId() -> SoType"""
    return _coin.SoCylinder_getClassTypeId()

def SoCylinder_initClass() -> "void":
    r"""SoCylinder_initClass()"""
    return _coin.SoCylinder_initClass()

class SoEnvironment(SoNode):
    r"""Proxy of C++ SoEnvironment class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEnvironment_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoEnvironment self) -> SoType"""
        return _coin.SoEnvironment_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoEnvironment_initClass()

    def __init__(self):
        r"""__init__(SoEnvironment self) -> SoEnvironment"""
        _coin.SoEnvironment_swiginit(self, _coin.new_SoEnvironment())
    NONE = _coin.SoEnvironment_NONE
    
    HAZE = _coin.SoEnvironment_HAZE
    
    FOG = _coin.SoEnvironment_FOG
    
    SMOKE = _coin.SoEnvironment_SMOKE
    

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoEnvironment self, SoGLRenderAction action)"""
        return _coin.SoEnvironment_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoEnvironment self, SoCallbackAction action)"""
        return _coin.SoEnvironment_callback(self, action)
    ambientIntensity = property(_coin.SoEnvironment_ambientIntensity_get, _coin.SoEnvironment_ambientIntensity_set, doc=r"""ambientIntensity : SoSFFloat""")
    ambientColor = property(_coin.SoEnvironment_ambientColor_get, _coin.SoEnvironment_ambientColor_set, doc=r"""ambientColor : SoSFColor""")
    attenuation = property(_coin.SoEnvironment_attenuation_get, _coin.SoEnvironment_attenuation_set, doc=r"""attenuation : SoSFVec3f""")
    fogType = property(_coin.SoEnvironment_fogType_get, _coin.SoEnvironment_fogType_set, doc=r"""fogType : SoSFEnum""")
    fogColor = property(_coin.SoEnvironment_fogColor_get, _coin.SoEnvironment_fogColor_set, doc=r"""fogColor : SoSFColor""")
    fogVisibility = property(_coin.SoEnvironment_fogVisibility_get, _coin.SoEnvironment_fogVisibility_set, doc=r"""fogVisibility : SoSFFloat""")

# Register SoEnvironment in _coin:
_coin.SoEnvironment_swigregister(SoEnvironment)

def SoEnvironment_getClassTypeId() -> "SoType":
    r"""SoEnvironment_getClassTypeId() -> SoType"""
    return _coin.SoEnvironment_getClassTypeId()

def SoEnvironment_initClass() -> "void":
    r"""SoEnvironment_initClass()"""
    return _coin.SoEnvironment_initClass()

class SoEventCallback(SoNode):
    r"""Proxy of C++ SoEventCallback class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEventCallback_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoEventCallback self) -> SoType"""
        return _coin.SoEventCallback_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoEventCallback_initClass()

    def __init__(self):
        r"""__init__(SoEventCallback self) -> SoEventCallback"""
        _coin.SoEventCallback_swiginit(self, _coin.new_SoEventCallback())

    def setPath(self, path: "SoPath") -> "void":
        r"""setPath(SoEventCallback self, SoPath path)"""
        return _coin.SoEventCallback_setPath(self, path)

    def getPath(self) -> "SoPath const *":
        r"""getPath(SoEventCallback self) -> SoPath"""
        return _coin.SoEventCallback_getPath(self)

    def getAction(self) -> "SoHandleEventAction *":
        r"""getAction(SoEventCallback self) -> SoHandleEventAction"""
        return _coin.SoEventCallback_getAction(self)

    def getEvent(self) -> "SoEvent const *":
        r"""getEvent(SoEventCallback self) -> SoEvent"""
        return _coin.SoEventCallback_getEvent(self)

    def getPickedPoint(self) -> "SoPickedPoint const *":
        r"""getPickedPoint(SoEventCallback self) -> SoPickedPoint"""
        return _coin.SoEventCallback_getPickedPoint(self)

    def setHandled(self) -> "void":
        r"""setHandled(SoEventCallback self)"""
        return _coin.SoEventCallback_setHandled(self)

    def isHandled(self) -> "SbBool":
        r"""isHandled(SoEventCallback self) -> SbBool"""
        return _coin.SoEventCallback_isHandled(self)

    def grabEvents(self) -> "void":
        r"""grabEvents(SoEventCallback self)"""
        return _coin.SoEventCallback_grabEvents(self)

    def releaseEvents(self) -> "void":
        r"""releaseEvents(SoEventCallback self)"""
        return _coin.SoEventCallback_releaseEvents(self)

    def addEventCallback(self, *args) -> "PyObject *":
        r"""
        addEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)
        addEventCallback(SoEventCallback self, SoType eventtype, PyObject * pyfunc, PyObject * userdata=None) -> PyObject
        """
        return _coin.SoEventCallback_addEventCallback(self, *args)

    def removeEventCallback(self, *args) -> "void":
        r"""
        removeEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)
        removeEventCallback(SoEventCallback self, SoType eventtype, PyObject * tuple)
        """
        return _coin.SoEventCallback_removeEventCallback(self, *args)

# Register SoEventCallback in _coin:
_coin.SoEventCallback_swigregister(SoEventCallback)

def SoEventCallback_getClassTypeId() -> "SoType":
    r"""SoEventCallback_getClassTypeId() -> SoType"""
    return _coin.SoEventCallback_getClassTypeId()

def SoEventCallback_initClass() -> "void":
    r"""SoEventCallback_initClass()"""
    return _coin.SoEventCallback_initClass()

class SoSelection(SoSeparator):
    r"""Proxy of C++ SoSelection class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSelection_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSelection self) -> SoType"""
        return _coin.SoSelection_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSelection_initClass()
    SINGLE = _coin.SoSelection_SINGLE
    
    TOGGLE = _coin.SoSelection_TOGGLE
    
    SHIFT = _coin.SoSelection_SHIFT
    
    DISABLE = _coin.SoSelection_DISABLE
    
    policy = property(_coin.SoSelection_policy_get, _coin.SoSelection_policy_set, doc=r"""policy : SoSFEnum""")

    def __init__(self, *args):
        r"""
        __init__(SoSelection self) -> SoSelection
        __init__(SoSelection self, int const nChildren) -> SoSelection
        """
        _coin.SoSelection_swiginit(self, _coin.new_SoSelection(*args))

    def select(self, *args) -> "void":
        r"""
        select(SoSelection self, SoPath path)
        select(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_select(self, *args)

    def deselect(self, *args) -> "void":
        r"""
        deselect(SoSelection self, SoPath path)
        deselect(SoSelection self, int const which)
        deselect(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_deselect(self, *args)

    def toggle(self, *args) -> "void":
        r"""
        toggle(SoSelection self, SoPath path)
        toggle(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_toggle(self, *args)

    def isSelected(self, *args) -> "SbBool":
        r"""
        isSelected(SoSelection self, SoPath path) -> SbBool
        isSelected(SoSelection self, SoNode node) -> SbBool
        """
        return _coin.SoSelection_isSelected(self, *args)

    def deselectAll(self) -> "void":
        r"""deselectAll(SoSelection self)"""
        return _coin.SoSelection_deselectAll(self)

    def getNumSelected(self) -> "int":
        r"""getNumSelected(SoSelection self) -> int"""
        return _coin.SoSelection_getNumSelected(self)

    def getList(self) -> "SoPathList const *":
        r"""getList(SoSelection self) -> SoPathList"""
        return _coin.SoSelection_getList(self)

    def getPath(self, index: "int const") -> "SoPath *":
        r"""getPath(SoSelection self, int const index) -> SoPath"""
        return _coin.SoSelection_getPath(self, index)

    def setPickMatching(self, pickMatching: "SbBool const") -> "void":
        r"""setPickMatching(SoSelection self, SbBool const pickMatching)"""
        return _coin.SoSelection_setPickMatching(self, pickMatching)

    def isPickMatching(self) -> "SbBool":
        r"""isPickMatching(SoSelection self) -> SbBool"""
        return _coin.SoSelection_isPickMatching(self)

    def getPickMatching(self) -> "SbBool":
        r"""getPickMatching(SoSelection self) -> SbBool"""
        return _coin.SoSelection_getPickMatching(self)

    def addSelectionCallback(self, *args) -> "void":
        r"""
        addSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        addSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addSelectionCallback(self, *args)

    def removeSelectionCallback(self, *args) -> "void":
        r"""
        removeSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        removeSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeSelectionCallback(self, *args)

    def addDeselectionCallback(self, *args) -> "void":
        r"""
        addDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        addDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addDeselectionCallback(self, *args)

    def removeDeselectionCallback(self, *args) -> "void":
        r"""
        removeDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        removeDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeDeselectionCallback(self, *args)

    def addStartCallback(self, *args) -> "void":
        r"""
        addStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addStartCallback(self, *args)

    def removeStartCallback(self, *args) -> "void":
        r"""
        removeStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeStartCallback(self, *args)

    def addFinishCallback(self, *args) -> "void":
        r"""
        addFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addFinishCallback(self, *args)

    def removeFinishCallback(self, *args) -> "void":
        r"""
        removeFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeFinishCallback(self, *args)

    def setPickFilterCallback(self, *args) -> "void":
        r"""
        setPickFilterCallback(SoSelection self, SoSelectionPickCB * f, void * userData=None, SbBool const callOnlyIfSelectable=1)
        setPickFilterCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None, int callOnlyIfSelectable=1)
        """
        return _coin.SoSelection_setPickFilterCallback(self, *args)

    def addChangeCallback(self, *args) -> "void":
        r"""
        addChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addChangeCallback(self, *args)

    def removeChangeCallback(self, *args) -> "void":
        r"""
        removeChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeChangeCallback(self, *args)

# Register SoSelection in _coin:
_coin.SoSelection_swigregister(SoSelection)

def SoSelection_getClassTypeId() -> "SoType":
    r"""SoSelection_getClassTypeId() -> SoType"""
    return _coin.SoSelection_getClassTypeId()

def SoSelection_initClass() -> "void":
    r"""SoSelection_initClass()"""
    return _coin.SoSelection_initClass()

class SoExtSelection(SoSelection):
    r"""Proxy of C++ SoExtSelection class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoExtSelection_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoExtSelection self) -> SoType"""
        return _coin.SoExtSelection_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoExtSelection_initClass()

    def __init__(self):
        r"""__init__(SoExtSelection self) -> SoExtSelection"""
        _coin.SoExtSelection_swiginit(self, _coin.new_SoExtSelection())
    NOLASSO = _coin.SoExtSelection_NOLASSO
    
    LASSO = _coin.SoExtSelection_LASSO
    
    RECTANGLE = _coin.SoExtSelection_RECTANGLE
    
    FULL_BBOX = _coin.SoExtSelection_FULL_BBOX
    
    PART_BBOX = _coin.SoExtSelection_PART_BBOX
    
    FULL = _coin.SoExtSelection_FULL
    
    PART = _coin.SoExtSelection_PART
    
    ALL_SHAPES = _coin.SoExtSelection_ALL_SHAPES
    
    VISIBLE_SHAPES = _coin.SoExtSelection_VISIBLE_SHAPES
    
    lassoType = property(_coin.SoExtSelection_lassoType_get, _coin.SoExtSelection_lassoType_set, doc=r"""lassoType : SoSFEnum""")
    lassoPolicy = property(_coin.SoExtSelection_lassoPolicy_get, _coin.SoExtSelection_lassoPolicy_set, doc=r"""lassoPolicy : SoSFEnum""")
    lassoMode = property(_coin.SoExtSelection_lassoMode_get, _coin.SoExtSelection_lassoMode_set, doc=r"""lassoMode : SoSFEnum""")

    def useOverlay(self, overlay: "SbBool"=1) -> "void":
        r"""useOverlay(SoExtSelection self, SbBool overlay=1)"""
        return _coin.SoExtSelection_useOverlay(self, overlay)

    def isUsingOverlay(self) -> "SbBool":
        r"""isUsingOverlay(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_isUsingOverlay(self)

    def getOverlaySceneGraph(self) -> "SoSeparator *":
        r"""getOverlaySceneGraph(SoExtSelection self) -> SoSeparator"""
        return _coin.SoExtSelection_getOverlaySceneGraph(self)

    def setOverlayLassoColorIndex(self, index: "int const") -> "void":
        r"""setOverlayLassoColorIndex(SoExtSelection self, int const index)"""
        return _coin.SoExtSelection_setOverlayLassoColorIndex(self, index)

    def getOverlayLassoColorIndex(self) -> "int":
        r"""getOverlayLassoColorIndex(SoExtSelection self) -> int"""
        return _coin.SoExtSelection_getOverlayLassoColorIndex(self)

    def setLassoColor(self, color: "SbColor") -> "void":
        r"""setLassoColor(SoExtSelection self, SbColor color)"""
        return _coin.SoExtSelection_setLassoColor(self, color)

    def getLassoColor(self) -> "SbColor const &":
        r"""getLassoColor(SoExtSelection self) -> SbColor"""
        return _coin.SoExtSelection_getLassoColor(self)

    def setLassoWidth(self, width: "float const") -> "void":
        r"""setLassoWidth(SoExtSelection self, float const width)"""
        return _coin.SoExtSelection_setLassoWidth(self, width)

    def getLassoWidth(self) -> "float":
        r"""getLassoWidth(SoExtSelection self) -> float"""
        return _coin.SoExtSelection_getLassoWidth(self)

    def setOverlayLassoPattern(self, pattern: "unsigned short const") -> "void":
        r"""setOverlayLassoPattern(SoExtSelection self, unsigned short const pattern)"""
        return _coin.SoExtSelection_setOverlayLassoPattern(self, pattern)

    def getOverlayLassoPattern(self) -> "unsigned short":
        r"""getOverlayLassoPattern(SoExtSelection self) -> unsigned short"""
        return _coin.SoExtSelection_getOverlayLassoPattern(self)

    def animateOverlayLasso(self, animate: "SbBool const"=1) -> "void":
        r"""animateOverlayLasso(SoExtSelection self, SbBool const animate=1)"""
        return _coin.SoExtSelection_animateOverlayLasso(self, animate)

    def isOverlayLassoAnimated(self) -> "SbBool":
        r"""isOverlayLassoAnimated(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_isOverlayLassoAnimated(self)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoExtSelection self, SoHandleEventAction action)"""
        return _coin.SoExtSelection_handleEvent(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoExtSelection self, SoGLRenderAction action)"""
        return _coin.SoExtSelection_GLRenderBelowPath(self, action)

    def select(self, *args) -> "void":
        r"""
        select(SoExtSelection self, SoNode root, int numcoords, SbVec2f lasso, SbViewportRegion vp, SbBool shiftpolicy)
        select(SoExtSelection self, SoNode root, int numcoords, SbVec3f lasso, SbViewportRegion vp, SbBool shiftkeypolicy)
        """
        return _coin.SoExtSelection_select(self, *args)

    def getLassoCoordsDC(self, numCoords: "int &") -> "SbVec2s const *":
        r"""getLassoCoordsDC(SoExtSelection self, int & numCoords) -> SbVec2s"""
        return _coin.SoExtSelection_getLassoCoordsDC(self, numCoords)

    def getLassoCoordsWC(self, numCoords: "int &") -> "SbVec3f const *":
        r"""getLassoCoordsWC(SoExtSelection self, int & numCoords) -> SbVec3f"""
        return _coin.SoExtSelection_getLassoCoordsWC(self, numCoords)

    def getSelectionPathList(self) -> "SoPathList const &":
        r"""getSelectionPathList(SoExtSelection self) -> SoPathList"""
        return _coin.SoExtSelection_getSelectionPathList(self)

    def setLassoFilterCallback(self, f: "SoLassoSelectionFilterCB *", userdata: "void *"=None, callonlyifselectable: "SbBool const"=1) -> "void":
        r"""setLassoFilterCallback(SoExtSelection self, SoLassoSelectionFilterCB * f, void * userdata=None, SbBool const callonlyifselectable=1)"""
        return _coin.SoExtSelection_setLassoFilterCallback(self, f, userdata, callonlyifselectable)

    def setTriangleFilterCallback(self, func: "SoExtSelectionTriangleCB *", userdata: "void *"=None) -> "void":
        r"""setTriangleFilterCallback(SoExtSelection self, SoExtSelectionTriangleCB * func, void * userdata=None)"""
        return _coin.SoExtSelection_setTriangleFilterCallback(self, func, userdata)

    def setLineSegmentFilterCallback(self, func: "SoExtSelectionLineSegmentCB *", userdata: "void *"=None) -> "void":
        r"""setLineSegmentFilterCallback(SoExtSelection self, SoExtSelectionLineSegmentCB * func, void * userdata=None)"""
        return _coin.SoExtSelection_setLineSegmentFilterCallback(self, func, userdata)

    def setPointFilterCallback(self, func: "SoExtSelectionPointCB *", userdata: "void *"=None) -> "void":
        r"""setPointFilterCallback(SoExtSelection self, SoExtSelectionPointCB * func, void * userdata=None)"""
        return _coin.SoExtSelection_setPointFilterCallback(self, func, userdata)

    def wasShiftDown(self) -> "SbBool":
        r"""wasShiftDown(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_wasShiftDown(self)

# Register SoExtSelection in _coin:
_coin.SoExtSelection_swigregister(SoExtSelection)

def SoExtSelection_getClassTypeId() -> "SoType":
    r"""SoExtSelection_getClassTypeId() -> SoType"""
    return _coin.SoExtSelection_getClassTypeId()

def SoExtSelection_initClass() -> "void":
    r"""SoExtSelection_initClass()"""
    return _coin.SoExtSelection_initClass()

class SoVertexProperty(SoNode):
    r"""Proxy of C++ SoVertexProperty class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexProperty_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVertexProperty self) -> SoType"""
        return _coin.SoVertexProperty_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVertexProperty_initClass()

    def __init__(self):
        r"""__init__(SoVertexProperty self) -> SoVertexProperty"""
        _coin.SoVertexProperty_swiginit(self, _coin.new_SoVertexProperty())
    OVERALL = _coin.SoVertexProperty_OVERALL
    
    PER_PART = _coin.SoVertexProperty_PER_PART
    
    PER_PART_INDEXED = _coin.SoVertexProperty_PER_PART_INDEXED
    
    PER_FACE = _coin.SoVertexProperty_PER_FACE
    
    PER_FACE_INDEXED = _coin.SoVertexProperty_PER_FACE_INDEXED
    
    PER_VERTEX = _coin.SoVertexProperty_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoVertexProperty_PER_VERTEX_INDEXED
    
    vertex = property(_coin.SoVertexProperty_vertex_get, _coin.SoVertexProperty_vertex_set, doc=r"""vertex : SoMFVec3f""")
    texCoord = property(_coin.SoVertexProperty_texCoord_get, _coin.SoVertexProperty_texCoord_set, doc=r"""texCoord : SoMFVec2f""")
    texCoord3 = property(_coin.SoVertexProperty_texCoord3_get, _coin.SoVertexProperty_texCoord3_set, doc=r"""texCoord3 : SoMFVec3f""")
    normal = property(_coin.SoVertexProperty_normal_get, _coin.SoVertexProperty_normal_set, doc=r"""normal : SoMFVec3f""")
    normalBinding = property(_coin.SoVertexProperty_normalBinding_get, _coin.SoVertexProperty_normalBinding_set, doc=r"""normalBinding : SoSFEnum""")
    orderedRGBA = property(_coin.SoVertexProperty_orderedRGBA_get, _coin.SoVertexProperty_orderedRGBA_set, doc=r"""orderedRGBA : SoMFUInt32""")
    materialBinding = property(_coin.SoVertexProperty_materialBinding_get, _coin.SoVertexProperty_materialBinding_set, doc=r"""materialBinding : SoSFEnum""")
    textureUnit = property(_coin.SoVertexProperty_textureUnit_get, _coin.SoVertexProperty_textureUnit_set, doc=r"""textureUnit : SoMFInt32""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVertexProperty self, SoAction action)"""
        return _coin.SoVertexProperty_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVertexProperty self, SoGLRenderAction action)"""
        return _coin.SoVertexProperty_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVertexProperty self, SoGetBoundingBoxAction action)"""
        return _coin.SoVertexProperty_getBoundingBox(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVertexProperty self, SoCallbackAction action)"""
        return _coin.SoVertexProperty_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVertexProperty self, SoPickAction action)"""
        return _coin.SoVertexProperty_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVertexProperty self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexProperty_getPrimitiveCount(self, action)

# Register SoVertexProperty in _coin:
_coin.SoVertexProperty_swigregister(SoVertexProperty)

def SoVertexProperty_getClassTypeId() -> "SoType":
    r"""SoVertexProperty_getClassTypeId() -> SoType"""
    return _coin.SoVertexProperty_getClassTypeId()

def SoVertexProperty_initClass() -> "void":
    r"""SoVertexProperty_initClass()"""
    return _coin.SoVertexProperty_initClass()

class SoVertexShape(SoShape):
    r"""Proxy of C++ SoVertexShape class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexShape_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVertexShape self) -> SoType"""
        return _coin.SoVertexShape_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVertexShape_initClass()
    vertexProperty = property(_coin.SoVertexShape_vertexProperty_get, _coin.SoVertexShape_vertexProperty_set, doc=r"""vertexProperty : SoSFNode""")

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoVertexShape self, SoNotList nl)"""
        return _coin.SoVertexShape_notify(self, nl)

    def generateDefaultNormals(self, *args) -> "SbBool":
        r"""
        generateDefaultNormals(SoVertexShape self, SoState state, SoNormalBundle bundle) -> SbBool
        generateDefaultNormals(SoVertexShape self, SoState state, SoNormalCache cache) -> SbBool
        """
        return _coin.SoVertexShape_generateDefaultNormals(self, *args)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVertexShape self, SoWriteAction action)"""
        return _coin.SoVertexShape_write(self, action)

# Register SoVertexShape in _coin:
_coin.SoVertexShape_swigregister(SoVertexShape)

def SoVertexShape_getClassTypeId() -> "SoType":
    r"""SoVertexShape_getClassTypeId() -> SoType"""
    return _coin.SoVertexShape_getClassTypeId()

def SoVertexShape_initClass() -> "void":
    r"""SoVertexShape_initClass()"""
    return _coin.SoVertexShape_initClass()

class SoNonIndexedShape(SoVertexShape):
    r"""Proxy of C++ SoNonIndexedShape class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNonIndexedShape_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNonIndexedShape self) -> SoType"""
        return _coin.SoNonIndexedShape_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNonIndexedShape_initClass()
    startIndex = property(_coin.SoNonIndexedShape_startIndex_get, _coin.SoNonIndexedShape_startIndex_set, doc=r"""startIndex : SoSFInt32""")

# Register SoNonIndexedShape in _coin:
_coin.SoNonIndexedShape_swigregister(SoNonIndexedShape)

def SoNonIndexedShape_getClassTypeId() -> "SoType":
    r"""SoNonIndexedShape_getClassTypeId() -> SoType"""
    return _coin.SoNonIndexedShape_getClassTypeId()

def SoNonIndexedShape_initClass() -> "void":
    r"""SoNonIndexedShape_initClass()"""
    return _coin.SoNonIndexedShape_initClass()

class SoFaceSet(SoNonIndexedShape):
    r"""Proxy of C++ SoFaceSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFaceSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFaceSet self) -> SoType"""
        return _coin.SoFaceSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFaceSet_initClass()

    def __init__(self):
        r"""__init__(SoFaceSet self) -> SoFaceSet"""
        _coin.SoFaceSet_swiginit(self, _coin.new_SoFaceSet())
    numVertices = property(_coin.SoFaceSet_numVertices_get, _coin.SoFaceSet_numVertices_set, doc=r"""numVertices : SoMFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoFaceSet self, SoGLRenderAction action)"""
        return _coin.SoFaceSet_GLRender(self, action)

    def generateDefaultNormals(self, state: "SoState", nb: "SoNormalBundle") -> "SbBool":
        r"""generateDefaultNormals(SoFaceSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoFaceSet_generateDefaultNormals(self, state, nb)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFaceSet_getPrimitiveCount(self, action)

# Register SoFaceSet in _coin:
_coin.SoFaceSet_swigregister(SoFaceSet)

def SoFaceSet_getClassTypeId() -> "SoType":
    r"""SoFaceSet_getClassTypeId() -> SoType"""
    return _coin.SoFaceSet_getClassTypeId()

def SoFaceSet_initClass() -> "void":
    r"""SoFaceSet_initClass()"""
    return _coin.SoFaceSet_initClass()

class SoFile(SoNode):
    r"""Proxy of C++ SoFile class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFile_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFile self) -> SoType"""
        return _coin.SoFile_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFile_initClass()

    def __init__(self):
        r"""__init__(SoFile self) -> SoFile"""
        _coin.SoFile_swiginit(self, _coin.new_SoFile())
    name = property(_coin.SoFile_name_get, _coin.SoFile_name_set, doc=r"""name : SoSFString""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoFile self, SoAction action)"""
        return _coin.SoFile_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoFile self, SoCallbackAction action)"""
        return _coin.SoFile_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoFile self, SoGLRenderAction action)"""
        return _coin.SoFile_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoFile self, SoGetBoundingBoxAction action)"""
        return _coin.SoFile_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoFile self, SoGetMatrixAction action)"""
        return _coin.SoFile_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoFile self, SoHandleEventAction action)"""
        return _coin.SoFile_handleEvent(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoFile self, SoPickAction action)"""
        return _coin.SoFile_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoFile self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFile_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoFile self, SoAudioRenderAction action)"""
        return _coin.SoFile_audioRender(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoFile self, SoSearchAction action)"""
        return _coin.SoFile_search(self, action)

    def copyChildren(self) -> "SoGroup *":
        r"""copyChildren(SoFile self) -> SoGroup"""
        return _coin.SoFile_copyChildren(self)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoFile self) -> SoChildList"""
        return _coin.SoFile_getChildren(self)

    def copyContents(self, srcFrom: "SoFieldContainer", copyconnections: "SbBool") -> "void":
        r"""copyContents(SoFile self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoFile_copyContents(self, srcFrom, copyconnections)

    def getFullName(self) -> "SbString const &":
        r"""getFullName(SoFile self) -> SbString"""
        return _coin.SoFile_getFullName(self)

    @staticmethod
    def setSearchOK(dosearch: "SbBool") -> "void":
        r"""setSearchOK(SbBool dosearch)"""
        return _coin.SoFile_setSearchOK(dosearch)

    @staticmethod
    def getSearchOK() -> "SbBool":
        r"""getSearchOK() -> SbBool"""
        return _coin.SoFile_getSearchOK()

# Register SoFile in _coin:
_coin.SoFile_swigregister(SoFile)

def SoFile_getClassTypeId() -> "SoType":
    r"""SoFile_getClassTypeId() -> SoType"""
    return _coin.SoFile_getClassTypeId()

def SoFile_initClass() -> "void":
    r"""SoFile_initClass()"""
    return _coin.SoFile_initClass()

def SoFile_setSearchOK(dosearch: "SbBool") -> "void":
    r"""SoFile_setSearchOK(SbBool dosearch)"""
    return _coin.SoFile_setSearchOK(dosearch)

def SoFile_getSearchOK() -> "SbBool":
    r"""SoFile_getSearchOK() -> SbBool"""
    return _coin.SoFile_getSearchOK()

class SoFont(SoNode):
    r"""Proxy of C++ SoFont class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFont_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFont self) -> SoType"""
        return _coin.SoFont_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFont_initClass()

    def __init__(self):
        r"""__init__(SoFont self) -> SoFont"""
        _coin.SoFont_swiginit(self, _coin.new_SoFont())
    name = property(_coin.SoFont_name_get, _coin.SoFont_name_set, doc=r"""name : SoSFName""")
    size = property(_coin.SoFont_size_get, _coin.SoFont_size_set, doc=r"""size : SoSFFloat""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoFont self, SoAction action)"""
        return _coin.SoFont_doAction(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoFont self, SoGetBoundingBoxAction action)"""
        return _coin.SoFont_getBoundingBox(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoFont self, SoGLRenderAction action)"""
        return _coin.SoFont_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoFont self, SoCallbackAction action)"""
        return _coin.SoFont_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoFont self, SoPickAction action)"""
        return _coin.SoFont_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoFont self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFont_getPrimitiveCount(self, action)

# Register SoFont in _coin:
_coin.SoFont_swigregister(SoFont)

def SoFont_getClassTypeId() -> "SoType":
    r"""SoFont_getClassTypeId() -> SoType"""
    return _coin.SoFont_getClassTypeId()

def SoFont_initClass() -> "void":
    r"""SoFont_initClass()"""
    return _coin.SoFont_initClass()

class SoFontStyle(SoFont):
    r"""Proxy of C++ SoFontStyle class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFontStyle_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFontStyle self) -> SoType"""
        return _coin.SoFontStyle_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFontStyle_initClass()

    def __init__(self):
        r"""__init__(SoFontStyle self) -> SoFontStyle"""
        _coin.SoFontStyle_swiginit(self, _coin.new_SoFontStyle())
    SERIF = _coin.SoFontStyle_SERIF
    
    SANS = _coin.SoFontStyle_SANS
    
    TYPEWRITER = _coin.SoFontStyle_TYPEWRITER
    
    NONE = _coin.SoFontStyle_NONE
    
    BOLD = _coin.SoFontStyle_BOLD
    
    ITALIC = _coin.SoFontStyle_ITALIC
    
    family = property(_coin.SoFontStyle_family_get, _coin.SoFontStyle_family_set, doc=r"""family : SoSFEnum""")
    style = property(_coin.SoFontStyle_style_get, _coin.SoFontStyle_style_set, doc=r"""style : SoSFBitMask""")

    def getFontName(self) -> "SbString":
        r"""getFontName(SoFontStyle self) -> SbString"""
        return _coin.SoFontStyle_getFontName(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoFontStyle self, SoAction action)"""
        return _coin.SoFontStyle_doAction(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoFontStyle self, SoGetBoundingBoxAction action)"""
        return _coin.SoFontStyle_getBoundingBox(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoFontStyle self, SoGLRenderAction action)"""
        return _coin.SoFontStyle_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoFontStyle self, SoCallbackAction action)"""
        return _coin.SoFontStyle_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoFontStyle self, SoPickAction action)"""
        return _coin.SoFontStyle_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoFontStyle self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFontStyle_getPrimitiveCount(self, action)

# Register SoFontStyle in _coin:
_coin.SoFontStyle_swigregister(SoFontStyle)

def SoFontStyle_getClassTypeId() -> "SoType":
    r"""SoFontStyle_getClassTypeId() -> SoType"""
    return _coin.SoFontStyle_getClassTypeId()

def SoFontStyle_initClass() -> "void":
    r"""SoFontStyle_initClass()"""
    return _coin.SoFontStyle_initClass()

class SoGeoCoordinate(SoNode):
    r"""Proxy of C++ SoGeoCoordinate class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGeoCoordinate_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGeoCoordinate self) -> SoType"""
        return _coin.SoGeoCoordinate_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGeoCoordinate_initClass()

    def __init__(self):
        r"""__init__(SoGeoCoordinate self) -> SoGeoCoordinate"""
        _coin.SoGeoCoordinate_swiginit(self, _coin.new_SoGeoCoordinate())
    point = property(_coin.SoGeoCoordinate_point_get, _coin.SoGeoCoordinate_point_set, doc=r"""point : SoMFVec3d""")
    geoSystem = property(_coin.SoGeoCoordinate_geoSystem_get, _coin.SoGeoCoordinate_geoSystem_set, doc=r"""geoSystem : SoMFString""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoGeoCoordinate self, SoAction action)"""
        return _coin.SoGeoCoordinate_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoGeoCoordinate self, SoCallbackAction action)"""
        return _coin.SoGeoCoordinate_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoGeoCoordinate self, SoGLRenderAction action)"""
        return _coin.SoGeoCoordinate_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoGeoCoordinate self, SoGetBoundingBoxAction action)"""
        return _coin.SoGeoCoordinate_getBoundingBox(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoGeoCoordinate self, SoPickAction action)"""
        return _coin.SoGeoCoordinate_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoGeoCoordinate self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGeoCoordinate_getPrimitiveCount(self, action)

# Register SoGeoCoordinate in _coin:
_coin.SoGeoCoordinate_swigregister(SoGeoCoordinate)

def SoGeoCoordinate_getClassTypeId() -> "SoType":
    r"""SoGeoCoordinate_getClassTypeId() -> SoType"""
    return _coin.SoGeoCoordinate_getClassTypeId()

def SoGeoCoordinate_initClass() -> "void":
    r"""SoGeoCoordinate_initClass()"""
    return _coin.SoGeoCoordinate_initClass()

class SoGeoLocation(SoTransformation):
    r"""Proxy of C++ SoGeoLocation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGeoLocation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGeoLocation self) -> SoType"""
        return _coin.SoGeoLocation_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGeoLocation_initClass()

    def __init__(self):
        r"""__init__(SoGeoLocation self) -> SoGeoLocation"""
        _coin.SoGeoLocation_swiginit(self, _coin.new_SoGeoLocation())
    geoCoords = property(_coin.SoGeoLocation_geoCoords_get, _coin.SoGeoLocation_geoCoords_set, doc=r"""geoCoords : SoSFVec3d""")
    geoSystem = property(_coin.SoGeoLocation_geoSystem_get, _coin.SoGeoLocation_geoSystem_set, doc=r"""geoSystem : SoMFString""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoGeoLocation self, SoAction action)"""
        return _coin.SoGeoLocation_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoGeoLocation self, SoCallbackAction action)"""
        return _coin.SoGeoLocation_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoGeoLocation self, SoGLRenderAction action)"""
        return _coin.SoGeoLocation_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoGeoLocation self, SoGetBoundingBoxAction action)"""
        return _coin.SoGeoLocation_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoGeoLocation self, SoGetMatrixAction action)"""
        return _coin.SoGeoLocation_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoGeoLocation self, SoPickAction action)"""
        return _coin.SoGeoLocation_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoGeoLocation self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGeoLocation_getPrimitiveCount(self, action)

# Register SoGeoLocation in _coin:
_coin.SoGeoLocation_swigregister(SoGeoLocation)

def SoGeoLocation_getClassTypeId() -> "SoType":
    r"""SoGeoLocation_getClassTypeId() -> SoType"""
    return _coin.SoGeoLocation_getClassTypeId()

def SoGeoLocation_initClass() -> "void":
    r"""SoGeoLocation_initClass()"""
    return _coin.SoGeoLocation_initClass()

class SoGeoOrigin(SoNode):
    r"""Proxy of C++ SoGeoOrigin class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGeoOrigin_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGeoOrigin self) -> SoType"""
        return _coin.SoGeoOrigin_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGeoOrigin_initClass()

    def __init__(self):
        r"""__init__(SoGeoOrigin self) -> SoGeoOrigin"""
        _coin.SoGeoOrigin_swiginit(self, _coin.new_SoGeoOrigin())
    geoCoords = property(_coin.SoGeoOrigin_geoCoords_get, _coin.SoGeoOrigin_geoCoords_set, doc=r"""geoCoords : SoSFVec3d""")
    geoSystem = property(_coin.SoGeoOrigin_geoSystem_get, _coin.SoGeoOrigin_geoSystem_set, doc=r"""geoSystem : SoMFString""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoGeoOrigin self, SoAction action)"""
        return _coin.SoGeoOrigin_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoGeoOrigin self, SoCallbackAction action)"""
        return _coin.SoGeoOrigin_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoGeoOrigin self, SoGLRenderAction action)"""
        return _coin.SoGeoOrigin_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoGeoOrigin self, SoGetBoundingBoxAction action)"""
        return _coin.SoGeoOrigin_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoGeoOrigin self, SoGetMatrixAction action)"""
        return _coin.SoGeoOrigin_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoGeoOrigin self, SoPickAction action)"""
        return _coin.SoGeoOrigin_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoGeoOrigin self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGeoOrigin_getPrimitiveCount(self, action)

# Register SoGeoOrigin in _coin:
_coin.SoGeoOrigin_swigregister(SoGeoOrigin)

def SoGeoOrigin_getClassTypeId() -> "SoType":
    r"""SoGeoOrigin_getClassTypeId() -> SoType"""
    return _coin.SoGeoOrigin_getClassTypeId()

def SoGeoOrigin_initClass() -> "void":
    r"""SoGeoOrigin_initClass()"""
    return _coin.SoGeoOrigin_initClass()

class SoGeoSeparator(SoSeparator):
    r"""Proxy of C++ SoGeoSeparator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGeoSeparator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoGeoSeparator self) -> SoType"""
        return _coin.SoGeoSeparator_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoGeoSeparator_initClass()

    def __init__(self):
        r"""__init__(SoGeoSeparator self) -> SoGeoSeparator"""
        _coin.SoGeoSeparator_swiginit(self, _coin.new_SoGeoSeparator())
    geoCoords = property(_coin.SoGeoSeparator_geoCoords_get, _coin.SoGeoSeparator_geoCoords_set, doc=r"""geoCoords : SoSFVec3d""")
    geoSystem = property(_coin.SoGeoSeparator_geoSystem_get, _coin.SoGeoSeparator_geoSystem_set, doc=r"""geoSystem : SoMFString""")

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoGeoSeparator self, SoCallbackAction action)"""
        return _coin.SoGeoSeparator_callback(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoGeoSeparator self, SoGLRenderAction action)"""
        return _coin.SoGeoSeparator_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoGeoSeparator self, SoGLRenderAction action)"""
        return _coin.SoGeoSeparator_GLRenderInPath(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoGeoSeparator self, SoGetBoundingBoxAction action)"""
        return _coin.SoGeoSeparator_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoGeoSeparator self, SoGetMatrixAction action)"""
        return _coin.SoGeoSeparator_getMatrix(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoGeoSeparator self, SoRayPickAction action)"""
        return _coin.SoGeoSeparator_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoGeoSeparator self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGeoSeparator_getPrimitiveCount(self, action)

# Register SoGeoSeparator in _coin:
_coin.SoGeoSeparator_swigregister(SoGeoSeparator)

def SoGeoSeparator_getClassTypeId() -> "SoType":
    r"""SoGeoSeparator_getClassTypeId() -> SoType"""
    return _coin.SoGeoSeparator_getClassTypeId()

def SoGeoSeparator_initClass() -> "void":
    r"""SoGeoSeparator_initClass()"""
    return _coin.SoGeoSeparator_initClass()

class SoIndexedShape(SoVertexShape):
    r"""Proxy of C++ SoIndexedShape class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedShape_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedShape self) -> SoType"""
        return _coin.SoIndexedShape_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedShape_initClass()
    coordIndex = property(_coin.SoIndexedShape_coordIndex_get, _coin.SoIndexedShape_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    materialIndex = property(_coin.SoIndexedShape_materialIndex_get, _coin.SoIndexedShape_materialIndex_set, doc=r"""materialIndex : SoMFInt32""")
    normalIndex = property(_coin.SoIndexedShape_normalIndex_get, _coin.SoIndexedShape_normalIndex_set, doc=r"""normalIndex : SoMFInt32""")
    textureCoordIndex = property(_coin.SoIndexedShape_textureCoordIndex_get, _coin.SoIndexedShape_textureCoordIndex_set, doc=r"""textureCoordIndex : SoMFInt32""")

# Register SoIndexedShape in _coin:
_coin.SoIndexedShape_swigregister(SoIndexedShape)

def SoIndexedShape_getClassTypeId() -> "SoType":
    r"""SoIndexedShape_getClassTypeId() -> SoType"""
    return _coin.SoIndexedShape_getClassTypeId()

def SoIndexedShape_initClass() -> "void":
    r"""SoIndexedShape_initClass()"""
    return _coin.SoIndexedShape_initClass()

SO_END_FACE_INDEX = _coin.SO_END_FACE_INDEX

class SoIndexedFaceSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedFaceSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedFaceSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedFaceSet self) -> SoType"""
        return _coin.SoIndexedFaceSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedFaceSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedFaceSet self) -> SoIndexedFaceSet"""
        _coin.SoIndexedFaceSet_swiginit(self, _coin.new_SoIndexedFaceSet())

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoIndexedFaceSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedFaceSet_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoIndexedFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedFaceSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, *args) -> "SbBool":
        r"""
        generateDefaultNormals(SoIndexedFaceSet self, SoState state, SoNormalBundle bundle) -> SbBool
        generateDefaultNormals(SoIndexedFaceSet self, SoState state, SoNormalCache cache) -> SbBool
        """
        return _coin.SoIndexedFaceSet_generateDefaultNormals(self, *args)

# Register SoIndexedFaceSet in _coin:
_coin.SoIndexedFaceSet_swigregister(SoIndexedFaceSet)

def SoIndexedFaceSet_getClassTypeId() -> "SoType":
    r"""SoIndexedFaceSet_getClassTypeId() -> SoType"""
    return _coin.SoIndexedFaceSet_getClassTypeId()

def SoIndexedFaceSet_initClass() -> "void":
    r"""SoIndexedFaceSet_initClass()"""
    return _coin.SoIndexedFaceSet_initClass()

SO_END_LINE_INDEX = _coin.SO_END_LINE_INDEX

class SoIndexedLineSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedLineSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedLineSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedLineSet self) -> SoType"""
        return _coin.SoIndexedLineSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedLineSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedLineSet self) -> SoIndexedLineSet"""
        _coin.SoIndexedLineSet_swiginit(self, _coin.new_SoIndexedLineSet())

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoIndexedLineSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedLineSet_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoIndexedLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedLineSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoIndexedLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedLineSet_getPrimitiveCount(self, action)

# Register SoIndexedLineSet in _coin:
_coin.SoIndexedLineSet_swigregister(SoIndexedLineSet)

def SoIndexedLineSet_getClassTypeId() -> "SoType":
    r"""SoIndexedLineSet_getClassTypeId() -> SoType"""
    return _coin.SoIndexedLineSet_getClassTypeId()

def SoIndexedLineSet_initClass() -> "void":
    r"""SoIndexedLineSet_initClass()"""
    return _coin.SoIndexedLineSet_initClass()

class SoIndexedNurbsCurve(SoShape):
    r"""Proxy of C++ SoIndexedNurbsCurve class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedNurbsCurve_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedNurbsCurve self) -> SoType"""
        return _coin.SoIndexedNurbsCurve_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedNurbsCurve_initClass()

    def __init__(self):
        r"""__init__(SoIndexedNurbsCurve self) -> SoIndexedNurbsCurve"""
        _coin.SoIndexedNurbsCurve_swiginit(self, _coin.new_SoIndexedNurbsCurve())
    numControlPoints = property(_coin.SoIndexedNurbsCurve_numControlPoints_get, _coin.SoIndexedNurbsCurve_numControlPoints_set, doc=r"""numControlPoints : SoSFInt32""")
    coordIndex = property(_coin.SoIndexedNurbsCurve_coordIndex_get, _coin.SoIndexedNurbsCurve_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    knotVector = property(_coin.SoIndexedNurbsCurve_knotVector_get, _coin.SoIndexedNurbsCurve_knotVector_set, doc=r"""knotVector : SoMFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoIndexedNurbsCurve self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsCurve_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoIndexedNurbsCurve self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsCurve_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoIndexedNurbsCurve self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsCurve_getPrimitiveCount(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoIndexedNurbsCurve self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedNurbsCurve_getBoundingBox(self, action)

    def sendPrimitive(self, arg2: "SoAction", arg3: "SoPrimitiveVertex") -> "void":
        r"""sendPrimitive(SoIndexedNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoIndexedNurbsCurve_sendPrimitive(self, arg2, arg3)

# Register SoIndexedNurbsCurve in _coin:
_coin.SoIndexedNurbsCurve_swigregister(SoIndexedNurbsCurve)

def SoIndexedNurbsCurve_getClassTypeId() -> "SoType":
    r"""SoIndexedNurbsCurve_getClassTypeId() -> SoType"""
    return _coin.SoIndexedNurbsCurve_getClassTypeId()

def SoIndexedNurbsCurve_initClass() -> "void":
    r"""SoIndexedNurbsCurve_initClass()"""
    return _coin.SoIndexedNurbsCurve_initClass()

class SoIndexedNurbsSurface(SoShape):
    r"""Proxy of C++ SoIndexedNurbsSurface class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedNurbsSurface_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedNurbsSurface self) -> SoType"""
        return _coin.SoIndexedNurbsSurface_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedNurbsSurface_initClass()

    def __init__(self):
        r"""__init__(SoIndexedNurbsSurface self) -> SoIndexedNurbsSurface"""
        _coin.SoIndexedNurbsSurface_swiginit(self, _coin.new_SoIndexedNurbsSurface())
    numUControlPoints = property(_coin.SoIndexedNurbsSurface_numUControlPoints_get, _coin.SoIndexedNurbsSurface_numUControlPoints_set, doc=r"""numUControlPoints : SoSFInt32""")
    numVControlPoints = property(_coin.SoIndexedNurbsSurface_numVControlPoints_get, _coin.SoIndexedNurbsSurface_numVControlPoints_set, doc=r"""numVControlPoints : SoSFInt32""")
    coordIndex = property(_coin.SoIndexedNurbsSurface_coordIndex_get, _coin.SoIndexedNurbsSurface_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    uKnotVector = property(_coin.SoIndexedNurbsSurface_uKnotVector_get, _coin.SoIndexedNurbsSurface_uKnotVector_set, doc=r"""uKnotVector : SoMFFloat""")
    vKnotVector = property(_coin.SoIndexedNurbsSurface_vKnotVector_get, _coin.SoIndexedNurbsSurface_vKnotVector_set, doc=r"""vKnotVector : SoMFFloat""")
    numSControlPoints = property(_coin.SoIndexedNurbsSurface_numSControlPoints_get, _coin.SoIndexedNurbsSurface_numSControlPoints_set, doc=r"""numSControlPoints : SoSFInt32""")
    numTControlPoints = property(_coin.SoIndexedNurbsSurface_numTControlPoints_get, _coin.SoIndexedNurbsSurface_numTControlPoints_set, doc=r"""numTControlPoints : SoSFInt32""")
    textureCoordIndex = property(_coin.SoIndexedNurbsSurface_textureCoordIndex_get, _coin.SoIndexedNurbsSurface_textureCoordIndex_set, doc=r"""textureCoordIndex : SoMFInt32""")
    sKnotVector = property(_coin.SoIndexedNurbsSurface_sKnotVector_get, _coin.SoIndexedNurbsSurface_sKnotVector_set, doc=r"""sKnotVector : SoMFFloat""")
    tKnotVector = property(_coin.SoIndexedNurbsSurface_tKnotVector_get, _coin.SoIndexedNurbsSurface_tKnotVector_set, doc=r"""tKnotVector : SoMFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoIndexedNurbsSurface self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsSurface_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoIndexedNurbsSurface self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsSurface_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoIndexedNurbsSurface self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsSurface_getPrimitiveCount(self, action)

    def sendPrimitive(self, arg2: "SoAction", arg3: "SoPrimitiveVertex") -> "void":
        r"""sendPrimitive(SoIndexedNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoIndexedNurbsSurface_sendPrimitive(self, arg2, arg3)

# Register SoIndexedNurbsSurface in _coin:
_coin.SoIndexedNurbsSurface_swigregister(SoIndexedNurbsSurface)

def SoIndexedNurbsSurface_getClassTypeId() -> "SoType":
    r"""SoIndexedNurbsSurface_getClassTypeId() -> SoType"""
    return _coin.SoIndexedNurbsSurface_getClassTypeId()

def SoIndexedNurbsSurface_initClass() -> "void":
    r"""SoIndexedNurbsSurface_initClass()"""
    return _coin.SoIndexedNurbsSurface_initClass()

SO_END_STRIP_INDEX = _coin.SO_END_STRIP_INDEX

class SoIndexedTriangleStripSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedTriangleStripSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedTriangleStripSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedTriangleStripSet self) -> SoType"""
        return _coin.SoIndexedTriangleStripSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedTriangleStripSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedTriangleStripSet self) -> SoIndexedTriangleStripSet"""
        _coin.SoIndexedTriangleStripSet_swiginit(self, _coin.new_SoIndexedTriangleStripSet())

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoIndexedTriangleStripSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedTriangleStripSet_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoIndexedTriangleStripSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedTriangleStripSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, state: "SoState", nb: "SoNormalBundle") -> "SbBool":
        r"""generateDefaultNormals(SoIndexedTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoIndexedTriangleStripSet_generateDefaultNormals(self, state, nb)

# Register SoIndexedTriangleStripSet in _coin:
_coin.SoIndexedTriangleStripSet_swigregister(SoIndexedTriangleStripSet)

def SoIndexedTriangleStripSet_getClassTypeId() -> "SoType":
    r"""SoIndexedTriangleStripSet_getClassTypeId() -> SoType"""
    return _coin.SoIndexedTriangleStripSet_getClassTypeId()

def SoIndexedTriangleStripSet_initClass() -> "void":
    r"""SoIndexedTriangleStripSet_initClass()"""
    return _coin.SoIndexedTriangleStripSet_initClass()

class SoInfo(SoNode):
    r"""Proxy of C++ SoInfo class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInfo_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoInfo self) -> SoType"""
        return _coin.SoInfo_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoInfo_initClass()

    def __init__(self):
        r"""__init__(SoInfo self) -> SoInfo"""
        _coin.SoInfo_swiginit(self, _coin.new_SoInfo())
    string = property(_coin.SoInfo_string_get, _coin.SoInfo_string_set, doc=r"""string : SoSFString""")

# Register SoInfo in _coin:
_coin.SoInfo_swigregister(SoInfo)

def SoInfo_getClassTypeId() -> "SoType":
    r"""SoInfo_getClassTypeId() -> SoType"""
    return _coin.SoInfo_getClassTypeId()

def SoInfo_initClass() -> "void":
    r"""SoInfo_initClass()"""
    return _coin.SoInfo_initClass()

class SoLabel(SoNode):
    r"""Proxy of C++ SoLabel class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLabel_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLabel self) -> SoType"""
        return _coin.SoLabel_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLabel_initClass()

    def __init__(self):
        r"""__init__(SoLabel self) -> SoLabel"""
        _coin.SoLabel_swiginit(self, _coin.new_SoLabel())
    label = property(_coin.SoLabel_label_get, _coin.SoLabel_label_set, doc=r"""label : SoSFName""")

# Register SoLabel in _coin:
_coin.SoLabel_swigregister(SoLabel)

def SoLabel_getClassTypeId() -> "SoType":
    r"""SoLabel_getClassTypeId() -> SoType"""
    return _coin.SoLabel_getClassTypeId()

def SoLabel_initClass() -> "void":
    r"""SoLabel_initClass()"""
    return _coin.SoLabel_initClass()

class SoLevelOfDetail(SoGroup):
    r"""Proxy of C++ SoLevelOfDetail class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLevelOfDetail_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLevelOfDetail self) -> SoType"""
        return _coin.SoLevelOfDetail_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLevelOfDetail_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoLevelOfDetail self) -> SoLevelOfDetail
        __init__(SoLevelOfDetail self, int numchildren) -> SoLevelOfDetail
        """
        _coin.SoLevelOfDetail_swiginit(self, _coin.new_SoLevelOfDetail(*args))
    screenArea = property(_coin.SoLevelOfDetail_screenArea_get, _coin.SoLevelOfDetail_screenArea_set, doc=r"""screenArea : SoMFFloat""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoLevelOfDetail self, SoAction action)"""
        return _coin.SoLevelOfDetail_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoLevelOfDetail self, SoCallbackAction action)"""
        return _coin.SoLevelOfDetail_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoLevelOfDetail self, SoGLRenderAction action)"""
        return _coin.SoLevelOfDetail_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoLevelOfDetail self, SoRayPickAction action)"""
        return _coin.SoLevelOfDetail_rayPick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoLevelOfDetail self, SoGetBoundingBoxAction action)"""
        return _coin.SoLevelOfDetail_getBoundingBox(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoLevelOfDetail self, SoAudioRenderAction action)"""
        return _coin.SoLevelOfDetail_audioRender(self, action)

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoLevelOfDetail self, SoNotList nl)"""
        return _coin.SoLevelOfDetail_notify(self, nl)

# Register SoLevelOfDetail in _coin:
_coin.SoLevelOfDetail_swigregister(SoLevelOfDetail)

def SoLevelOfDetail_getClassTypeId() -> "SoType":
    r"""SoLevelOfDetail_getClassTypeId() -> SoType"""
    return _coin.SoLevelOfDetail_getClassTypeId()

def SoLevelOfDetail_initClass() -> "void":
    r"""SoLevelOfDetail_initClass()"""
    return _coin.SoLevelOfDetail_initClass()

class SoProfile(SoNode):
    r"""Proxy of C++ SoProfile class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfile_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoProfile self) -> SoType"""
        return _coin.SoProfile_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProfile_initClass()
    START_FIRST = _coin.SoProfile_START_FIRST
    
    START_NEW = _coin.SoProfile_START_NEW
    
    ADD_TO_CURRENT = _coin.SoProfile_ADD_TO_CURRENT
    
    index = property(_coin.SoProfile_index_get, _coin.SoProfile_index_set, doc=r"""index : SoMFInt32""")
    linkage = property(_coin.SoProfile_linkage_get, _coin.SoProfile_linkage_set, doc=r"""linkage : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoProfile self, SoAction action)"""
        return _coin.SoProfile_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoProfile self, SoCallbackAction action)"""
        return _coin.SoProfile_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoProfile self, SoGLRenderAction action)"""
        return _coin.SoProfile_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoProfile self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfile_getBoundingBox(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoProfile self, SoPickAction action)"""
        return _coin.SoProfile_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoProfile self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfile_getPrimitiveCount(self, action)

    def getTrimCurve(self, state: "SoState", numpoints: "int32_t &", points: "float *&", floatspervec: "int &", numknots: "int32_t &", knotvector: "float *&") -> "void":
        r"""getTrimCurve(SoProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"""
        return _coin.SoProfile_getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector)

    def getVertices(self, state: "SoState", numvertices: "int32_t &", vertices: "SbVec2f *&") -> "void":
        r"""getVertices(SoProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoProfile_getVertices(self, state, numvertices, vertices)

# Register SoProfile in _coin:
_coin.SoProfile_swigregister(SoProfile)

def SoProfile_getClassTypeId() -> "SoType":
    r"""SoProfile_getClassTypeId() -> SoType"""
    return _coin.SoProfile_getClassTypeId()

def SoProfile_initClass() -> "void":
    r"""SoProfile_initClass()"""
    return _coin.SoProfile_initClass()

class SoLinearProfile(SoProfile):
    r"""Proxy of C++ SoLinearProfile class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLinearProfile_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLinearProfile self) -> SoType"""
        return _coin.SoLinearProfile_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLinearProfile_initClass()

    def __init__(self):
        r"""__init__(SoLinearProfile self) -> SoLinearProfile"""
        _coin.SoLinearProfile_swiginit(self, _coin.new_SoLinearProfile())

    def getTrimCurve(self, state: "SoState", numpoints: "int32_t &", points: "float *&", floatspervec: "int &", numknots: "int32_t &", knotvector: "float *&") -> "void":
        r"""getTrimCurve(SoLinearProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"""
        return _coin.SoLinearProfile_getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector)

    def getVertices(self, state: "SoState", numvertices: "int32_t &", vertices: "SbVec2f *&") -> "void":
        r"""getVertices(SoLinearProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoLinearProfile_getVertices(self, state, numvertices, vertices)

# Register SoLinearProfile in _coin:
_coin.SoLinearProfile_swigregister(SoLinearProfile)

def SoLinearProfile_getClassTypeId() -> "SoType":
    r"""SoLinearProfile_getClassTypeId() -> SoType"""
    return _coin.SoLinearProfile_getClassTypeId()

def SoLinearProfile_initClass() -> "void":
    r"""SoLinearProfile_initClass()"""
    return _coin.SoLinearProfile_initClass()

class SoLineSet(SoNonIndexedShape):
    r"""Proxy of C++ SoLineSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLineSet self) -> SoType"""
        return _coin.SoLineSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLineSet_initClass()

    def __init__(self):
        r"""__init__(SoLineSet self) -> SoLineSet"""
        _coin.SoLineSet_swiginit(self, _coin.new_SoLineSet())
    numVertices = property(_coin.SoLineSet_numVertices_get, _coin.SoLineSet_numVertices_set, doc=r"""numVertices : SoMFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoLineSet self, SoGLRenderAction action)"""
        return _coin.SoLineSet_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoLineSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLineSet_getPrimitiveCount(self, action)

# Register SoLineSet in _coin:
_coin.SoLineSet_swigregister(SoLineSet)

def SoLineSet_getClassTypeId() -> "SoType":
    r"""SoLineSet_getClassTypeId() -> SoType"""
    return _coin.SoLineSet_getClassTypeId()

def SoLineSet_initClass() -> "void":
    r"""SoLineSet_initClass()"""
    return _coin.SoLineSet_initClass()

class SoListener(SoNode):
    r"""Proxy of C++ SoListener class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListener_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoListener self) -> SoType"""
        return _coin.SoListener_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoListener_initClass()

    def __init__(self):
        r"""__init__(SoListener self) -> SoListener"""
        _coin.SoListener_swiginit(self, _coin.new_SoListener())
    position = property(_coin.SoListener_position_get, _coin.SoListener_position_set, doc=r"""position : SoSFVec3f""")
    orientation = property(_coin.SoListener_orientation_get, _coin.SoListener_orientation_set, doc=r"""orientation : SoSFRotation""")
    gain = property(_coin.SoListener_gain_get, _coin.SoListener_gain_set, doc=r"""gain : SoSFFloat""")
    dopplerVelocity = property(_coin.SoListener_dopplerVelocity_get, _coin.SoListener_dopplerVelocity_set, doc=r"""dopplerVelocity : SoSFVec3f""")
    dopplerFactor = property(_coin.SoListener_dopplerFactor_get, _coin.SoListener_dopplerFactor_set, doc=r"""dopplerFactor : SoSFFloat""")

# Register SoListener in _coin:
_coin.SoListener_swigregister(SoListener)

def SoListener_getClassTypeId() -> "SoType":
    r"""SoListener_getClassTypeId() -> SoType"""
    return _coin.SoListener_getClassTypeId()

def SoListener_initClass() -> "void":
    r"""SoListener_initClass()"""
    return _coin.SoListener_initClass()

class SoLocateHighlight(SoSeparator):
    r"""Proxy of C++ SoLocateHighlight class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLocateHighlight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLocateHighlight self) -> SoType"""
        return _coin.SoLocateHighlight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLocateHighlight_initClass()

    def __init__(self):
        r"""__init__(SoLocateHighlight self) -> SoLocateHighlight"""
        _coin.SoLocateHighlight_swiginit(self, _coin.new_SoLocateHighlight())
    AUTO = _coin.SoLocateHighlight_AUTO
    
    ON = _coin.SoLocateHighlight_ON
    
    OFF = _coin.SoLocateHighlight_OFF
    
    EMISSIVE = _coin.SoLocateHighlight_EMISSIVE
    
    EMISSIVE_DIFFUSE = _coin.SoLocateHighlight_EMISSIVE_DIFFUSE
    
    color = property(_coin.SoLocateHighlight_color_get, _coin.SoLocateHighlight_color_set, doc=r"""color : SoSFColor""")
    style = property(_coin.SoLocateHighlight_style_get, _coin.SoLocateHighlight_style_set, doc=r"""style : SoSFEnum""")
    mode = property(_coin.SoLocateHighlight_mode_get, _coin.SoLocateHighlight_mode_set, doc=r"""mode : SoSFEnum""")

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoLocateHighlight self, SoHandleEventAction action)"""
        return _coin.SoLocateHighlight_handleEvent(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoLocateHighlight self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoLocateHighlight self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderInPath(self, action)

    @staticmethod
    def turnOffCurrentHighlight(action: "SoGLRenderAction") -> "void":
        r"""turnOffCurrentHighlight(SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_turnOffCurrentHighlight(action)

# Register SoLocateHighlight in _coin:
_coin.SoLocateHighlight_swigregister(SoLocateHighlight)

def SoLocateHighlight_getClassTypeId() -> "SoType":
    r"""SoLocateHighlight_getClassTypeId() -> SoType"""
    return _coin.SoLocateHighlight_getClassTypeId()

def SoLocateHighlight_initClass() -> "void":
    r"""SoLocateHighlight_initClass()"""
    return _coin.SoLocateHighlight_initClass()

def SoLocateHighlight_turnOffCurrentHighlight(action: "SoGLRenderAction") -> "void":
    r"""SoLocateHighlight_turnOffCurrentHighlight(SoGLRenderAction action)"""
    return _coin.SoLocateHighlight_turnOffCurrentHighlight(action)

class SoLOD(SoGroup):
    r"""Proxy of C++ SoLOD class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLOD_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoLOD self) -> SoType"""
        return _coin.SoLOD_getTypeId(self)

    def __init__(self, *args):
        r"""
        __init__(SoLOD self) -> SoLOD
        __init__(SoLOD self, int numchildren) -> SoLOD
        """
        _coin.SoLOD_swiginit(self, _coin.new_SoLOD(*args))

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoLOD_initClass()
    range = property(_coin.SoLOD_range_get, _coin.SoLOD_range_set, doc=r"""range : SoMFFloat""")
    center = property(_coin.SoLOD_center_get, _coin.SoLOD_center_set, doc=r"""center : SoSFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoLOD self, SoAction action)"""
        return _coin.SoLOD_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoLOD self, SoCallbackAction action)"""
        return _coin.SoLOD_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRender(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderOffPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderOffPath(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoLOD self, SoRayPickAction action)"""
        return _coin.SoLOD_rayPick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoLOD self, SoGetBoundingBoxAction action)"""
        return _coin.SoLOD_getBoundingBox(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoLOD self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLOD_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoLOD self, SoAudioRenderAction action)"""
        return _coin.SoLOD_audioRender(self, action)

    def notify(self, nl: "SoNotList") -> "void":
        r"""notify(SoLOD self, SoNotList nl)"""
        return _coin.SoLOD_notify(self, nl)

# Register SoLOD in _coin:
_coin.SoLOD_swigregister(SoLOD)

def SoLOD_getClassTypeId() -> "SoType":
    r"""SoLOD_getClassTypeId() -> SoType"""
    return _coin.SoLOD_getClassTypeId()

def SoLOD_initClass() -> "void":
    r"""SoLOD_initClass()"""
    return _coin.SoLOD_initClass()

class SoPointSet(SoNonIndexedShape):
    r"""Proxy of C++ SoPointSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPointSet self) -> SoType"""
        return _coin.SoPointSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPointSet_initClass()

    def __init__(self):
        r"""__init__(SoPointSet self) -> SoPointSet"""
        _coin.SoPointSet_swiginit(self, _coin.new_SoPointSet())
    numPoints = property(_coin.SoPointSet_numPoints_get, _coin.SoPointSet_numPoints_set, doc=r"""numPoints : SoSFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoPointSet self, SoGLRenderAction action)"""
        return _coin.SoPointSet_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoPointSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPointSet_getPrimitiveCount(self, action)

# Register SoPointSet in _coin:
_coin.SoPointSet_swigregister(SoPointSet)

def SoPointSet_getClassTypeId() -> "SoType":
    r"""SoPointSet_getClassTypeId() -> SoType"""
    return _coin.SoPointSet_getClassTypeId()

def SoPointSet_initClass() -> "void":
    r"""SoPointSet_initClass()"""
    return _coin.SoPointSet_initClass()

class SoMarkerSet(SoPointSet):
    r"""Proxy of C++ SoMarkerSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMarkerSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMarkerSet self) -> SoType"""
        return _coin.SoMarkerSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMarkerSet_initClass()

    def __init__(self):
        r"""__init__(SoMarkerSet self) -> SoMarkerSet"""
        _coin.SoMarkerSet_swiginit(self, _coin.new_SoMarkerSet())
    NONE = _coin.SoMarkerSet_NONE
    
    CROSS_5_5 = _coin.SoMarkerSet_CROSS_5_5
    
    PLUS_5_5 = _coin.SoMarkerSet_PLUS_5_5
    
    MINUS_5_5 = _coin.SoMarkerSet_MINUS_5_5
    
    SLASH_5_5 = _coin.SoMarkerSet_SLASH_5_5
    
    BACKSLASH_5_5 = _coin.SoMarkerSet_BACKSLASH_5_5
    
    BAR_5_5 = _coin.SoMarkerSet_BAR_5_5
    
    STAR_5_5 = _coin.SoMarkerSet_STAR_5_5
    
    Y_5_5 = _coin.SoMarkerSet_Y_5_5
    
    LIGHTNING_5_5 = _coin.SoMarkerSet_LIGHTNING_5_5
    
    WELL_5_5 = _coin.SoMarkerSet_WELL_5_5
    
    CIRCLE_LINE_5_5 = _coin.SoMarkerSet_CIRCLE_LINE_5_5
    
    SQUARE_LINE_5_5 = _coin.SoMarkerSet_SQUARE_LINE_5_5
    
    DIAMOND_LINE_5_5 = _coin.SoMarkerSet_DIAMOND_LINE_5_5
    
    TRIANGLE_LINE_5_5 = _coin.SoMarkerSet_TRIANGLE_LINE_5_5
    
    RHOMBUS_LINE_5_5 = _coin.SoMarkerSet_RHOMBUS_LINE_5_5
    
    HOURGLASS_LINE_5_5 = _coin.SoMarkerSet_HOURGLASS_LINE_5_5
    
    SATELLITE_LINE_5_5 = _coin.SoMarkerSet_SATELLITE_LINE_5_5
    
    PINE_TREE_LINE_5_5 = _coin.SoMarkerSet_PINE_TREE_LINE_5_5
    
    CAUTION_LINE_5_5 = _coin.SoMarkerSet_CAUTION_LINE_5_5
    
    SHIP_LINE_5_5 = _coin.SoMarkerSet_SHIP_LINE_5_5
    
    CIRCLE_FILLED_5_5 = _coin.SoMarkerSet_CIRCLE_FILLED_5_5
    
    SQUARE_FILLED_5_5 = _coin.SoMarkerSet_SQUARE_FILLED_5_5
    
    DIAMOND_FILLED_5_5 = _coin.SoMarkerSet_DIAMOND_FILLED_5_5
    
    TRIANGLE_FILLED_5_5 = _coin.SoMarkerSet_TRIANGLE_FILLED_5_5
    
    RHOMBUS_FILLED_5_5 = _coin.SoMarkerSet_RHOMBUS_FILLED_5_5
    
    HOURGLASS_FILLED_5_5 = _coin.SoMarkerSet_HOURGLASS_FILLED_5_5
    
    SATELLITE_FILLED_5_5 = _coin.SoMarkerSet_SATELLITE_FILLED_5_5
    
    PINE_TREE_FILLED_5_5 = _coin.SoMarkerSet_PINE_TREE_FILLED_5_5
    
    CAUTION_FILLED_5_5 = _coin.SoMarkerSet_CAUTION_FILLED_5_5
    
    SHIP_FILLED_5_5 = _coin.SoMarkerSet_SHIP_FILLED_5_5
    
    CROSS_7_7 = _coin.SoMarkerSet_CROSS_7_7
    
    PLUS_7_7 = _coin.SoMarkerSet_PLUS_7_7
    
    MINUS_7_7 = _coin.SoMarkerSet_MINUS_7_7
    
    SLASH_7_7 = _coin.SoMarkerSet_SLASH_7_7
    
    BACKSLASH_7_7 = _coin.SoMarkerSet_BACKSLASH_7_7
    
    BAR_7_7 = _coin.SoMarkerSet_BAR_7_7
    
    STAR_7_7 = _coin.SoMarkerSet_STAR_7_7
    
    Y_7_7 = _coin.SoMarkerSet_Y_7_7
    
    LIGHTNING_7_7 = _coin.SoMarkerSet_LIGHTNING_7_7
    
    WELL_7_7 = _coin.SoMarkerSet_WELL_7_7
    
    CIRCLE_LINE_7_7 = _coin.SoMarkerSet_CIRCLE_LINE_7_7
    
    SQUARE_LINE_7_7 = _coin.SoMarkerSet_SQUARE_LINE_7_7
    
    DIAMOND_LINE_7_7 = _coin.SoMarkerSet_DIAMOND_LINE_7_7
    
    TRIANGLE_LINE_7_7 = _coin.SoMarkerSet_TRIANGLE_LINE_7_7
    
    RHOMBUS_LINE_7_7 = _coin.SoMarkerSet_RHOMBUS_LINE_7_7
    
    HOURGLASS_LINE_7_7 = _coin.SoMarkerSet_HOURGLASS_LINE_7_7
    
    SATELLITE_LINE_7_7 = _coin.SoMarkerSet_SATELLITE_LINE_7_7
    
    PINE_TREE_LINE_7_7 = _coin.SoMarkerSet_PINE_TREE_LINE_7_7
    
    CAUTION_LINE_7_7 = _coin.SoMarkerSet_CAUTION_LINE_7_7
    
    SHIP_LINE_7_7 = _coin.SoMarkerSet_SHIP_LINE_7_7
    
    CIRCLE_FILLED_7_7 = _coin.SoMarkerSet_CIRCLE_FILLED_7_7
    
    SQUARE_FILLED_7_7 = _coin.SoMarkerSet_SQUARE_FILLED_7_7
    
    DIAMOND_FILLED_7_7 = _coin.SoMarkerSet_DIAMOND_FILLED_7_7
    
    TRIANGLE_FILLED_7_7 = _coin.SoMarkerSet_TRIANGLE_FILLED_7_7
    
    RHOMBUS_FILLED_7_7 = _coin.SoMarkerSet_RHOMBUS_FILLED_7_7
    
    HOURGLASS_FILLED_7_7 = _coin.SoMarkerSet_HOURGLASS_FILLED_7_7
    
    SATELLITE_FILLED_7_7 = _coin.SoMarkerSet_SATELLITE_FILLED_7_7
    
    PINE_TREE_FILLED_7_7 = _coin.SoMarkerSet_PINE_TREE_FILLED_7_7
    
    CAUTION_FILLED_7_7 = _coin.SoMarkerSet_CAUTION_FILLED_7_7
    
    SHIP_FILLED_7_7 = _coin.SoMarkerSet_SHIP_FILLED_7_7
    
    CROSS_9_9 = _coin.SoMarkerSet_CROSS_9_9
    
    PLUS_9_9 = _coin.SoMarkerSet_PLUS_9_9
    
    MINUS_9_9 = _coin.SoMarkerSet_MINUS_9_9
    
    SLASH_9_9 = _coin.SoMarkerSet_SLASH_9_9
    
    BACKSLASH_9_9 = _coin.SoMarkerSet_BACKSLASH_9_9
    
    BAR_9_9 = _coin.SoMarkerSet_BAR_9_9
    
    STAR_9_9 = _coin.SoMarkerSet_STAR_9_9
    
    Y_9_9 = _coin.SoMarkerSet_Y_9_9
    
    LIGHTNING_9_9 = _coin.SoMarkerSet_LIGHTNING_9_9
    
    WELL_9_9 = _coin.SoMarkerSet_WELL_9_9
    
    CIRCLE_LINE_9_9 = _coin.SoMarkerSet_CIRCLE_LINE_9_9
    
    SQUARE_LINE_9_9 = _coin.SoMarkerSet_SQUARE_LINE_9_9
    
    DIAMOND_LINE_9_9 = _coin.SoMarkerSet_DIAMOND_LINE_9_9
    
    TRIANGLE_LINE_9_9 = _coin.SoMarkerSet_TRIANGLE_LINE_9_9
    
    RHOMBUS_LINE_9_9 = _coin.SoMarkerSet_RHOMBUS_LINE_9_9
    
    HOURGLASS_LINE_9_9 = _coin.SoMarkerSet_HOURGLASS_LINE_9_9
    
    SATELLITE_LINE_9_9 = _coin.SoMarkerSet_SATELLITE_LINE_9_9
    
    PINE_TREE_LINE_9_9 = _coin.SoMarkerSet_PINE_TREE_LINE_9_9
    
    CAUTION_LINE_9_9 = _coin.SoMarkerSet_CAUTION_LINE_9_9
    
    SHIP_LINE_9_9 = _coin.SoMarkerSet_SHIP_LINE_9_9
    
    CIRCLE_FILLED_9_9 = _coin.SoMarkerSet_CIRCLE_FILLED_9_9
    
    SQUARE_FILLED_9_9 = _coin.SoMarkerSet_SQUARE_FILLED_9_9
    
    DIAMOND_FILLED_9_9 = _coin.SoMarkerSet_DIAMOND_FILLED_9_9
    
    TRIANGLE_FILLED_9_9 = _coin.SoMarkerSet_TRIANGLE_FILLED_9_9
    
    RHOMBUS_FILLED_9_9 = _coin.SoMarkerSet_RHOMBUS_FILLED_9_9
    
    HOURGLASS_FILLED_9_9 = _coin.SoMarkerSet_HOURGLASS_FILLED_9_9
    
    SATELLITE_FILLED_9_9 = _coin.SoMarkerSet_SATELLITE_FILLED_9_9
    
    PINE_TREE_FILLED_9_9 = _coin.SoMarkerSet_PINE_TREE_FILLED_9_9
    
    CAUTION_FILLED_9_9 = _coin.SoMarkerSet_CAUTION_FILLED_9_9
    
    SHIP_FILLED_9_9 = _coin.SoMarkerSet_SHIP_FILLED_9_9
    
    NUM_MARKERS = _coin.SoMarkerSet_NUM_MARKERS
    
    markerIndex = property(_coin.SoMarkerSet_markerIndex_get, _coin.SoMarkerSet_markerIndex_set, doc=r"""markerIndex : SoMFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoMarkerSet self, SoGLRenderAction action)"""
        return _coin.SoMarkerSet_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoMarkerSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMarkerSet_getPrimitiveCount(self, action)

    @staticmethod
    def getNumDefinedMarkers() -> "int":
        r"""getNumDefinedMarkers() -> int"""
        return _coin.SoMarkerSet_getNumDefinedMarkers()

    @staticmethod
    def getMarker(idx: "int", size: "SbVec2s", bytes: "unsigned char const *&", isLSBFirst: "SbBool &") -> "SbBool":
        r"""getMarker(int idx, SbVec2s size, unsigned char const *& bytes, SbBool & isLSBFirst) -> SbBool"""
        return _coin.SoMarkerSet_getMarker(idx, size, bytes, isLSBFirst)

    @staticmethod
    def removeMarker(idx: "int") -> "SbBool":
        r"""removeMarker(int idx) -> SbBool"""
        return _coin.SoMarkerSet_removeMarker(idx)

    @staticmethod
    def isMarkerBitSet(idx: "int", bitNumber: "int") -> "SbBool":
        r"""isMarkerBitSet(int idx, int bitNumber) -> SbBool"""
        return _coin.SoMarkerSet_isMarkerBitSet(idx, bitNumber)

    @staticmethod
    def addMarker(*args) -> "void":
        r"""
        addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1, SbBool isUpToDown=1)
        addMarker(int idx, SbVec2s size, PyObject * string, SbBool isLSBFirst=1, SbBool isUpToDown=1)
        """
        return _coin.SoMarkerSet_addMarker(*args)

# Register SoMarkerSet in _coin:
_coin.SoMarkerSet_swigregister(SoMarkerSet)

def SoMarkerSet_getClassTypeId() -> "SoType":
    r"""SoMarkerSet_getClassTypeId() -> SoType"""
    return _coin.SoMarkerSet_getClassTypeId()

def SoMarkerSet_initClass() -> "void":
    r"""SoMarkerSet_initClass()"""
    return _coin.SoMarkerSet_initClass()

def SoMarkerSet_getNumDefinedMarkers() -> "int":
    r"""SoMarkerSet_getNumDefinedMarkers() -> int"""
    return _coin.SoMarkerSet_getNumDefinedMarkers()

def SoMarkerSet_getMarker(idx: "int", size: "SbVec2s", bytes: "unsigned char const *&", isLSBFirst: "SbBool &") -> "SbBool":
    r"""SoMarkerSet_getMarker(int idx, SbVec2s size, unsigned char const *& bytes, SbBool & isLSBFirst) -> SbBool"""
    return _coin.SoMarkerSet_getMarker(idx, size, bytes, isLSBFirst)

def SoMarkerSet_removeMarker(idx: "int") -> "SbBool":
    r"""SoMarkerSet_removeMarker(int idx) -> SbBool"""
    return _coin.SoMarkerSet_removeMarker(idx)

def SoMarkerSet_isMarkerBitSet(idx: "int", bitNumber: "int") -> "SbBool":
    r"""SoMarkerSet_isMarkerBitSet(int idx, int bitNumber) -> SbBool"""
    return _coin.SoMarkerSet_isMarkerBitSet(idx, bitNumber)

def SoMarkerSet_addMarker(*args) -> "void":
    r"""
    SoMarkerSet_addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1, SbBool isUpToDown=1)
    SoMarkerSet_addMarker(int idx, SbVec2s size, PyObject * string, SbBool isLSBFirst=1, SbBool isUpToDown=1)
    """
    return _coin.SoMarkerSet_addMarker(*args)

class SoMaterial(SoNode):
    r"""Proxy of C++ SoMaterial class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMaterial_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMaterial self) -> SoType"""
        return _coin.SoMaterial_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMaterial_initClass()

    def __init__(self):
        r"""__init__(SoMaterial self) -> SoMaterial"""
        _coin.SoMaterial_swiginit(self, _coin.new_SoMaterial())
    ambientColor = property(_coin.SoMaterial_ambientColor_get, _coin.SoMaterial_ambientColor_set, doc=r"""ambientColor : SoMFColor""")
    diffuseColor = property(_coin.SoMaterial_diffuseColor_get, _coin.SoMaterial_diffuseColor_set, doc=r"""diffuseColor : SoMFColor""")
    specularColor = property(_coin.SoMaterial_specularColor_get, _coin.SoMaterial_specularColor_set, doc=r"""specularColor : SoMFColor""")
    emissiveColor = property(_coin.SoMaterial_emissiveColor_get, _coin.SoMaterial_emissiveColor_set, doc=r"""emissiveColor : SoMFColor""")
    shininess = property(_coin.SoMaterial_shininess_get, _coin.SoMaterial_shininess_set, doc=r"""shininess : SoMFFloat""")
    transparency = property(_coin.SoMaterial_transparency_get, _coin.SoMaterial_transparency_set, doc=r"""transparency : SoMFFloat""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoMaterial self, SoAction action)"""
        return _coin.SoMaterial_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoMaterial self, SoGLRenderAction action)"""
        return _coin.SoMaterial_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoMaterial self, SoCallbackAction action)"""
        return _coin.SoMaterial_callback(self, action)

# Register SoMaterial in _coin:
_coin.SoMaterial_swigregister(SoMaterial)

def SoMaterial_getClassTypeId() -> "SoType":
    r"""SoMaterial_getClassTypeId() -> SoType"""
    return _coin.SoMaterial_getClassTypeId()

def SoMaterial_initClass() -> "void":
    r"""SoMaterial_initClass()"""
    return _coin.SoMaterial_initClass()

class SoMatrixTransform(SoTransformation):
    r"""Proxy of C++ SoMatrixTransform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMatrixTransform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMatrixTransform self) -> SoType"""
        return _coin.SoMatrixTransform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMatrixTransform_initClass()

    def __init__(self):
        r"""__init__(SoMatrixTransform self) -> SoMatrixTransform"""
        _coin.SoMatrixTransform_swiginit(self, _coin.new_SoMatrixTransform())
    matrix = property(_coin.SoMatrixTransform_matrix_get, _coin.SoMatrixTransform_matrix_set, doc=r"""matrix : SoSFMatrix""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoMatrixTransform self, SoAction action)"""
        return _coin.SoMatrixTransform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoMatrixTransform self, SoCallbackAction action)"""
        return _coin.SoMatrixTransform_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoMatrixTransform self, SoGLRenderAction action)"""
        return _coin.SoMatrixTransform_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoMatrixTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoMatrixTransform_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoMatrixTransform self, SoGetMatrixAction action)"""
        return _coin.SoMatrixTransform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoMatrixTransform self, SoPickAction action)"""
        return _coin.SoMatrixTransform_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoMatrixTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMatrixTransform_getPrimitiveCount(self, action)

# Register SoMatrixTransform in _coin:
_coin.SoMatrixTransform_swigregister(SoMatrixTransform)

def SoMatrixTransform_getClassTypeId() -> "SoType":
    r"""SoMatrixTransform_getClassTypeId() -> SoType"""
    return _coin.SoMatrixTransform_getClassTypeId()

def SoMatrixTransform_initClass() -> "void":
    r"""SoMatrixTransform_initClass()"""
    return _coin.SoMatrixTransform_initClass()

class SoMultipleCopy(SoGroup):
    r"""Proxy of C++ SoMultipleCopy class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultipleCopy_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoMultipleCopy self) -> SoType"""
        return _coin.SoMultipleCopy_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoMultipleCopy_initClass()

    def __init__(self):
        r"""__init__(SoMultipleCopy self) -> SoMultipleCopy"""
        _coin.SoMultipleCopy_swiginit(self, _coin.new_SoMultipleCopy())
    matrix = property(_coin.SoMultipleCopy_matrix_get, _coin.SoMultipleCopy_matrix_set, doc=r"""matrix : SoMFMatrix""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoMultipleCopy self) -> SbBool"""
        return _coin.SoMultipleCopy_affectsState(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoMultipleCopy self, SoAction action)"""
        return _coin.SoMultipleCopy_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoMultipleCopy self, SoCallbackAction action)"""
        return _coin.SoMultipleCopy_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoMultipleCopy self, SoGLRenderAction action)"""
        return _coin.SoMultipleCopy_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoMultipleCopy self, SoPickAction action)"""
        return _coin.SoMultipleCopy_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoMultipleCopy self, SoGetBoundingBoxAction action)"""
        return _coin.SoMultipleCopy_getBoundingBox(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoMultipleCopy self, SoHandleEventAction action)"""
        return _coin.SoMultipleCopy_handleEvent(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoMultipleCopy self, SoGetMatrixAction action)"""
        return _coin.SoMultipleCopy_getMatrix(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoMultipleCopy self, SoSearchAction action)"""
        return _coin.SoMultipleCopy_search(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoMultipleCopy self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMultipleCopy_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoMultipleCopy self, SoAudioRenderAction action)"""
        return _coin.SoMultipleCopy_audioRender(self, action)

# Register SoMultipleCopy in _coin:
_coin.SoMultipleCopy_swigregister(SoMultipleCopy)

def SoMultipleCopy_getClassTypeId() -> "SoType":
    r"""SoMultipleCopy_getClassTypeId() -> SoType"""
    return _coin.SoMultipleCopy_getClassTypeId()

def SoMultipleCopy_initClass() -> "void":
    r"""SoMultipleCopy_initClass()"""
    return _coin.SoMultipleCopy_initClass()

class SoPerspectiveCamera(SoCamera):
    r"""Proxy of C++ SoPerspectiveCamera class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPerspectiveCamera_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPerspectiveCamera self) -> SoType"""
        return _coin.SoPerspectiveCamera_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPerspectiveCamera_initClass()

    def __init__(self):
        r"""__init__(SoPerspectiveCamera self) -> SoPerspectiveCamera"""
        _coin.SoPerspectiveCamera_swiginit(self, _coin.new_SoPerspectiveCamera())
    heightAngle = property(_coin.SoPerspectiveCamera_heightAngle_get, _coin.SoPerspectiveCamera_heightAngle_set, doc=r"""heightAngle : SoSFFloat""")

    def scaleHeight(self, scalefactor: "float") -> "void":
        r"""scaleHeight(SoPerspectiveCamera self, float scalefactor)"""
        return _coin.SoPerspectiveCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, useaspectratio: "float"=0.0) -> "SbViewVolume":
        r"""getViewVolume(SoPerspectiveCamera self, float useaspectratio=0.0) -> SbViewVolume"""
        return _coin.SoPerspectiveCamera_getViewVolume(self, useaspectratio)

    def viewBoundingBox(self, box: "SbBox3f", aspect: "float", slack: "float") -> "void":
        r"""viewBoundingBox(SoPerspectiveCamera self, SbBox3f box, float aspect, float slack)"""
        return _coin.SoPerspectiveCamera_viewBoundingBox(self, box, aspect, slack)

# Register SoPerspectiveCamera in _coin:
_coin.SoPerspectiveCamera_swigregister(SoPerspectiveCamera)

def SoPerspectiveCamera_getClassTypeId() -> "SoType":
    r"""SoPerspectiveCamera_getClassTypeId() -> SoType"""
    return _coin.SoPerspectiveCamera_getClassTypeId()

def SoPerspectiveCamera_initClass() -> "void":
    r"""SoPerspectiveCamera_initClass()"""
    return _coin.SoPerspectiveCamera_initClass()

class SoReversePerspectiveCamera(SoPerspectiveCamera):
    r"""Proxy of C++ SoReversePerspectiveCamera class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoReversePerspectiveCamera_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoReversePerspectiveCamera self) -> SoType"""
        return _coin.SoReversePerspectiveCamera_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoReversePerspectiveCamera_initClass()

    def __init__(self):
        r"""__init__(SoReversePerspectiveCamera self) -> SoReversePerspectiveCamera"""
        _coin.SoReversePerspectiveCamera_swiginit(self, _coin.new_SoReversePerspectiveCamera())

# Register SoReversePerspectiveCamera in _coin:
_coin.SoReversePerspectiveCamera_swigregister(SoReversePerspectiveCamera)

def SoReversePerspectiveCamera_getClassTypeId() -> "SoType":
    r"""SoReversePerspectiveCamera_getClassTypeId() -> SoType"""
    return _coin.SoReversePerspectiveCamera_getClassTypeId()

def SoReversePerspectiveCamera_initClass() -> "void":
    r"""SoReversePerspectiveCamera_initClass()"""
    return _coin.SoReversePerspectiveCamera_initClass()

class SoOrthographicCamera(SoCamera):
    r"""Proxy of C++ SoOrthographicCamera class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOrthographicCamera_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoOrthographicCamera self) -> SoType"""
        return _coin.SoOrthographicCamera_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoOrthographicCamera_initClass()

    def __init__(self):
        r"""__init__(SoOrthographicCamera self) -> SoOrthographicCamera"""
        _coin.SoOrthographicCamera_swiginit(self, _coin.new_SoOrthographicCamera())
    height = property(_coin.SoOrthographicCamera_height_get, _coin.SoOrthographicCamera_height_set, doc=r"""height : SoSFFloat""")

    def scaleHeight(self, scalefactor: "float") -> "void":
        r"""scaleHeight(SoOrthographicCamera self, float scalefactor)"""
        return _coin.SoOrthographicCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, useaspectratio: "float"=0.0) -> "SbViewVolume":
        r"""getViewVolume(SoOrthographicCamera self, float useaspectratio=0.0) -> SbViewVolume"""
        return _coin.SoOrthographicCamera_getViewVolume(self, useaspectratio)

    def viewBoundingBox(self, box: "SbBox3f", aspect: "float", slack: "float") -> "void":
        r"""viewBoundingBox(SoOrthographicCamera self, SbBox3f box, float aspect, float slack)"""
        return _coin.SoOrthographicCamera_viewBoundingBox(self, box, aspect, slack)

# Register SoOrthographicCamera in _coin:
_coin.SoOrthographicCamera_swigregister(SoOrthographicCamera)

def SoOrthographicCamera_getClassTypeId() -> "SoType":
    r"""SoOrthographicCamera_getClassTypeId() -> SoType"""
    return _coin.SoOrthographicCamera_getClassTypeId()

def SoOrthographicCamera_initClass() -> "void":
    r"""SoOrthographicCamera_initClass()"""
    return _coin.SoOrthographicCamera_initClass()

class SoFrustumCamera(SoCamera):
    r"""Proxy of C++ SoFrustumCamera class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFrustumCamera_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFrustumCamera self) -> SoType"""
        return _coin.SoFrustumCamera_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFrustumCamera_initClass()

    def __init__(self):
        r"""__init__(SoFrustumCamera self) -> SoFrustumCamera"""
        _coin.SoFrustumCamera_swiginit(self, _coin.new_SoFrustumCamera())
    left = property(_coin.SoFrustumCamera_left_get, _coin.SoFrustumCamera_left_set, doc=r"""left : SoSFFloat""")
    right = property(_coin.SoFrustumCamera_right_get, _coin.SoFrustumCamera_right_set, doc=r"""right : SoSFFloat""")
    top = property(_coin.SoFrustumCamera_top_get, _coin.SoFrustumCamera_top_set, doc=r"""top : SoSFFloat""")
    bottom = property(_coin.SoFrustumCamera_bottom_get, _coin.SoFrustumCamera_bottom_set, doc=r"""bottom : SoSFFloat""")

    def scaleHeight(self, scalefactor: "float") -> "void":
        r"""scaleHeight(SoFrustumCamera self, float scalefactor)"""
        return _coin.SoFrustumCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, useaspectratio: "float"=0.0) -> "SbViewVolume":
        r"""getViewVolume(SoFrustumCamera self, float useaspectratio=0.0) -> SbViewVolume"""
        return _coin.SoFrustumCamera_getViewVolume(self, useaspectratio)

# Register SoFrustumCamera in _coin:
_coin.SoFrustumCamera_swigregister(SoFrustumCamera)

def SoFrustumCamera_getClassTypeId() -> "SoType":
    r"""SoFrustumCamera_getClassTypeId() -> SoType"""
    return _coin.SoFrustumCamera_getClassTypeId()

def SoFrustumCamera_initClass() -> "void":
    r"""SoFrustumCamera_initClass()"""
    return _coin.SoFrustumCamera_initClass()

class SoQuadMesh(SoNonIndexedShape):
    r"""Proxy of C++ SoQuadMesh class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoQuadMesh_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoQuadMesh self) -> SoType"""
        return _coin.SoQuadMesh_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoQuadMesh_initClass()

    def __init__(self):
        r"""__init__(SoQuadMesh self) -> SoQuadMesh"""
        _coin.SoQuadMesh_swiginit(self, _coin.new_SoQuadMesh())
    verticesPerColumn = property(_coin.SoQuadMesh_verticesPerColumn_get, _coin.SoQuadMesh_verticesPerColumn_set, doc=r"""verticesPerColumn : SoSFInt32""")
    verticesPerRow = property(_coin.SoQuadMesh_verticesPerRow_get, _coin.SoQuadMesh_verticesPerRow_set, doc=r"""verticesPerRow : SoSFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoQuadMesh self, SoGLRenderAction action)"""
        return _coin.SoQuadMesh_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoQuadMesh self, SoGetPrimitiveCountAction action)"""
        return _coin.SoQuadMesh_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, state: "SoState", nb: "SoNormalBundle") -> "SbBool":
        r"""generateDefaultNormals(SoQuadMesh self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoQuadMesh_generateDefaultNormals(self, state, nb)

# Register SoQuadMesh in _coin:
_coin.SoQuadMesh_swigregister(SoQuadMesh)

def SoQuadMesh_getClassTypeId() -> "SoType":
    r"""SoQuadMesh_getClassTypeId() -> SoType"""
    return _coin.SoQuadMesh_getClassTypeId()

def SoQuadMesh_initClass() -> "void":
    r"""SoQuadMesh_initClass()"""
    return _coin.SoQuadMesh_initClass()

class SoTriangleStripSet(SoNonIndexedShape):
    r"""Proxy of C++ SoTriangleStripSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTriangleStripSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTriangleStripSet self) -> SoType"""
        return _coin.SoTriangleStripSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTriangleStripSet_initClass()

    def __init__(self):
        r"""__init__(SoTriangleStripSet self) -> SoTriangleStripSet"""
        _coin.SoTriangleStripSet_swiginit(self, _coin.new_SoTriangleStripSet())
    numVertices = property(_coin.SoTriangleStripSet_numVertices_get, _coin.SoTriangleStripSet_numVertices_set, doc=r"""numVertices : SoMFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTriangleStripSet self, SoGLRenderAction action)"""
        return _coin.SoTriangleStripSet_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoTriangleStripSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTriangleStripSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, state: "SoState", nb: "SoNormalBundle") -> "SbBool":
        r"""generateDefaultNormals(SoTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoTriangleStripSet_generateDefaultNormals(self, state, nb)

# Register SoTriangleStripSet in _coin:
_coin.SoTriangleStripSet_swigregister(SoTriangleStripSet)

def SoTriangleStripSet_getClassTypeId() -> "SoType":
    r"""SoTriangleStripSet_getClassTypeId() -> SoType"""
    return _coin.SoTriangleStripSet_getClassTypeId()

def SoTriangleStripSet_initClass() -> "void":
    r"""SoTriangleStripSet_initClass()"""
    return _coin.SoTriangleStripSet_initClass()

class SoIndexedPointSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedPointSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedPointSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedPointSet self) -> SoType"""
        return _coin.SoIndexedPointSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedPointSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedPointSet self) -> SoIndexedPointSet"""
        _coin.SoIndexedPointSet_swiginit(self, _coin.new_SoIndexedPointSet())

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoIndexedPointSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedPointSet_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoIndexedPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedPointSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoIndexedPointSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedPointSet_getPrimitiveCount(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoIndexedPointSet self, SoNotList list)"""
        return _coin.SoIndexedPointSet_notify(self, list)

# Register SoIndexedPointSet in _coin:
_coin.SoIndexedPointSet_swigregister(SoIndexedPointSet)

def SoIndexedPointSet_getClassTypeId() -> "SoType":
    r"""SoIndexedPointSet_getClassTypeId() -> SoType"""
    return _coin.SoIndexedPointSet_getClassTypeId()

def SoIndexedPointSet_initClass() -> "void":
    r"""SoIndexedPointSet_initClass()"""
    return _coin.SoIndexedPointSet_initClass()

class SoIndexedMarkerSet(SoIndexedPointSet):
    r"""Proxy of C++ SoIndexedMarkerSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedMarkerSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoIndexedMarkerSet self) -> SoType"""
        return _coin.SoIndexedMarkerSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoIndexedMarkerSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedMarkerSet self) -> SoIndexedMarkerSet"""
        _coin.SoIndexedMarkerSet_swiginit(self, _coin.new_SoIndexedMarkerSet())
    markerIndex = property(_coin.SoIndexedMarkerSet_markerIndex_get, _coin.SoIndexedMarkerSet_markerIndex_set, doc=r"""markerIndex : SoMFInt32""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoIndexedMarkerSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedMarkerSet_GLRender(self, action)

# Register SoIndexedMarkerSet in _coin:
_coin.SoIndexedMarkerSet_swigregister(SoIndexedMarkerSet)

def SoIndexedMarkerSet_getClassTypeId() -> "SoType":
    r"""SoIndexedMarkerSet_getClassTypeId() -> SoType"""
    return _coin.SoIndexedMarkerSet_getClassTypeId()

def SoIndexedMarkerSet_initClass() -> "void":
    r"""SoIndexedMarkerSet_initClass()"""
    return _coin.SoIndexedMarkerSet_initClass()

class SoNurbsCurve(SoShape):
    r"""Proxy of C++ SoNurbsCurve class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNurbsCurve_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNurbsCurve self) -> SoType"""
        return _coin.SoNurbsCurve_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNurbsCurve_initClass()

    def __init__(self):
        r"""__init__(SoNurbsCurve self) -> SoNurbsCurve"""
        _coin.SoNurbsCurve_swiginit(self, _coin.new_SoNurbsCurve())
    numControlPoints = property(_coin.SoNurbsCurve_numControlPoints_get, _coin.SoNurbsCurve_numControlPoints_set, doc=r"""numControlPoints : SoSFInt32""")
    knotVector = property(_coin.SoNurbsCurve_knotVector_get, _coin.SoNurbsCurve_knotVector_set, doc=r"""knotVector : SoMFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoNurbsCurve self, SoGLRenderAction action)"""
        return _coin.SoNurbsCurve_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoNurbsCurve self, SoRayPickAction action)"""
        return _coin.SoNurbsCurve_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoNurbsCurve self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsCurve_getPrimitiveCount(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoNurbsCurve self, SoGetBoundingBoxAction action)"""
        return _coin.SoNurbsCurve_getBoundingBox(self, action)

    def sendPrimitive(self, arg2: "SoAction", arg3: "SoPrimitiveVertex") -> "void":
        r"""sendPrimitive(SoNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoNurbsCurve_sendPrimitive(self, arg2, arg3)

# Register SoNurbsCurve in _coin:
_coin.SoNurbsCurve_swigregister(SoNurbsCurve)

def SoNurbsCurve_getClassTypeId() -> "SoType":
    r"""SoNurbsCurve_getClassTypeId() -> SoType"""
    return _coin.SoNurbsCurve_getClassTypeId()

def SoNurbsCurve_initClass() -> "void":
    r"""SoNurbsCurve_initClass()"""
    return _coin.SoNurbsCurve_initClass()

class SoNurbsSurface(SoShape):
    r"""Proxy of C++ SoNurbsSurface class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNurbsSurface_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNurbsSurface self) -> SoType"""
        return _coin.SoNurbsSurface_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNurbsSurface_initClass()

    def __init__(self):
        r"""__init__(SoNurbsSurface self) -> SoNurbsSurface"""
        _coin.SoNurbsSurface_swiginit(self, _coin.new_SoNurbsSurface())
    numUControlPoints = property(_coin.SoNurbsSurface_numUControlPoints_get, _coin.SoNurbsSurface_numUControlPoints_set, doc=r"""numUControlPoints : SoSFInt32""")
    numVControlPoints = property(_coin.SoNurbsSurface_numVControlPoints_get, _coin.SoNurbsSurface_numVControlPoints_set, doc=r"""numVControlPoints : SoSFInt32""")
    numSControlPoints = property(_coin.SoNurbsSurface_numSControlPoints_get, _coin.SoNurbsSurface_numSControlPoints_set, doc=r"""numSControlPoints : SoSFInt32""")
    numTControlPoints = property(_coin.SoNurbsSurface_numTControlPoints_get, _coin.SoNurbsSurface_numTControlPoints_set, doc=r"""numTControlPoints : SoSFInt32""")
    uKnotVector = property(_coin.SoNurbsSurface_uKnotVector_get, _coin.SoNurbsSurface_uKnotVector_set, doc=r"""uKnotVector : SoMFFloat""")
    vKnotVector = property(_coin.SoNurbsSurface_vKnotVector_get, _coin.SoNurbsSurface_vKnotVector_set, doc=r"""vKnotVector : SoMFFloat""")
    sKnotVector = property(_coin.SoNurbsSurface_sKnotVector_get, _coin.SoNurbsSurface_sKnotVector_set, doc=r"""sKnotVector : SoMFFloat""")
    tKnotVector = property(_coin.SoNurbsSurface_tKnotVector_get, _coin.SoNurbsSurface_tKnotVector_set, doc=r"""tKnotVector : SoMFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoNurbsSurface self, SoGLRenderAction action)"""
        return _coin.SoNurbsSurface_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoNurbsSurface self, SoRayPickAction action)"""
        return _coin.SoNurbsSurface_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoNurbsSurface self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsSurface_getPrimitiveCount(self, action)

    def sendPrimitive(self, arg2: "SoAction", arg3: "SoPrimitiveVertex") -> "void":
        r"""sendPrimitive(SoNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoNurbsSurface_sendPrimitive(self, arg2, arg3)

# Register SoNurbsSurface in _coin:
_coin.SoNurbsSurface_swigregister(SoNurbsSurface)

def SoNurbsSurface_getClassTypeId() -> "SoType":
    r"""SoNurbsSurface_getClassTypeId() -> SoType"""
    return _coin.SoNurbsSurface_getClassTypeId()

def SoNurbsSurface_initClass() -> "void":
    r"""SoNurbsSurface_initClass()"""
    return _coin.SoNurbsSurface_initClass()

class SoSphere(SoShape):
    r"""Proxy of C++ SoSphere class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSphere_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSphere self) -> SoType"""
        return _coin.SoSphere_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSphere_initClass()

    def __init__(self):
        r"""__init__(SoSphere self) -> SoSphere"""
        _coin.SoSphere_swiginit(self, _coin.new_SoSphere())
    radius = property(_coin.SoSphere_radius_get, _coin.SoSphere_radius_set, doc=r"""radius : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoSphere self, SoGLRenderAction action)"""
        return _coin.SoSphere_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoSphere self, SoRayPickAction action)"""
        return _coin.SoSphere_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoSphere self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSphere_getPrimitiveCount(self, action)

# Register SoSphere in _coin:
_coin.SoSphere_swigregister(SoSphere)

def SoSphere_getClassTypeId() -> "SoType":
    r"""SoSphere_getClassTypeId() -> SoType"""
    return _coin.SoSphere_getClassTypeId()

def SoSphere_initClass() -> "void":
    r"""SoSphere_initClass()"""
    return _coin.SoSphere_initClass()

class SoText2(SoShape):
    r"""Proxy of C++ SoText2 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoText2_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoText2 self) -> SoType"""
        return _coin.SoText2_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoText2_initClass()

    def __init__(self):
        r"""__init__(SoText2 self) -> SoText2"""
        _coin.SoText2_swiginit(self, _coin.new_SoText2())
    LEFT = _coin.SoText2_LEFT
    
    RIGHT = _coin.SoText2_RIGHT
    
    CENTER = _coin.SoText2_CENTER
    
    string = property(_coin.SoText2_string_get, _coin.SoText2_string_set, doc=r"""string : SoMFString""")
    spacing = property(_coin.SoText2_spacing_get, _coin.SoText2_spacing_set, doc=r"""spacing : SoSFFloat""")
    justification = property(_coin.SoText2_justification_get, _coin.SoText2_justification_set, doc=r"""justification : SoSFEnum""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoText2 self, SoGLRenderAction action)"""
        return _coin.SoText2_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoText2 self, SoRayPickAction action)"""
        return _coin.SoText2_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoText2 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText2_getPrimitiveCount(self, action)

# Register SoText2 in _coin:
_coin.SoText2_swigregister(SoText2)

def SoText2_getClassTypeId() -> "SoType":
    r"""SoText2_getClassTypeId() -> SoType"""
    return _coin.SoText2_getClassTypeId()

def SoText2_initClass() -> "void":
    r"""SoText2_initClass()"""
    return _coin.SoText2_initClass()

class SoText3(SoShape):
    r"""Proxy of C++ SoText3 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoText3_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoText3 self) -> SoType"""
        return _coin.SoText3_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoText3_initClass()

    def __init__(self):
        r"""__init__(SoText3 self) -> SoText3"""
        _coin.SoText3_swiginit(self, _coin.new_SoText3())
    FRONT = _coin.SoText3_FRONT
    
    SIDES = _coin.SoText3_SIDES
    
    BACK = _coin.SoText3_BACK
    
    ALL = _coin.SoText3_ALL
    
    LEFT = _coin.SoText3_LEFT
    
    RIGHT = _coin.SoText3_RIGHT
    
    CENTER = _coin.SoText3_CENTER
    
    string = property(_coin.SoText3_string_get, _coin.SoText3_string_set, doc=r"""string : SoMFString""")
    spacing = property(_coin.SoText3_spacing_get, _coin.SoText3_spacing_set, doc=r"""spacing : SoSFFloat""")
    justification = property(_coin.SoText3_justification_get, _coin.SoText3_justification_set, doc=r"""justification : SoSFEnum""")
    parts = property(_coin.SoText3_parts_get, _coin.SoText3_parts_set, doc=r"""parts : SoSFBitMask""")

    def getCharacterBounds(self, state: "SoState", stringindex: "int", charindex: "int") -> "SbBox3f":
        r"""getCharacterBounds(SoText3 self, SoState state, int stringindex, int charindex) -> SbBox3f"""
        return _coin.SoText3_getCharacterBounds(self, state, stringindex, charindex)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoText3 self, SoGLRenderAction action)"""
        return _coin.SoText3_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoText3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText3_getPrimitiveCount(self, action)

# Register SoText3 in _coin:
_coin.SoText3_swigregister(SoText3)

def SoText3_getClassTypeId() -> "SoType":
    r"""SoText3_getClassTypeId() -> SoType"""
    return _coin.SoText3_getClassTypeId()

def SoText3_initClass() -> "void":
    r"""SoText3_initClass()"""
    return _coin.SoText3_initClass()

class SoWWWAnchor(SoLocateHighlight):
    r"""Proxy of C++ SoWWWAnchor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWWWAnchor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoWWWAnchor self) -> SoType"""
        return _coin.SoWWWAnchor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoWWWAnchor_initClass()

    def __init__(self):
        r"""__init__(SoWWWAnchor self) -> SoWWWAnchor"""
        _coin.SoWWWAnchor_swiginit(self, _coin.new_SoWWWAnchor())
    NONE = _coin.SoWWWAnchor_NONE
    
    POINT = _coin.SoWWWAnchor_POINT
    
    name = property(_coin.SoWWWAnchor_name_get, _coin.SoWWWAnchor_name_set, doc=r"""name : SoSFString""")
    description = property(_coin.SoWWWAnchor_description_get, _coin.SoWWWAnchor_description_set, doc=r"""description : SoSFString""")
    map = property(_coin.SoWWWAnchor_map_get, _coin.SoWWWAnchor_map_set, doc=r"""map : SoSFEnum""")

    def setFullURLName(self, url: "SbString") -> "void":
        r"""setFullURLName(SoWWWAnchor self, SbString url)"""
        return _coin.SoWWWAnchor_setFullURLName(self, url)

    def getFullURLName(self) -> "SbString const &":
        r"""getFullURLName(SoWWWAnchor self) -> SbString"""
        return _coin.SoWWWAnchor_getFullURLName(self)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoWWWAnchor self, SoHandleEventAction action)"""
        return _coin.SoWWWAnchor_handleEvent(self, action)

    @staticmethod
    def setFetchURLCallBack(f: "SoWWWAnchorCB *", userData: "void *") -> "void":
        r"""setFetchURLCallBack(SoWWWAnchorCB * f, void * userData)"""
        return _coin.SoWWWAnchor_setFetchURLCallBack(f, userData)

    @staticmethod
    def setHighlightURLCallBack(f: "SoWWWAnchorCB *", userData: "void *") -> "void":
        r"""setHighlightURLCallBack(SoWWWAnchorCB * f, void * userData)"""
        return _coin.SoWWWAnchor_setHighlightURLCallBack(f, userData)

# Register SoWWWAnchor in _coin:
_coin.SoWWWAnchor_swigregister(SoWWWAnchor)

def SoWWWAnchor_getClassTypeId() -> "SoType":
    r"""SoWWWAnchor_getClassTypeId() -> SoType"""
    return _coin.SoWWWAnchor_getClassTypeId()

def SoWWWAnchor_initClass() -> "void":
    r"""SoWWWAnchor_initClass()"""
    return _coin.SoWWWAnchor_initClass()

def SoWWWAnchor_setFetchURLCallBack(f: "SoWWWAnchorCB *", userData: "void *") -> "void":
    r"""SoWWWAnchor_setFetchURLCallBack(SoWWWAnchorCB * f, void * userData)"""
    return _coin.SoWWWAnchor_setFetchURLCallBack(f, userData)

def SoWWWAnchor_setHighlightURLCallBack(f: "SoWWWAnchorCB *", userData: "void *") -> "void":
    r"""SoWWWAnchor_setHighlightURLCallBack(SoWWWAnchorCB * f, void * userData)"""
    return _coin.SoWWWAnchor_setHighlightURLCallBack(f, userData)

class SoPathSwitch(SoGroup):
    r"""Proxy of C++ SoPathSwitch class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPathSwitch_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPathSwitch self) -> SoType"""
        return _coin.SoPathSwitch_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPathSwitch_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoPathSwitch self) -> SoPathSwitch
        __init__(SoPathSwitch self, int numchildren) -> SoPathSwitch
        """
        _coin.SoPathSwitch_swiginit(self, _coin.new_SoPathSwitch(*args))
    path = property(_coin.SoPathSwitch_path_get, _coin.SoPathSwitch_path_set, doc=r"""path : SoSFPath""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoPathSwitch self, SoAction action)"""
        return _coin.SoPathSwitch_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoPathSwitch self, SoGLRenderAction action)"""
        return _coin.SoPathSwitch_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoPathSwitch self, SoPickAction action)"""
        return _coin.SoPathSwitch_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoPathSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoPathSwitch_getBoundingBox(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoPathSwitch self, SoHandleEventAction action)"""
        return _coin.SoPathSwitch_handleEvent(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoPathSwitch self, SoGetMatrixAction action)"""
        return _coin.SoPathSwitch_getMatrix(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoPathSwitch self, SoSearchAction action)"""
        return _coin.SoPathSwitch_search(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoPathSwitch self, SoCallbackAction action)"""
        return _coin.SoPathSwitch_callback(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoPathSwitch self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPathSwitch_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoPathSwitch self, SoAudioRenderAction action)"""
        return _coin.SoPathSwitch_audioRender(self, action)

# Register SoPathSwitch in _coin:
_coin.SoPathSwitch_swigregister(SoPathSwitch)

def SoPathSwitch_getClassTypeId() -> "SoType":
    r"""SoPathSwitch_getClassTypeId() -> SoType"""
    return _coin.SoPathSwitch_getClassTypeId()

def SoPathSwitch_initClass() -> "void":
    r"""SoPathSwitch_initClass()"""
    return _coin.SoPathSwitch_initClass()

class SoTransformSeparator(SoGroup):
    r"""Proxy of C++ SoTransformSeparator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformSeparator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransformSeparator self) -> SoType"""
        return _coin.SoTransformSeparator_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransformSeparator_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoTransformSeparator self) -> SoTransformSeparator
        __init__(SoTransformSeparator self, int nChildren) -> SoTransformSeparator
        """
        _coin.SoTransformSeparator_swiginit(self, _coin.new_SoTransformSeparator(*args))

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTransformSeparator self, SoAction action)"""
        return _coin.SoTransformSeparator_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTransformSeparator self, SoCallbackAction action)"""
        return _coin.SoTransformSeparator_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTransformSeparator self, SoGLRenderAction action)"""
        return _coin.SoTransformSeparator_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTransformSeparator self, SoPickAction action)"""
        return _coin.SoTransformSeparator_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoTransformSeparator self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformSeparator_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTransformSeparator self, SoGetMatrixAction action)"""
        return _coin.SoTransformSeparator_getMatrix(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoTransformSeparator self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransformSeparator_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoTransformSeparator self, SoAudioRenderAction action)"""
        return _coin.SoTransformSeparator_audioRender(self, action)

# Register SoTransformSeparator in _coin:
_coin.SoTransformSeparator_swigregister(SoTransformSeparator)

def SoTransformSeparator_getClassTypeId() -> "SoType":
    r"""SoTransformSeparator_getClassTypeId() -> SoType"""
    return _coin.SoTransformSeparator_getClassTypeId()

def SoTransformSeparator_initClass() -> "void":
    r"""SoTransformSeparator_initClass()"""
    return _coin.SoTransformSeparator_initClass()

class SoRotation(SoTransformation):
    r"""Proxy of C++ SoRotation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoRotation self) -> SoType"""
        return _coin.SoRotation_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoRotation_initClass()

    def __init__(self):
        r"""__init__(SoRotation self) -> SoRotation"""
        _coin.SoRotation_swiginit(self, _coin.new_SoRotation())
    rotation = property(_coin.SoRotation_rotation_get, _coin.SoRotation_rotation_set, doc=r"""rotation : SoSFRotation""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoRotation self, SoAction action)"""
        return _coin.SoRotation_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoRotation self, SoGLRenderAction action)"""
        return _coin.SoRotation_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoRotation self, SoCallbackAction action)"""
        return _coin.SoRotation_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoRotation self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotation_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoRotation self, SoGetMatrixAction action)"""
        return _coin.SoRotation_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoRotation self, SoPickAction action)"""
        return _coin.SoRotation_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoRotation self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotation_getPrimitiveCount(self, action)

# Register SoRotation in _coin:
_coin.SoRotation_swigregister(SoRotation)

def SoRotation_getClassTypeId() -> "SoType":
    r"""SoRotation_getClassTypeId() -> SoType"""
    return _coin.SoRotation_getClassTypeId()

def SoRotation_initClass() -> "void":
    r"""SoRotation_initClass()"""
    return _coin.SoRotation_initClass()

class SoPendulum(SoRotation):
    r"""Proxy of C++ SoPendulum class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPendulum_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPendulum self) -> SoType"""
        return _coin.SoPendulum_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPendulum_initClass()

    def __init__(self):
        r"""__init__(SoPendulum self) -> SoPendulum"""
        _coin.SoPendulum_swiginit(self, _coin.new_SoPendulum())
    rotation0 = property(_coin.SoPendulum_rotation0_get, _coin.SoPendulum_rotation0_set, doc=r"""rotation0 : SoSFRotation""")
    rotation1 = property(_coin.SoPendulum_rotation1_get, _coin.SoPendulum_rotation1_set, doc=r"""rotation1 : SoSFRotation""")
    speed = property(_coin.SoPendulum_speed_get, _coin.SoPendulum_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoPendulum_on_get, _coin.SoPendulum_on_set, doc=r"""on : SoSFBool""")

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoPendulum self, SoWriteAction action)"""
        return _coin.SoPendulum_write(self, action)

# Register SoPendulum in _coin:
_coin.SoPendulum_swigregister(SoPendulum)

def SoPendulum_getClassTypeId() -> "SoType":
    r"""SoPendulum_getClassTypeId() -> SoType"""
    return _coin.SoPendulum_getClassTypeId()

def SoPendulum_initClass() -> "void":
    r"""SoPendulum_initClass()"""
    return _coin.SoPendulum_initClass()

class SoRotor(SoRotation):
    r"""Proxy of C++ SoRotor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoRotor self) -> SoType"""
        return _coin.SoRotor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoRotor_initClass()

    def __init__(self):
        r"""__init__(SoRotor self) -> SoRotor"""
        _coin.SoRotor_swiginit(self, _coin.new_SoRotor())
    speed = property(_coin.SoRotor_speed_get, _coin.SoRotor_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoRotor_on_get, _coin.SoRotor_on_set, doc=r"""on : SoSFBool""")

# Register SoRotor in _coin:
_coin.SoRotor_swigregister(SoRotor)

def SoRotor_getClassTypeId() -> "SoType":
    r"""SoRotor_getClassTypeId() -> SoType"""
    return _coin.SoRotor_getClassTypeId()

def SoRotor_initClass() -> "void":
    r"""SoRotor_initClass()"""
    return _coin.SoRotor_initClass()

class SoResetTransform(SoTransformation):
    r"""Proxy of C++ SoResetTransform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoResetTransform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoResetTransform self) -> SoType"""
        return _coin.SoResetTransform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoResetTransform_initClass()

    def __init__(self):
        r"""__init__(SoResetTransform self) -> SoResetTransform"""
        _coin.SoResetTransform_swiginit(self, _coin.new_SoResetTransform())
    TRANSFORM = _coin.SoResetTransform_TRANSFORM
    
    BBOX = _coin.SoResetTransform_BBOX
    
    whatToReset = property(_coin.SoResetTransform_whatToReset_get, _coin.SoResetTransform_whatToReset_set, doc=r"""whatToReset : SoSFBitMask""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoResetTransform self, SoAction action)"""
        return _coin.SoResetTransform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoResetTransform self, SoCallbackAction action)"""
        return _coin.SoResetTransform_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoResetTransform self, SoGLRenderAction action)"""
        return _coin.SoResetTransform_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoResetTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoResetTransform_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoResetTransform self, SoGetMatrixAction action)"""
        return _coin.SoResetTransform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoResetTransform self, SoPickAction action)"""
        return _coin.SoResetTransform_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoResetTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoResetTransform_getPrimitiveCount(self, action)

# Register SoResetTransform in _coin:
_coin.SoResetTransform_swigregister(SoResetTransform)

def SoResetTransform_getClassTypeId() -> "SoType":
    r"""SoResetTransform_getClassTypeId() -> SoType"""
    return _coin.SoResetTransform_getClassTypeId()

def SoResetTransform_initClass() -> "void":
    r"""SoResetTransform_initClass()"""
    return _coin.SoResetTransform_initClass()

class SoRotationXYZ(SoTransformation):
    r"""Proxy of C++ SoRotationXYZ class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotationXYZ_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoRotationXYZ self) -> SoType"""
        return _coin.SoRotationXYZ_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoRotationXYZ_initClass()

    def __init__(self):
        r"""__init__(SoRotationXYZ self) -> SoRotationXYZ"""
        _coin.SoRotationXYZ_swiginit(self, _coin.new_SoRotationXYZ())
    X = _coin.SoRotationXYZ_X
    
    Y = _coin.SoRotationXYZ_Y
    
    Z = _coin.SoRotationXYZ_Z
    
    axis = property(_coin.SoRotationXYZ_axis_get, _coin.SoRotationXYZ_axis_set, doc=r"""axis : SoSFEnum""")
    angle = property(_coin.SoRotationXYZ_angle_get, _coin.SoRotationXYZ_angle_set, doc=r"""angle : SoSFFloat""")

    def getRotation(self) -> "SbRotation":
        r"""getRotation(SoRotationXYZ self) -> SbRotation"""
        return _coin.SoRotationXYZ_getRotation(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoRotationXYZ self, SoAction action)"""
        return _coin.SoRotationXYZ_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoRotationXYZ self, SoGLRenderAction action)"""
        return _coin.SoRotationXYZ_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoRotationXYZ self, SoCallbackAction action)"""
        return _coin.SoRotationXYZ_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoRotationXYZ self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotationXYZ_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoRotationXYZ self, SoGetMatrixAction action)"""
        return _coin.SoRotationXYZ_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoRotationXYZ self, SoPickAction action)"""
        return _coin.SoRotationXYZ_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoRotationXYZ self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotationXYZ_getPrimitiveCount(self, action)

# Register SoRotationXYZ in _coin:
_coin.SoRotationXYZ_swigregister(SoRotationXYZ)

def SoRotationXYZ_getClassTypeId() -> "SoType":
    r"""SoRotationXYZ_getClassTypeId() -> SoType"""
    return _coin.SoRotationXYZ_getClassTypeId()

def SoRotationXYZ_initClass() -> "void":
    r"""SoRotationXYZ_initClass()"""
    return _coin.SoRotationXYZ_initClass()

class SoTranslation(SoTransformation):
    r"""Proxy of C++ SoTranslation class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTranslation_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTranslation self) -> SoType"""
        return _coin.SoTranslation_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTranslation_initClass()

    def __init__(self):
        r"""__init__(SoTranslation self) -> SoTranslation"""
        _coin.SoTranslation_swiginit(self, _coin.new_SoTranslation())
    translation = property(_coin.SoTranslation_translation_get, _coin.SoTranslation_translation_set, doc=r"""translation : SoSFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTranslation self, SoAction action)"""
        return _coin.SoTranslation_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTranslation self, SoCallbackAction action)"""
        return _coin.SoTranslation_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTranslation self, SoGLRenderAction action)"""
        return _coin.SoTranslation_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoTranslation self, SoGetBoundingBoxAction action)"""
        return _coin.SoTranslation_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTranslation self, SoGetMatrixAction action)"""
        return _coin.SoTranslation_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTranslation self, SoPickAction action)"""
        return _coin.SoTranslation_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoTranslation self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTranslation_getPrimitiveCount(self, action)

# Register SoTranslation in _coin:
_coin.SoTranslation_swigregister(SoTranslation)

def SoTranslation_getClassTypeId() -> "SoType":
    r"""SoTranslation_getClassTypeId() -> SoType"""
    return _coin.SoTranslation_getClassTypeId()

def SoTranslation_initClass() -> "void":
    r"""SoTranslation_initClass()"""
    return _coin.SoTranslation_initClass()

class SoShuttle(SoTranslation):
    r"""Proxy of C++ SoShuttle class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShuttle_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShuttle self) -> SoType"""
        return _coin.SoShuttle_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShuttle_initClass()

    def __init__(self):
        r"""__init__(SoShuttle self) -> SoShuttle"""
        _coin.SoShuttle_swiginit(self, _coin.new_SoShuttle())
    translation0 = property(_coin.SoShuttle_translation0_get, _coin.SoShuttle_translation0_set, doc=r"""translation0 : SoSFVec3f""")
    translation1 = property(_coin.SoShuttle_translation1_get, _coin.SoShuttle_translation1_set, doc=r"""translation1 : SoSFVec3f""")
    speed = property(_coin.SoShuttle_speed_get, _coin.SoShuttle_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoShuttle_on_get, _coin.SoShuttle_on_set, doc=r"""on : SoSFBool""")

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoShuttle self, SoWriteAction action)"""
        return _coin.SoShuttle_write(self, action)

# Register SoShuttle in _coin:
_coin.SoShuttle_swigregister(SoShuttle)

def SoShuttle_getClassTypeId() -> "SoType":
    r"""SoShuttle_getClassTypeId() -> SoType"""
    return _coin.SoShuttle_getClassTypeId()

def SoShuttle_initClass() -> "void":
    r"""SoShuttle_initClass()"""
    return _coin.SoShuttle_initClass()

class SoSurroundScale(SoTransformation):
    r"""Proxy of C++ SoSurroundScale class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSurroundScale_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSurroundScale self) -> SoType"""
        return _coin.SoSurroundScale_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSurroundScale_initClass()

    def __init__(self):
        r"""__init__(SoSurroundScale self) -> SoSurroundScale"""
        _coin.SoSurroundScale_swiginit(self, _coin.new_SoSurroundScale())
    numNodesUpToContainer = property(_coin.SoSurroundScale_numNodesUpToContainer_get, _coin.SoSurroundScale_numNodesUpToContainer_set, doc=r"""numNodesUpToContainer : SoSFInt32""")
    numNodesUpToReset = property(_coin.SoSurroundScale_numNodesUpToReset_get, _coin.SoSurroundScale_numNodesUpToReset_set, doc=r"""numNodesUpToReset : SoSFInt32""")

    def invalidate(self) -> "void":
        r"""invalidate(SoSurroundScale self)"""
        return _coin.SoSurroundScale_invalidate(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoSurroundScale self, SoAction action)"""
        return _coin.SoSurroundScale_doAction(self, action)

    def setDoingTranslations(self, val: "SbBool const") -> "void":
        r"""setDoingTranslations(SoSurroundScale self, SbBool const val)"""
        return _coin.SoSurroundScale_setDoingTranslations(self, val)

    def isDoingTranslations(self) -> "SbBool":
        r"""isDoingTranslations(SoSurroundScale self) -> SbBool"""
        return _coin.SoSurroundScale_isDoingTranslations(self)

# Register SoSurroundScale in _coin:
_coin.SoSurroundScale_swigregister(SoSurroundScale)

def SoSurroundScale_getClassTypeId() -> "SoType":
    r"""SoSurroundScale_getClassTypeId() -> SoType"""
    return _coin.SoSurroundScale_getClassTypeId()

def SoSurroundScale_initClass() -> "void":
    r"""SoSurroundScale_initClass()"""
    return _coin.SoSurroundScale_initClass()

class SoNurbsProfile(SoProfile):
    r"""Proxy of C++ SoNurbsProfile class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNurbsProfile_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNurbsProfile self) -> SoType"""
        return _coin.SoNurbsProfile_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNurbsProfile_initClass()

    def __init__(self):
        r"""__init__(SoNurbsProfile self) -> SoNurbsProfile"""
        _coin.SoNurbsProfile_swiginit(self, _coin.new_SoNurbsProfile())
    knotVector = property(_coin.SoNurbsProfile_knotVector_get, _coin.SoNurbsProfile_knotVector_set, doc=r"""knotVector : SoMFFloat""")

    def getTrimCurve(self, state: "SoState", numpoints: "int32_t &", points: "float *&", floatspervec: "int &", numknots: "int32_t &", knotvector: "float *&") -> "void":
        r"""getTrimCurve(SoNurbsProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"""
        return _coin.SoNurbsProfile_getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector)

    def getVertices(self, state: "SoState", numvertices: "int32_t &", vertices: "SbVec2f *&") -> "void":
        r"""getVertices(SoNurbsProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoNurbsProfile_getVertices(self, state, numvertices, vertices)

# Register SoNurbsProfile in _coin:
_coin.SoNurbsProfile_swigregister(SoNurbsProfile)

def SoNurbsProfile_getClassTypeId() -> "SoType":
    r"""SoNurbsProfile_getClassTypeId() -> SoType"""
    return _coin.SoNurbsProfile_getClassTypeId()

def SoNurbsProfile_initClass() -> "void":
    r"""SoNurbsProfile_initClass()"""
    return _coin.SoNurbsProfile_initClass()

class SoVertexAttribute(SoNode):
    r"""Proxy of C++ SoVertexAttribute class."""

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

    def __init__(self):
        r"""__init__(SoVertexAttribute self) -> SoVertexAttribute"""
        _coin.SoVertexAttribute_swiginit(self, _coin.new_SoVertexAttribute())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVertexAttribute_initClass()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttribute_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVertexAttribute self) -> SoType"""
        return _coin.SoVertexAttribute_getTypeId(self)
    name = property(_coin.SoVertexAttribute_name_get, _coin.SoVertexAttribute_name_set, doc=r"""name : SoSFName""")
    typeName = property(_coin.SoVertexAttribute_typeName_get, _coin.SoVertexAttribute_typeName_set, doc=r"""typeName : SoSFName""")

    def getValuesField(self) -> "SoMField *":
        r"""getValuesField(SoVertexAttribute self) -> SoMField"""
        return _coin.SoVertexAttribute_getValuesField(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVertexAttribute self, SoAction action)"""
        return _coin.SoVertexAttribute_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVertexAttribute self, SoGLRenderAction action)"""
        return _coin.SoVertexAttribute_GLRender(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVertexAttribute self, SoWriteAction action)"""
        return _coin.SoVertexAttribute_write(self, action)

    def copyContents(self, srcFrom: "SoFieldContainer", copyconnections: "SbBool") -> "void":
        r"""copyContents(SoVertexAttribute self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoVertexAttribute_copyContents(self, srcFrom, copyconnections)

    def notify(self, l: "SoNotList") -> "void":
        r"""notify(SoVertexAttribute self, SoNotList l)"""
        return _coin.SoVertexAttribute_notify(self, l)

# Register SoVertexAttribute in _coin:
_coin.SoVertexAttribute_swigregister(SoVertexAttribute)

def SoVertexAttribute_initClass() -> "void":
    r"""SoVertexAttribute_initClass()"""
    return _coin.SoVertexAttribute_initClass()

def SoVertexAttribute_getClassTypeId() -> "SoType":
    r"""SoVertexAttribute_getClassTypeId() -> SoType"""
    return _coin.SoVertexAttribute_getClassTypeId()

class SoVertexAttributeBinding(SoNode):
    r"""Proxy of C++ SoVertexAttributeBinding class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeBinding_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVertexAttributeBinding self) -> SoType"""
        return _coin.SoVertexAttributeBinding_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVertexAttributeBinding_initClass()

    def __init__(self):
        r"""__init__(SoVertexAttributeBinding self) -> SoVertexAttributeBinding"""
        _coin.SoVertexAttributeBinding_swiginit(self, _coin.new_SoVertexAttributeBinding())
    OVERALL = _coin.SoVertexAttributeBinding_OVERALL
    
    PER_VERTEX = _coin.SoVertexAttributeBinding_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoVertexAttributeBinding_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoVertexAttributeBinding_DEFAULT
    
    value = property(_coin.SoVertexAttributeBinding_value_get, _coin.SoVertexAttributeBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVertexAttributeBinding self, SoAction action)"""
        return _coin.SoVertexAttributeBinding_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVertexAttributeBinding self, SoGLRenderAction action)"""
        return _coin.SoVertexAttributeBinding_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVertexAttributeBinding self, SoCallbackAction action)"""
        return _coin.SoVertexAttributeBinding_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVertexAttributeBinding self, SoPickAction action)"""
        return _coin.SoVertexAttributeBinding_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVertexAttributeBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexAttributeBinding_getPrimitiveCount(self, action)

# Register SoVertexAttributeBinding in _coin:
_coin.SoVertexAttributeBinding_swigregister(SoVertexAttributeBinding)

def SoVertexAttributeBinding_getClassTypeId() -> "SoType":
    r"""SoVertexAttributeBinding_getClassTypeId() -> SoType"""
    return _coin.SoVertexAttributeBinding_getClassTypeId()

def SoVertexAttributeBinding_initClass() -> "void":
    r"""SoVertexAttributeBinding_initClass()"""
    return _coin.SoVertexAttributeBinding_initClass()

class SoNormal(SoNode):
    r"""Proxy of C++ SoNormal class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormal_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoNormal self) -> SoType"""
        return _coin.SoNormal_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoNormal_initClass()

    def __init__(self):
        r"""__init__(SoNormal self) -> SoNormal"""
        _coin.SoNormal_swiginit(self, _coin.new_SoNormal())
    vector = property(_coin.SoNormal_vector_get, _coin.SoNormal_vector_set, doc=r"""vector : SoMFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoNormal self, SoAction action)"""
        return _coin.SoNormal_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoNormal self, SoGLRenderAction action)"""
        return _coin.SoNormal_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoNormal self, SoCallbackAction action)"""
        return _coin.SoNormal_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoNormal self, SoPickAction action)"""
        return _coin.SoNormal_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoNormal self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormal_getPrimitiveCount(self, action)

# Register SoNormal in _coin:
_coin.SoNormal_swigregister(SoNormal)

def SoNormal_getClassTypeId() -> "SoType":
    r"""SoNormal_getClassTypeId() -> SoType"""
    return _coin.SoNormal_getClassTypeId()

def SoNormal_initClass() -> "void":
    r"""SoNormal_initClass()"""
    return _coin.SoNormal_initClass()

class SoPackedColor(SoNode):
    r"""Proxy of C++ SoPackedColor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPackedColor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPackedColor self) -> SoType"""
        return _coin.SoPackedColor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPackedColor_initClass()

    def __init__(self):
        r"""__init__(SoPackedColor self) -> SoPackedColor"""
        _coin.SoPackedColor_swiginit(self, _coin.new_SoPackedColor())
    orderedRGBA = property(_coin.SoPackedColor_orderedRGBA_get, _coin.SoPackedColor_orderedRGBA_set, doc=r"""orderedRGBA : SoMFUInt32""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoPackedColor self, SoAction action)"""
        return _coin.SoPackedColor_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoPackedColor self, SoGLRenderAction action)"""
        return _coin.SoPackedColor_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoPackedColor self, SoCallbackAction action)"""
        return _coin.SoPackedColor_callback(self, action)

    def isTransparent(self) -> "SbBool":
        r"""isTransparent(SoPackedColor self) -> SbBool"""
        return _coin.SoPackedColor_isTransparent(self)

# Register SoPackedColor in _coin:
_coin.SoPackedColor_swigregister(SoPackedColor)

def SoPackedColor_getClassTypeId() -> "SoType":
    r"""SoPackedColor_getClassTypeId() -> SoType"""
    return _coin.SoPackedColor_getClassTypeId()

def SoPackedColor_initClass() -> "void":
    r"""SoPackedColor_initClass()"""
    return _coin.SoPackedColor_initClass()

class SoPolygonOffset(SoNode):
    r"""Proxy of C++ SoPolygonOffset class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPolygonOffset_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoPolygonOffset self) -> SoType"""
        return _coin.SoPolygonOffset_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoPolygonOffset_initClass()

    def __init__(self):
        r"""__init__(SoPolygonOffset self) -> SoPolygonOffset"""
        _coin.SoPolygonOffset_swiginit(self, _coin.new_SoPolygonOffset())
    FILLED = _coin.SoPolygonOffset_FILLED
    
    LINES = _coin.SoPolygonOffset_LINES
    
    POINTS = _coin.SoPolygonOffset_POINTS
    
    factor = property(_coin.SoPolygonOffset_factor_get, _coin.SoPolygonOffset_factor_set, doc=r"""factor : SoSFFloat""")
    units = property(_coin.SoPolygonOffset_units_get, _coin.SoPolygonOffset_units_set, doc=r"""units : SoSFFloat""")
    styles = property(_coin.SoPolygonOffset_styles_get, _coin.SoPolygonOffset_styles_set, doc=r"""styles : SoSFBitMask""")
    on = property(_coin.SoPolygonOffset_on_get, _coin.SoPolygonOffset_on_set, doc=r"""on : SoSFBool""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoPolygonOffset self, SoAction action)"""
        return _coin.SoPolygonOffset_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoPolygonOffset self, SoCallbackAction action)"""
        return _coin.SoPolygonOffset_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoPolygonOffset self, SoGLRenderAction action)"""
        return _coin.SoPolygonOffset_GLRender(self, action)

# Register SoPolygonOffset in _coin:
_coin.SoPolygonOffset_swigregister(SoPolygonOffset)

def SoPolygonOffset_getClassTypeId() -> "SoType":
    r"""SoPolygonOffset_getClassTypeId() -> SoType"""
    return _coin.SoPolygonOffset_getClassTypeId()

def SoPolygonOffset_initClass() -> "void":
    r"""SoPolygonOffset_initClass()"""
    return _coin.SoPolygonOffset_initClass()

class SoProfileCoordinate2(SoNode):
    r"""Proxy of C++ SoProfileCoordinate2 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinate2_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoProfileCoordinate2 self) -> SoType"""
        return _coin.SoProfileCoordinate2_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProfileCoordinate2_initClass()

    def __init__(self):
        r"""__init__(SoProfileCoordinate2 self) -> SoProfileCoordinate2"""
        _coin.SoProfileCoordinate2_swiginit(self, _coin.new_SoProfileCoordinate2())
    point = property(_coin.SoProfileCoordinate2_point_get, _coin.SoProfileCoordinate2_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoProfileCoordinate2 self, SoAction action)"""
        return _coin.SoProfileCoordinate2_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoProfileCoordinate2 self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate2_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoProfileCoordinate2 self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate2_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoProfileCoordinate2 self, SoPickAction action)"""
        return _coin.SoProfileCoordinate2_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoProfileCoordinate2 self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate2_getBoundingBox(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoProfileCoordinate2 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate2_getPrimitiveCount(self, action)

# Register SoProfileCoordinate2 in _coin:
_coin.SoProfileCoordinate2_swigregister(SoProfileCoordinate2)

def SoProfileCoordinate2_getClassTypeId() -> "SoType":
    r"""SoProfileCoordinate2_getClassTypeId() -> SoType"""
    return _coin.SoProfileCoordinate2_getClassTypeId()

def SoProfileCoordinate2_initClass() -> "void":
    r"""SoProfileCoordinate2_initClass()"""
    return _coin.SoProfileCoordinate2_initClass()

class SoProfileCoordinate3(SoNode):
    r"""Proxy of C++ SoProfileCoordinate3 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinate3_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoProfileCoordinate3 self) -> SoType"""
        return _coin.SoProfileCoordinate3_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoProfileCoordinate3_initClass()

    def __init__(self):
        r"""__init__(SoProfileCoordinate3 self) -> SoProfileCoordinate3"""
        _coin.SoProfileCoordinate3_swiginit(self, _coin.new_SoProfileCoordinate3())
    point = property(_coin.SoProfileCoordinate3_point_get, _coin.SoProfileCoordinate3_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoProfileCoordinate3 self, SoAction action)"""
        return _coin.SoProfileCoordinate3_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoProfileCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate3_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoProfileCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate3_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoProfileCoordinate3 self, SoPickAction action)"""
        return _coin.SoProfileCoordinate3_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoProfileCoordinate3 self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate3_getBoundingBox(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoProfileCoordinate3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate3_getPrimitiveCount(self, action)

# Register SoProfileCoordinate3 in _coin:
_coin.SoProfileCoordinate3_swigregister(SoProfileCoordinate3)

def SoProfileCoordinate3_getClassTypeId() -> "SoType":
    r"""SoProfileCoordinate3_getClassTypeId() -> SoType"""
    return _coin.SoProfileCoordinate3_getClassTypeId()

def SoProfileCoordinate3_initClass() -> "void":
    r"""SoProfileCoordinate3_initClass()"""
    return _coin.SoProfileCoordinate3_initClass()

class SoTexture3(SoTexture):
    r"""Proxy of C++ SoTexture3 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture3_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTexture3 self) -> SoType"""
        return _coin.SoTexture3_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTexture3_initClass()

    def __init__(self):
        r"""__init__(SoTexture3 self) -> SoTexture3"""
        _coin.SoTexture3_swiginit(self, _coin.new_SoTexture3())
    MODULATE = _coin.SoTexture3_MODULATE
    
    DECAL = _coin.SoTexture3_DECAL
    
    BLEND = _coin.SoTexture3_BLEND
    
    REPEAT = _coin.SoTexture3_REPEAT
    
    CLAMP = _coin.SoTexture3_CLAMP
    
    filenames = property(_coin.SoTexture3_filenames_get, _coin.SoTexture3_filenames_set, doc=r"""filenames : SoMFString""")
    images = property(_coin.SoTexture3_images_get, _coin.SoTexture3_images_set, doc=r"""images : SoSFImage3""")
    wrapR = property(_coin.SoTexture3_wrapR_get, _coin.SoTexture3_wrapR_set, doc=r"""wrapR : SoSFEnum""")
    wrapS = property(_coin.SoTexture3_wrapS_get, _coin.SoTexture3_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoTexture3_wrapT_get, _coin.SoTexture3_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoTexture3_model_get, _coin.SoTexture3_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoTexture3_blendColor_get, _coin.SoTexture3_blendColor_set, doc=r"""blendColor : SoSFColor""")
    enableCompressedTexture = property(_coin.SoTexture3_enableCompressedTexture_get, _coin.SoTexture3_enableCompressedTexture_set, doc=r"""enableCompressedTexture : SoSFBool""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTexture3 self, SoAction action)"""
        return _coin.SoTexture3_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTexture3 self, SoGLRenderAction action)"""
        return _coin.SoTexture3_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTexture3 self, SoCallbackAction action)"""
        return _coin.SoTexture3_callback(self, action)

# Register SoTexture3 in _coin:
_coin.SoTexture3_swigregister(SoTexture3)

def SoTexture3_getClassTypeId() -> "SoType":
    r"""SoTexture3_getClassTypeId() -> SoType"""
    return _coin.SoTexture3_getClassTypeId()

def SoTexture3_initClass() -> "void":
    r"""SoTexture3_initClass()"""
    return _coin.SoTexture3_initClass()

class SoTexture2Transform(SoNode):
    r"""Proxy of C++ SoTexture2Transform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture2Transform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTexture2Transform self) -> SoType"""
        return _coin.SoTexture2Transform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTexture2Transform_initClass()

    def __init__(self):
        r"""__init__(SoTexture2Transform self) -> SoTexture2Transform"""
        _coin.SoTexture2Transform_swiginit(self, _coin.new_SoTexture2Transform())
    translation = property(_coin.SoTexture2Transform_translation_get, _coin.SoTexture2Transform_translation_set, doc=r"""translation : SoSFVec2f""")
    rotation = property(_coin.SoTexture2Transform_rotation_get, _coin.SoTexture2Transform_rotation_set, doc=r"""rotation : SoSFFloat""")
    scaleFactor = property(_coin.SoTexture2Transform_scaleFactor_get, _coin.SoTexture2Transform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec2f""")
    center = property(_coin.SoTexture2Transform_center_get, _coin.SoTexture2Transform_center_set, doc=r"""center : SoSFVec2f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTexture2Transform self, SoAction action)"""
        return _coin.SoTexture2Transform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTexture2Transform self, SoCallbackAction action)"""
        return _coin.SoTexture2Transform_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTexture2Transform self, SoGLRenderAction action)"""
        return _coin.SoTexture2Transform_GLRender(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTexture2Transform self, SoGetMatrixAction action)"""
        return _coin.SoTexture2Transform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTexture2Transform self, SoPickAction action)"""
        return _coin.SoTexture2Transform_pick(self, action)

# Register SoTexture2Transform in _coin:
_coin.SoTexture2Transform_swigregister(SoTexture2Transform)

def SoTexture2Transform_getClassTypeId() -> "SoType":
    r"""SoTexture2Transform_getClassTypeId() -> SoType"""
    return _coin.SoTexture2Transform_getClassTypeId()

def SoTexture2Transform_initClass() -> "void":
    r"""SoTexture2Transform_initClass()"""
    return _coin.SoTexture2Transform_initClass()

class SoTexture3Transform(SoNode):
    r"""Proxy of C++ SoTexture3Transform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture3Transform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTexture3Transform self) -> SoType"""
        return _coin.SoTexture3Transform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTexture3Transform_initClass()

    def __init__(self):
        r"""__init__(SoTexture3Transform self) -> SoTexture3Transform"""
        _coin.SoTexture3Transform_swiginit(self, _coin.new_SoTexture3Transform())
    translation = property(_coin.SoTexture3Transform_translation_get, _coin.SoTexture3Transform_translation_set, doc=r"""translation : SoSFVec3f""")
    rotation = property(_coin.SoTexture3Transform_rotation_get, _coin.SoTexture3Transform_rotation_set, doc=r"""rotation : SoSFRotation""")
    scaleFactor = property(_coin.SoTexture3Transform_scaleFactor_get, _coin.SoTexture3Transform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    scaleOrientation = property(_coin.SoTexture3Transform_scaleOrientation_get, _coin.SoTexture3Transform_scaleOrientation_set, doc=r"""scaleOrientation : SoSFRotation""")
    center = property(_coin.SoTexture3Transform_center_get, _coin.SoTexture3Transform_center_set, doc=r"""center : SoSFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTexture3Transform self, SoAction action)"""
        return _coin.SoTexture3Transform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTexture3Transform self, SoCallbackAction action)"""
        return _coin.SoTexture3Transform_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTexture3Transform self, SoGLRenderAction action)"""
        return _coin.SoTexture3Transform_GLRender(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTexture3Transform self, SoGetMatrixAction action)"""
        return _coin.SoTexture3Transform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTexture3Transform self, SoPickAction action)"""
        return _coin.SoTexture3Transform_pick(self, action)

# Register SoTexture3Transform in _coin:
_coin.SoTexture3Transform_swigregister(SoTexture3Transform)

def SoTexture3Transform_getClassTypeId() -> "SoType":
    r"""SoTexture3Transform_getClassTypeId() -> SoType"""
    return _coin.SoTexture3Transform_getClassTypeId()

def SoTexture3Transform_initClass() -> "void":
    r"""SoTexture3Transform_initClass()"""
    return _coin.SoTexture3Transform_initClass()

class SoTextureCoordinate2(SoNode):
    r"""Proxy of C++ SoTextureCoordinate2 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinate2_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinate2 self) -> SoType"""
        return _coin.SoTextureCoordinate2_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinate2_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinate2 self) -> SoTextureCoordinate2"""
        _coin.SoTextureCoordinate2_swiginit(self, _coin.new_SoTextureCoordinate2())
    point = property(_coin.SoTextureCoordinate2_point_get, _coin.SoTextureCoordinate2_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinate2 self, SoAction action)"""
        return _coin.SoTextureCoordinate2_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinate2 self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate2_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinate2 self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate2_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinate2 self, SoPickAction action)"""
        return _coin.SoTextureCoordinate2_pick(self, action)

# Register SoTextureCoordinate2 in _coin:
_coin.SoTextureCoordinate2_swigregister(SoTextureCoordinate2)

def SoTextureCoordinate2_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinate2_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinate2_getClassTypeId()

def SoTextureCoordinate2_initClass() -> "void":
    r"""SoTextureCoordinate2_initClass()"""
    return _coin.SoTextureCoordinate2_initClass()

class SoTextureCoordinate3(SoNode):
    r"""Proxy of C++ SoTextureCoordinate3 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinate3_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinate3 self) -> SoType"""
        return _coin.SoTextureCoordinate3_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinate3_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinate3 self) -> SoTextureCoordinate3"""
        _coin.SoTextureCoordinate3_swiginit(self, _coin.new_SoTextureCoordinate3())
    point = property(_coin.SoTextureCoordinate3_point_get, _coin.SoTextureCoordinate3_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinate3 self, SoAction action)"""
        return _coin.SoTextureCoordinate3_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate3_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate3_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinate3 self, SoPickAction action)"""
        return _coin.SoTextureCoordinate3_pick(self, action)

# Register SoTextureCoordinate3 in _coin:
_coin.SoTextureCoordinate3_swigregister(SoTextureCoordinate3)

def SoTextureCoordinate3_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinate3_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinate3_getClassTypeId()

def SoTextureCoordinate3_initClass() -> "void":
    r"""SoTextureCoordinate3_initClass()"""
    return _coin.SoTextureCoordinate3_initClass()

class SoTextureCoordinateFunction(SoNode):
    r"""Proxy of C++ SoTextureCoordinateFunction class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateFunction_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateFunction self) -> SoType"""
        return _coin.SoTextureCoordinateFunction_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateFunction_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateFunction self) -> SoTextureCoordinateFunction"""
        _coin.SoTextureCoordinateFunction_swiginit(self, _coin.new_SoTextureCoordinateFunction())

# Register SoTextureCoordinateFunction in _coin:
_coin.SoTextureCoordinateFunction_swigregister(SoTextureCoordinateFunction)

def SoTextureCoordinateFunction_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateFunction_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateFunction_getClassTypeId()

def SoTextureCoordinateFunction_initClass() -> "void":
    r"""SoTextureCoordinateFunction_initClass()"""
    return _coin.SoTextureCoordinateFunction_initClass()

class SoTextureCoordinateDefault(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateDefault class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateDefault_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateDefault self) -> SoType"""
        return _coin.SoTextureCoordinateDefault_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateDefault_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateDefault self) -> SoTextureCoordinateDefault"""
        _coin.SoTextureCoordinateDefault_swiginit(self, _coin.new_SoTextureCoordinateDefault())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateDefault self, SoAction action)"""
        return _coin.SoTextureCoordinateDefault_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateDefault self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateDefault_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateDefault self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateDefault_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateDefault self, SoPickAction action)"""
        return _coin.SoTextureCoordinateDefault_pick(self, action)

# Register SoTextureCoordinateDefault in _coin:
_coin.SoTextureCoordinateDefault_swigregister(SoTextureCoordinateDefault)

def SoTextureCoordinateDefault_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateDefault_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateDefault_getClassTypeId()

def SoTextureCoordinateDefault_initClass() -> "void":
    r"""SoTextureCoordinateDefault_initClass()"""
    return _coin.SoTextureCoordinateDefault_initClass()

class SoTextureCoordinateEnvironment(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateEnvironment class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateEnvironment_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateEnvironment self) -> SoType"""
        return _coin.SoTextureCoordinateEnvironment_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateEnvironment_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateEnvironment self) -> SoTextureCoordinateEnvironment"""
        _coin.SoTextureCoordinateEnvironment_swiginit(self, _coin.new_SoTextureCoordinateEnvironment())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateEnvironment self, SoAction action)"""
        return _coin.SoTextureCoordinateEnvironment_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateEnvironment self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateEnvironment_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateEnvironment self, SoPickAction action)"""
        return _coin.SoTextureCoordinateEnvironment_pick(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateEnvironment self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateEnvironment_callback(self, action)

# Register SoTextureCoordinateEnvironment in _coin:
_coin.SoTextureCoordinateEnvironment_swigregister(SoTextureCoordinateEnvironment)

def SoTextureCoordinateEnvironment_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateEnvironment_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateEnvironment_getClassTypeId()

def SoTextureCoordinateEnvironment_initClass() -> "void":
    r"""SoTextureCoordinateEnvironment_initClass()"""
    return _coin.SoTextureCoordinateEnvironment_initClass()

class SoTextureCoordinatePlane(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinatePlane class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinatePlane_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinatePlane self) -> SoType"""
        return _coin.SoTextureCoordinatePlane_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinatePlane_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinatePlane self) -> SoTextureCoordinatePlane"""
        _coin.SoTextureCoordinatePlane_swiginit(self, _coin.new_SoTextureCoordinatePlane())
    directionS = property(_coin.SoTextureCoordinatePlane_directionS_get, _coin.SoTextureCoordinatePlane_directionS_set, doc=r"""directionS : SoSFVec3f""")
    directionT = property(_coin.SoTextureCoordinatePlane_directionT_get, _coin.SoTextureCoordinatePlane_directionT_set, doc=r"""directionT : SoSFVec3f""")
    directionR = property(_coin.SoTextureCoordinatePlane_directionR_get, _coin.SoTextureCoordinatePlane_directionR_set, doc=r"""directionR : SoSFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinatePlane self, SoAction action)"""
        return _coin.SoTextureCoordinatePlane_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinatePlane self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinatePlane_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinatePlane self, SoPickAction action)"""
        return _coin.SoTextureCoordinatePlane_pick(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinatePlane self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinatePlane_callback(self, action)

# Register SoTextureCoordinatePlane in _coin:
_coin.SoTextureCoordinatePlane_swigregister(SoTextureCoordinatePlane)

def SoTextureCoordinatePlane_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinatePlane_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinatePlane_getClassTypeId()

def SoTextureCoordinatePlane_initClass() -> "void":
    r"""SoTextureCoordinatePlane_initClass()"""
    return _coin.SoTextureCoordinatePlane_initClass()

class SoTextureMatrixTransform(SoNode):
    r"""Proxy of C++ SoTextureMatrixTransform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureMatrixTransform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureMatrixTransform self) -> SoType"""
        return _coin.SoTextureMatrixTransform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureMatrixTransform_initClass()

    def __init__(self):
        r"""__init__(SoTextureMatrixTransform self) -> SoTextureMatrixTransform"""
        _coin.SoTextureMatrixTransform_swiginit(self, _coin.new_SoTextureMatrixTransform())
    matrix = property(_coin.SoTextureMatrixTransform_matrix_get, _coin.SoTextureMatrixTransform_matrix_set, doc=r"""matrix : SoSFMatrix""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureMatrixTransform self, SoAction action)"""
        return _coin.SoTextureMatrixTransform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureMatrixTransform self, SoCallbackAction action)"""
        return _coin.SoTextureMatrixTransform_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureMatrixTransform self, SoGLRenderAction action)"""
        return _coin.SoTextureMatrixTransform_GLRender(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTextureMatrixTransform self, SoGetMatrixAction action)"""
        return _coin.SoTextureMatrixTransform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureMatrixTransform self, SoPickAction action)"""
        return _coin.SoTextureMatrixTransform_pick(self, action)

# Register SoTextureMatrixTransform in _coin:
_coin.SoTextureMatrixTransform_swigregister(SoTextureMatrixTransform)

def SoTextureMatrixTransform_getClassTypeId() -> "SoType":
    r"""SoTextureMatrixTransform_getClassTypeId() -> SoType"""
    return _coin.SoTextureMatrixTransform_getClassTypeId()

def SoTextureMatrixTransform_initClass() -> "void":
    r"""SoTextureMatrixTransform_initClass()"""
    return _coin.SoTextureMatrixTransform_initClass()

class SoWWWInline(SoNode):
    r"""Proxy of C++ SoWWWInline class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWWWInline_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoWWWInline self) -> SoType"""
        return _coin.SoWWWInline_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoWWWInline_initClass()

    def __init__(self):
        r"""__init__(SoWWWInline self) -> SoWWWInline"""
        _coin.SoWWWInline_swiginit(self, _coin.new_SoWWWInline())
    name = property(_coin.SoWWWInline_name_get, _coin.SoWWWInline_name_set, doc=r"""name : SoSFString""")
    bboxCenter = property(_coin.SoWWWInline_bboxCenter_get, _coin.SoWWWInline_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoWWWInline_bboxSize_get, _coin.SoWWWInline_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")
    alternateRep = property(_coin.SoWWWInline_alternateRep_get, _coin.SoWWWInline_alternateRep_set, doc=r"""alternateRep : SoSFNode""")
    NEVER = _coin.SoWWWInline_NEVER
    
    UNTIL_LOADED = _coin.SoWWWInline_UNTIL_LOADED
    
    ALWAYS = _coin.SoWWWInline_ALWAYS
    

    def setFullURLName(self, url: "SbString") -> "void":
        r"""setFullURLName(SoWWWInline self, SbString url)"""
        return _coin.SoWWWInline_setFullURLName(self, url)

    def getFullURLName(self) -> "SbString const &":
        r"""getFullURLName(SoWWWInline self) -> SbString"""
        return _coin.SoWWWInline_getFullURLName(self)

    def copyChildren(self) -> "SoGroup *":
        r"""copyChildren(SoWWWInline self) -> SoGroup"""
        return _coin.SoWWWInline_copyChildren(self)

    def requestURLData(self) -> "void":
        r"""requestURLData(SoWWWInline self)"""
        return _coin.SoWWWInline_requestURLData(self)

    def isURLDataRequested(self) -> "SbBool":
        r"""isURLDataRequested(SoWWWInline self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataRequested(self)

    def isURLDataHere(self) -> "SbBool":
        r"""isURLDataHere(SoWWWInline self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataHere(self)

    def cancelURLDataRequest(self) -> "void":
        r"""cancelURLDataRequest(SoWWWInline self)"""
        return _coin.SoWWWInline_cancelURLDataRequest(self)

    def setChildData(self, urldata: "SoNode") -> "void":
        r"""setChildData(SoWWWInline self, SoNode urldata)"""
        return _coin.SoWWWInline_setChildData(self, urldata)

    def getChildData(self) -> "SoNode *":
        r"""getChildData(SoWWWInline self) -> SoNode"""
        return _coin.SoWWWInline_getChildData(self)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoWWWInline self) -> SoChildList"""
        return _coin.SoWWWInline_getChildren(self)

    @staticmethod
    def setFetchURLCallBack(f: "SoWWWInlineFetchURLCB *", userdata: "void *") -> "void":
        r"""setFetchURLCallBack(SoWWWInlineFetchURLCB * f, void * userdata)"""
        return _coin.SoWWWInline_setFetchURLCallBack(f, userdata)

    @staticmethod
    def setBoundingBoxVisibility(b: "SoWWWInline::BboxVisibility") -> "void":
        r"""setBoundingBoxVisibility(SoWWWInline::BboxVisibility b)"""
        return _coin.SoWWWInline_setBoundingBoxVisibility(b)

    @staticmethod
    def getBoundingBoxVisibility() -> "SoWWWInline::BboxVisibility":
        r"""getBoundingBoxVisibility() -> SoWWWInline::BboxVisibility"""
        return _coin.SoWWWInline_getBoundingBoxVisibility()

    @staticmethod
    def setBoundingBoxColor(c: "SbColor") -> "void":
        r"""setBoundingBoxColor(SbColor c)"""
        return _coin.SoWWWInline_setBoundingBoxColor(c)

    @staticmethod
    def getBoundingBoxColor() -> "SbColor const &":
        r"""getBoundingBoxColor() -> SbColor"""
        return _coin.SoWWWInline_getBoundingBoxColor()

    @staticmethod
    def setReadAsSoFile(onoff: "SbBool") -> "void":
        r"""setReadAsSoFile(SbBool onoff)"""
        return _coin.SoWWWInline_setReadAsSoFile(onoff)

    @staticmethod
    def getReadAsSoFile() -> "SbBool":
        r"""getReadAsSoFile() -> SbBool"""
        return _coin.SoWWWInline_getReadAsSoFile()

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoWWWInline self, SoAction action)"""
        return _coin.SoWWWInline_doAction(self, action)

    def doActionOnKidsOrBox(self, action: "SoAction") -> "void":
        r"""doActionOnKidsOrBox(SoWWWInline self, SoAction action)"""
        return _coin.SoWWWInline_doActionOnKidsOrBox(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoWWWInline self, SoCallbackAction action)"""
        return _coin.SoWWWInline_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoWWWInline self, SoGLRenderAction action)"""
        return _coin.SoWWWInline_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoWWWInline self, SoGetBoundingBoxAction action)"""
        return _coin.SoWWWInline_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoWWWInline self, SoGetMatrixAction action)"""
        return _coin.SoWWWInline_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoWWWInline self, SoHandleEventAction action)"""
        return _coin.SoWWWInline_handleEvent(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoWWWInline self, SoSearchAction action)"""
        return _coin.SoWWWInline_search(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoWWWInline self, SoPickAction action)"""
        return _coin.SoWWWInline_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoWWWInline self, SoGetPrimitiveCountAction action)"""
        return _coin.SoWWWInline_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoWWWInline self, SoAudioRenderAction action)"""
        return _coin.SoWWWInline_audioRender(self, action)

# Register SoWWWInline in _coin:
_coin.SoWWWInline_swigregister(SoWWWInline)

def SoWWWInline_getClassTypeId() -> "SoType":
    r"""SoWWWInline_getClassTypeId() -> SoType"""
    return _coin.SoWWWInline_getClassTypeId()

def SoWWWInline_initClass() -> "void":
    r"""SoWWWInline_initClass()"""
    return _coin.SoWWWInline_initClass()

def SoWWWInline_setFetchURLCallBack(f: "SoWWWInlineFetchURLCB *", userdata: "void *") -> "void":
    r"""SoWWWInline_setFetchURLCallBack(SoWWWInlineFetchURLCB * f, void * userdata)"""
    return _coin.SoWWWInline_setFetchURLCallBack(f, userdata)

def SoWWWInline_setBoundingBoxVisibility(b: "SoWWWInline::BboxVisibility") -> "void":
    r"""SoWWWInline_setBoundingBoxVisibility(SoWWWInline::BboxVisibility b)"""
    return _coin.SoWWWInline_setBoundingBoxVisibility(b)

def SoWWWInline_getBoundingBoxVisibility() -> "SoWWWInline::BboxVisibility":
    r"""SoWWWInline_getBoundingBoxVisibility() -> SoWWWInline::BboxVisibility"""
    return _coin.SoWWWInline_getBoundingBoxVisibility()

def SoWWWInline_setBoundingBoxColor(c: "SbColor") -> "void":
    r"""SoWWWInline_setBoundingBoxColor(SbColor c)"""
    return _coin.SoWWWInline_setBoundingBoxColor(c)

def SoWWWInline_getBoundingBoxColor() -> "SbColor const &":
    r"""SoWWWInline_getBoundingBoxColor() -> SbColor"""
    return _coin.SoWWWInline_getBoundingBoxColor()

def SoWWWInline_setReadAsSoFile(onoff: "SbBool") -> "void":
    r"""SoWWWInline_setReadAsSoFile(SbBool onoff)"""
    return _coin.SoWWWInline_setReadAsSoFile(onoff)

def SoWWWInline_getReadAsSoFile() -> "SbBool":
    r"""SoWWWInline_getReadAsSoFile() -> SbBool"""
    return _coin.SoWWWInline_getReadAsSoFile()

class SoTransparencyType(SoNode):
    r"""Proxy of C++ SoTransparencyType class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransparencyType_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTransparencyType self) -> SoType"""
        return _coin.SoTransparencyType_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTransparencyType_initClass()

    def __init__(self):
        r"""__init__(SoTransparencyType self) -> SoTransparencyType"""
        _coin.SoTransparencyType_swiginit(self, _coin.new_SoTransparencyType())
    SCREEN_DOOR = _coin.SoTransparencyType_SCREEN_DOOR
    
    ADD = _coin.SoTransparencyType_ADD
    
    DELAYED_ADD = _coin.SoTransparencyType_DELAYED_ADD
    
    SORTED_OBJECT_ADD = _coin.SoTransparencyType_SORTED_OBJECT_ADD
    
    BLEND = _coin.SoTransparencyType_BLEND
    
    DELAYED_BLEND = _coin.SoTransparencyType_DELAYED_BLEND
    
    SORTED_OBJECT_BLEND = _coin.SoTransparencyType_SORTED_OBJECT_BLEND
    
    SORTED_OBJECT_SORTED_TRIANGLE_ADD = _coin.SoTransparencyType_SORTED_OBJECT_SORTED_TRIANGLE_ADD
    
    SORTED_OBJECT_SORTED_TRIANGLE_BLEND = _coin.SoTransparencyType_SORTED_OBJECT_SORTED_TRIANGLE_BLEND
    
    NONE = _coin.SoTransparencyType_NONE
    
    value = property(_coin.SoTransparencyType_value_get, _coin.SoTransparencyType_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTransparencyType self, SoAction action)"""
        return _coin.SoTransparencyType_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTransparencyType self, SoGLRenderAction action)"""
        return _coin.SoTransparencyType_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTransparencyType self, SoCallbackAction action)"""
        return _coin.SoTransparencyType_callback(self, action)

# Register SoTransparencyType in _coin:
_coin.SoTransparencyType_swigregister(SoTransparencyType)

def SoTransparencyType_getClassTypeId() -> "SoType":
    r"""SoTransparencyType_getClassTypeId() -> SoType"""
    return _coin.SoTransparencyType_getClassTypeId()

def SoTransparencyType_initClass() -> "void":
    r"""SoTransparencyType_initClass()"""
    return _coin.SoTransparencyType_initClass()

class SoTextureCoordinateCube(SoNode):
    r"""Proxy of C++ SoTextureCoordinateCube class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateCube_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateCube self) -> SoType"""
        return _coin.SoTextureCoordinateCube_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateCube_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateCube self) -> SoTextureCoordinateCube"""
        _coin.SoTextureCoordinateCube_swiginit(self, _coin.new_SoTextureCoordinateCube())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateCube self, SoAction action)"""
        return _coin.SoTextureCoordinateCube_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateCube self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCube_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateCube self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCube_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateCube self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCube_pick(self, action)

# Register SoTextureCoordinateCube in _coin:
_coin.SoTextureCoordinateCube_swigregister(SoTextureCoordinateCube)

def SoTextureCoordinateCube_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateCube_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateCube_getClassTypeId()

def SoTextureCoordinateCube_initClass() -> "void":
    r"""SoTextureCoordinateCube_initClass()"""
    return _coin.SoTextureCoordinateCube_initClass()

class SoTextureCoordinateSphere(SoNode):
    r"""Proxy of C++ SoTextureCoordinateSphere class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateSphere_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateSphere self) -> SoType"""
        return _coin.SoTextureCoordinateSphere_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateSphere_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateSphere self) -> SoTextureCoordinateSphere"""
        _coin.SoTextureCoordinateSphere_swiginit(self, _coin.new_SoTextureCoordinateSphere())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateSphere self, SoAction action)"""
        return _coin.SoTextureCoordinateSphere_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateSphere self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateSphere_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateSphere self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateSphere_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateSphere self, SoPickAction action)"""
        return _coin.SoTextureCoordinateSphere_pick(self, action)

# Register SoTextureCoordinateSphere in _coin:
_coin.SoTextureCoordinateSphere_swigregister(SoTextureCoordinateSphere)

def SoTextureCoordinateSphere_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateSphere_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateSphere_getClassTypeId()

def SoTextureCoordinateSphere_initClass() -> "void":
    r"""SoTextureCoordinateSphere_initClass()"""
    return _coin.SoTextureCoordinateSphere_initClass()

class SoTextureCoordinateCylinder(SoNode):
    r"""Proxy of C++ SoTextureCoordinateCylinder class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateCylinder_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateCylinder self) -> SoType"""
        return _coin.SoTextureCoordinateCylinder_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateCylinder_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateCylinder self) -> SoTextureCoordinateCylinder"""
        _coin.SoTextureCoordinateCylinder_swiginit(self, _coin.new_SoTextureCoordinateCylinder())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateCylinder self, SoAction action)"""
        return _coin.SoTextureCoordinateCylinder_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateCylinder self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCylinder_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateCylinder self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCylinder_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateCylinder self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCylinder_pick(self, action)

# Register SoTextureCoordinateCylinder in _coin:
_coin.SoTextureCoordinateCylinder_swigregister(SoTextureCoordinateCylinder)

def SoTextureCoordinateCylinder_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateCylinder_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateCylinder_getClassTypeId()

def SoTextureCoordinateCylinder_initClass() -> "void":
    r"""SoTextureCoordinateCylinder_initClass()"""
    return _coin.SoTextureCoordinateCylinder_initClass()

class SoTextureCubeMap(SoTexture):
    r"""Proxy of C++ SoTextureCubeMap class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCubeMap_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCubeMap self) -> SoType"""
        return _coin.SoTextureCubeMap_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCubeMap_initClass()

    def __init__(self):
        r"""__init__(SoTextureCubeMap self) -> SoTextureCubeMap"""
        _coin.SoTextureCubeMap_swiginit(self, _coin.new_SoTextureCubeMap())
    MODULATE = _coin.SoTextureCubeMap_MODULATE
    
    DECAL = _coin.SoTextureCubeMap_DECAL
    
    BLEND = _coin.SoTextureCubeMap_BLEND
    
    REPLACE = _coin.SoTextureCubeMap_REPLACE
    
    REPEAT = _coin.SoTextureCubeMap_REPEAT
    
    CLAMP = _coin.SoTextureCubeMap_CLAMP
    
    filenames = property(_coin.SoTextureCubeMap_filenames_get, _coin.SoTextureCubeMap_filenames_set, doc=r"""filenames : SoMFString""")
    imagePosX = property(_coin.SoTextureCubeMap_imagePosX_get, _coin.SoTextureCubeMap_imagePosX_set, doc=r"""imagePosX : SoSFImage""")
    imageNegX = property(_coin.SoTextureCubeMap_imageNegX_get, _coin.SoTextureCubeMap_imageNegX_set, doc=r"""imageNegX : SoSFImage""")
    imagePosY = property(_coin.SoTextureCubeMap_imagePosY_get, _coin.SoTextureCubeMap_imagePosY_set, doc=r"""imagePosY : SoSFImage""")
    imageNegY = property(_coin.SoTextureCubeMap_imageNegY_get, _coin.SoTextureCubeMap_imageNegY_set, doc=r"""imageNegY : SoSFImage""")
    imagePosZ = property(_coin.SoTextureCubeMap_imagePosZ_get, _coin.SoTextureCubeMap_imagePosZ_set, doc=r"""imagePosZ : SoSFImage""")
    imageNegZ = property(_coin.SoTextureCubeMap_imageNegZ_get, _coin.SoTextureCubeMap_imageNegZ_set, doc=r"""imageNegZ : SoSFImage""")
    wrapS = property(_coin.SoTextureCubeMap_wrapS_get, _coin.SoTextureCubeMap_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoTextureCubeMap_wrapT_get, _coin.SoTextureCubeMap_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoTextureCubeMap_model_get, _coin.SoTextureCubeMap_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoTextureCubeMap_blendColor_get, _coin.SoTextureCubeMap_blendColor_set, doc=r"""blendColor : SoSFColor""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCubeMap self, SoAction action)"""
        return _coin.SoTextureCubeMap_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCubeMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCubeMap_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCubeMap self, SoCallbackAction action)"""
        return _coin.SoTextureCubeMap_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoTextureCubeMap self, SoRayPickAction action)"""
        return _coin.SoTextureCubeMap_rayPick(self, action)

    @staticmethod
    def readImage(fname: "SbString", w: "int &", h: "int &", nc: "int &", bytes: "unsigned char *&") -> "SbBool":
        r"""readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
        return _coin.SoTextureCubeMap_readImage(fname, w, h, nc, bytes)

# Register SoTextureCubeMap in _coin:
_coin.SoTextureCubeMap_swigregister(SoTextureCubeMap)

def SoTextureCubeMap_getClassTypeId() -> "SoType":
    r"""SoTextureCubeMap_getClassTypeId() -> SoType"""
    return _coin.SoTextureCubeMap_getClassTypeId()

def SoTextureCubeMap_initClass() -> "void":
    r"""SoTextureCubeMap_initClass()"""
    return _coin.SoTextureCubeMap_initClass()

def SoTextureCubeMap_readImage(fname: "SbString", w: "int &", h: "int &", nc: "int &", bytes: "unsigned char *&") -> "SbBool":
    r"""SoTextureCubeMap_readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
    return _coin.SoTextureCubeMap_readImage(fname, w, h, nc, bytes)

class SoShaderObject(SoNode):
    r"""Proxy of C++ SoShaderObject class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderObject_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderObject self) -> SoType"""
        return _coin.SoShaderObject_getTypeId(self)
    ARB_PROGRAM = _coin.SoShaderObject_ARB_PROGRAM
    
    CG_PROGRAM = _coin.SoShaderObject_CG_PROGRAM
    
    GLSL_PROGRAM = _coin.SoShaderObject_GLSL_PROGRAM
    
    FILENAME = _coin.SoShaderObject_FILENAME
    
    isActive = property(_coin.SoShaderObject_isActive_get, _coin.SoShaderObject_isActive_set, doc=r"""isActive : SoSFBool""")
    sourceType = property(_coin.SoShaderObject_sourceType_get, _coin.SoShaderObject_sourceType_set, doc=r"""sourceType : SoSFEnum""")
    sourceProgram = property(_coin.SoShaderObject_sourceProgram_get, _coin.SoShaderObject_sourceProgram_set, doc=r"""sourceProgram : SoSFString""")
    parameter = property(_coin.SoShaderObject_parameter_get, _coin.SoShaderObject_parameter_set, doc=r"""parameter : SoMFNode""")

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderObject_initClass()

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoShaderObject self, SoGLRenderAction action)"""
        return _coin.SoShaderObject_GLRender(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoShaderObject self, SoSearchAction action)"""
        return _coin.SoShaderObject_search(self, action)

    def updateParameters(self, state: "SoState") -> "void":
        r"""updateParameters(SoShaderObject self, SoState state)"""
        return _coin.SoShaderObject_updateParameters(self, state)

    def getSourceType(self) -> "SoShaderObject::SourceType":
        r"""getSourceType(SoShaderObject self) -> SoShaderObject::SourceType"""
        return _coin.SoShaderObject_getSourceType(self)

    def getSourceProgram(self) -> "SbString":
        r"""getSourceProgram(SoShaderObject self) -> SbString"""
        return _coin.SoShaderObject_getSourceProgram(self)

# Register SoShaderObject in _coin:
_coin.SoShaderObject_swigregister(SoShaderObject)

def SoShaderObject_getClassTypeId() -> "SoType":
    r"""SoShaderObject_getClassTypeId() -> SoType"""
    return _coin.SoShaderObject_getClassTypeId()

def SoShaderObject_initClass() -> "void":
    r"""SoShaderObject_initClass()"""
    return _coin.SoShaderObject_initClass()

class SoShaderParameter(SoNode):
    r"""Proxy of C++ SoShaderParameter class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter self) -> SoType"""
        return _coin.SoShaderParameter_getTypeId(self)
    name = property(_coin.SoShaderParameter_name_get, _coin.SoShaderParameter_name_set, doc=r"""name : SoSFString""")
    identifier = property(_coin.SoShaderParameter_identifier_get, _coin.SoShaderParameter_identifier_set, doc=r"""identifier : SoSFInt32""")

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter_initClass()

# Register SoShaderParameter in _coin:
_coin.SoShaderParameter_swigregister(SoShaderParameter)

def SoShaderParameter_getClassTypeId() -> "SoType":
    r"""SoShaderParameter_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter_getClassTypeId()

def SoShaderParameter_initClass() -> "void":
    r"""SoShaderParameter_initClass()"""
    return _coin.SoShaderParameter_initClass()

class SoUniformShaderParameter(SoShaderParameter):
    r"""Proxy of C++ SoUniformShaderParameter class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoUniformShaderParameter_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoUniformShaderParameter self) -> SoType"""
        return _coin.SoUniformShaderParameter_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoUniformShaderParameter_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoUniformShaderParameter self, SoGLShaderObject * shaderObject)"""
        return _coin.SoUniformShaderParameter_updateParameter(self, shaderObject)

# Register SoUniformShaderParameter in _coin:
_coin.SoUniformShaderParameter_swigregister(SoUniformShaderParameter)

def SoUniformShaderParameter_getClassTypeId() -> "SoType":
    r"""SoUniformShaderParameter_getClassTypeId() -> SoType"""
    return _coin.SoUniformShaderParameter_getClassTypeId()

def SoUniformShaderParameter_initClass() -> "void":
    r"""SoUniformShaderParameter_initClass()"""
    return _coin.SoUniformShaderParameter_initClass()

class SoShaderParameter1f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter1f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter1f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter1f self) -> SoType"""
        return _coin.SoShaderParameter1f_getTypeId(self)
    value = property(_coin.SoShaderParameter1f_value_get, _coin.SoShaderParameter1f_value_set, doc=r"""value : SoSFFloat""")

    def __init__(self):
        r"""__init__(SoShaderParameter1f self) -> SoShaderParameter1f"""
        _coin.SoShaderParameter1f_swiginit(self, _coin.new_SoShaderParameter1f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter1f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter1f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter1f_updateParameter(self, shaderObject)

# Register SoShaderParameter1f in _coin:
_coin.SoShaderParameter1f_swigregister(SoShaderParameter1f)

def SoShaderParameter1f_getClassTypeId() -> "SoType":
    r"""SoShaderParameter1f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter1f_getClassTypeId()

def SoShaderParameter1f_initClass() -> "void":
    r"""SoShaderParameter1f_initClass()"""
    return _coin.SoShaderParameter1f_initClass()

class SoShaderParameter1i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter1i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter1i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter1i self) -> SoType"""
        return _coin.SoShaderParameter1i_getTypeId(self)
    value = property(_coin.SoShaderParameter1i_value_get, _coin.SoShaderParameter1i_value_set, doc=r"""value : SoSFInt32""")

    def __init__(self):
        r"""__init__(SoShaderParameter1i self) -> SoShaderParameter1i"""
        _coin.SoShaderParameter1i_swiginit(self, _coin.new_SoShaderParameter1i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter1i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter1i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter1i_updateParameter(self, shaderObject)

# Register SoShaderParameter1i in _coin:
_coin.SoShaderParameter1i_swigregister(SoShaderParameter1i)

def SoShaderParameter1i_getClassTypeId() -> "SoType":
    r"""SoShaderParameter1i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter1i_getClassTypeId()

def SoShaderParameter1i_initClass() -> "void":
    r"""SoShaderParameter1i_initClass()"""
    return _coin.SoShaderParameter1i_initClass()

class SoShaderParameter2f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter2f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter2f self) -> SoType"""
        return _coin.SoShaderParameter2f_getTypeId(self)
    value = property(_coin.SoShaderParameter2f_value_get, _coin.SoShaderParameter2f_value_set, doc=r"""value : SoSFVec2f""")

    def __init__(self):
        r"""__init__(SoShaderParameter2f self) -> SoShaderParameter2f"""
        _coin.SoShaderParameter2f_swiginit(self, _coin.new_SoShaderParameter2f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter2f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter2f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter2f_updateParameter(self, shaderObject)

# Register SoShaderParameter2f in _coin:
_coin.SoShaderParameter2f_swigregister(SoShaderParameter2f)

def SoShaderParameter2f_getClassTypeId() -> "SoType":
    r"""SoShaderParameter2f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter2f_getClassTypeId()

def SoShaderParameter2f_initClass() -> "void":
    r"""SoShaderParameter2f_initClass()"""
    return _coin.SoShaderParameter2f_initClass()

class SoShaderParameter2i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter2i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter2i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter2i self) -> SoType"""
        return _coin.SoShaderParameter2i_getTypeId(self)
    value = property(_coin.SoShaderParameter2i_value_get, _coin.SoShaderParameter2i_value_set, doc=r"""value : SoSFVec2i32""")

    def __init__(self):
        r"""__init__(SoShaderParameter2i self) -> SoShaderParameter2i"""
        _coin.SoShaderParameter2i_swiginit(self, _coin.new_SoShaderParameter2i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter2i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter2i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter2i_updateParameter(self, shaderObject)

# Register SoShaderParameter2i in _coin:
_coin.SoShaderParameter2i_swigregister(SoShaderParameter2i)

def SoShaderParameter2i_getClassTypeId() -> "SoType":
    r"""SoShaderParameter2i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter2i_getClassTypeId()

def SoShaderParameter2i_initClass() -> "void":
    r"""SoShaderParameter2i_initClass()"""
    return _coin.SoShaderParameter2i_initClass()

class SoShaderParameter3f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter3f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter3f self) -> SoType"""
        return _coin.SoShaderParameter3f_getTypeId(self)
    value = property(_coin.SoShaderParameter3f_value_get, _coin.SoShaderParameter3f_value_set, doc=r"""value : SoSFVec3f""")

    def __init__(self):
        r"""__init__(SoShaderParameter3f self) -> SoShaderParameter3f"""
        _coin.SoShaderParameter3f_swiginit(self, _coin.new_SoShaderParameter3f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter3f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter3f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter3f_updateParameter(self, shaderObject)

# Register SoShaderParameter3f in _coin:
_coin.SoShaderParameter3f_swigregister(SoShaderParameter3f)

def SoShaderParameter3f_getClassTypeId() -> "SoType":
    r"""SoShaderParameter3f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter3f_getClassTypeId()

def SoShaderParameter3f_initClass() -> "void":
    r"""SoShaderParameter3f_initClass()"""
    return _coin.SoShaderParameter3f_initClass()

class SoShaderParameter3i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter3i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter3i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter3i self) -> SoType"""
        return _coin.SoShaderParameter3i_getTypeId(self)
    value = property(_coin.SoShaderParameter3i_value_get, _coin.SoShaderParameter3i_value_set, doc=r"""value : SoSFVec3i32""")

    def __init__(self):
        r"""__init__(SoShaderParameter3i self) -> SoShaderParameter3i"""
        _coin.SoShaderParameter3i_swiginit(self, _coin.new_SoShaderParameter3i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter3i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter3i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter3i_updateParameter(self, shaderObject)

# Register SoShaderParameter3i in _coin:
_coin.SoShaderParameter3i_swigregister(SoShaderParameter3i)

def SoShaderParameter3i_getClassTypeId() -> "SoType":
    r"""SoShaderParameter3i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter3i_getClassTypeId()

def SoShaderParameter3i_initClass() -> "void":
    r"""SoShaderParameter3i_initClass()"""
    return _coin.SoShaderParameter3i_initClass()

class SoShaderParameter4f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter4f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter4f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter4f self) -> SoType"""
        return _coin.SoShaderParameter4f_getTypeId(self)
    value = property(_coin.SoShaderParameter4f_value_get, _coin.SoShaderParameter4f_value_set, doc=r"""value : SoSFVec4f""")

    def __init__(self):
        r"""__init__(SoShaderParameter4f self) -> SoShaderParameter4f"""
        _coin.SoShaderParameter4f_swiginit(self, _coin.new_SoShaderParameter4f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter4f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter4f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter4f_updateParameter(self, shaderObject)

# Register SoShaderParameter4f in _coin:
_coin.SoShaderParameter4f_swigregister(SoShaderParameter4f)

def SoShaderParameter4f_getClassTypeId() -> "SoType":
    r"""SoShaderParameter4f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter4f_getClassTypeId()

def SoShaderParameter4f_initClass() -> "void":
    r"""SoShaderParameter4f_initClass()"""
    return _coin.SoShaderParameter4f_initClass()

class SoShaderParameter4i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter4i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter4i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameter4i self) -> SoType"""
        return _coin.SoShaderParameter4i_getTypeId(self)
    value = property(_coin.SoShaderParameter4i_value_get, _coin.SoShaderParameter4i_value_set, doc=r"""value : SoSFVec4i32""")

    def __init__(self):
        r"""__init__(SoShaderParameter4i self) -> SoShaderParameter4i"""
        _coin.SoShaderParameter4i_swiginit(self, _coin.new_SoShaderParameter4i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameter4i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameter4i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter4i_updateParameter(self, shaderObject)

# Register SoShaderParameter4i in _coin:
_coin.SoShaderParameter4i_swigregister(SoShaderParameter4i)

def SoShaderParameter4i_getClassTypeId() -> "SoType":
    r"""SoShaderParameter4i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameter4i_getClassTypeId()

def SoShaderParameter4i_initClass() -> "void":
    r"""SoShaderParameter4i_initClass()"""
    return _coin.SoShaderParameter4i_initClass()

class SoShaderParameterArray1f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray1f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray1f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray1f self) -> SoType"""
        return _coin.SoShaderParameterArray1f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray1f_value_get, _coin.SoShaderParameterArray1f_value_set, doc=r"""value : SoMFFloat""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray1f self) -> SoShaderParameterArray1f"""
        _coin.SoShaderParameterArray1f_swiginit(self, _coin.new_SoShaderParameterArray1f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray1f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray1f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray1f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray1f in _coin:
_coin.SoShaderParameterArray1f_swigregister(SoShaderParameterArray1f)

def SoShaderParameterArray1f_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray1f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray1f_getClassTypeId()

def SoShaderParameterArray1f_initClass() -> "void":
    r"""SoShaderParameterArray1f_initClass()"""
    return _coin.SoShaderParameterArray1f_initClass()

class SoShaderParameterArray1i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray1i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray1i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray1i self) -> SoType"""
        return _coin.SoShaderParameterArray1i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray1i_value_get, _coin.SoShaderParameterArray1i_value_set, doc=r"""value : SoMFInt32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray1i self) -> SoShaderParameterArray1i"""
        _coin.SoShaderParameterArray1i_swiginit(self, _coin.new_SoShaderParameterArray1i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray1i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray1i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray1i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray1i in _coin:
_coin.SoShaderParameterArray1i_swigregister(SoShaderParameterArray1i)

def SoShaderParameterArray1i_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray1i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray1i_getClassTypeId()

def SoShaderParameterArray1i_initClass() -> "void":
    r"""SoShaderParameterArray1i_initClass()"""
    return _coin.SoShaderParameterArray1i_initClass()

class SoShaderParameterArray2f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray2f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray2f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray2f self) -> SoType"""
        return _coin.SoShaderParameterArray2f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray2f_value_get, _coin.SoShaderParameterArray2f_value_set, doc=r"""value : SoMFVec2f""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray2f self) -> SoShaderParameterArray2f"""
        _coin.SoShaderParameterArray2f_swiginit(self, _coin.new_SoShaderParameterArray2f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray2f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray2f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray2f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray2f in _coin:
_coin.SoShaderParameterArray2f_swigregister(SoShaderParameterArray2f)

def SoShaderParameterArray2f_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray2f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray2f_getClassTypeId()

def SoShaderParameterArray2f_initClass() -> "void":
    r"""SoShaderParameterArray2f_initClass()"""
    return _coin.SoShaderParameterArray2f_initClass()

class SoShaderParameterArray2i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray2i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray2i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray2i self) -> SoType"""
        return _coin.SoShaderParameterArray2i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray2i_value_get, _coin.SoShaderParameterArray2i_value_set, doc=r"""value : SoMFVec2i32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray2i self) -> SoShaderParameterArray2i"""
        _coin.SoShaderParameterArray2i_swiginit(self, _coin.new_SoShaderParameterArray2i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray2i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray2i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray2i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray2i in _coin:
_coin.SoShaderParameterArray2i_swigregister(SoShaderParameterArray2i)

def SoShaderParameterArray2i_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray2i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray2i_getClassTypeId()

def SoShaderParameterArray2i_initClass() -> "void":
    r"""SoShaderParameterArray2i_initClass()"""
    return _coin.SoShaderParameterArray2i_initClass()

class SoShaderParameterArray3f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray3f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray3f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray3f self) -> SoType"""
        return _coin.SoShaderParameterArray3f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray3f_value_get, _coin.SoShaderParameterArray3f_value_set, doc=r"""value : SoMFVec3f""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray3f self) -> SoShaderParameterArray3f"""
        _coin.SoShaderParameterArray3f_swiginit(self, _coin.new_SoShaderParameterArray3f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray3f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray3f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray3f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray3f in _coin:
_coin.SoShaderParameterArray3f_swigregister(SoShaderParameterArray3f)

def SoShaderParameterArray3f_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray3f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray3f_getClassTypeId()

def SoShaderParameterArray3f_initClass() -> "void":
    r"""SoShaderParameterArray3f_initClass()"""
    return _coin.SoShaderParameterArray3f_initClass()

class SoShaderParameterArray3i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray3i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray3i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray3i self) -> SoType"""
        return _coin.SoShaderParameterArray3i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray3i_value_get, _coin.SoShaderParameterArray3i_value_set, doc=r"""value : SoMFVec3i32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray3i self) -> SoShaderParameterArray3i"""
        _coin.SoShaderParameterArray3i_swiginit(self, _coin.new_SoShaderParameterArray3i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray3i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray3i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray3i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray3i in _coin:
_coin.SoShaderParameterArray3i_swigregister(SoShaderParameterArray3i)

def SoShaderParameterArray3i_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray3i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray3i_getClassTypeId()

def SoShaderParameterArray3i_initClass() -> "void":
    r"""SoShaderParameterArray3i_initClass()"""
    return _coin.SoShaderParameterArray3i_initClass()

class SoShaderParameterArray4f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray4f class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray4f_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray4f self) -> SoType"""
        return _coin.SoShaderParameterArray4f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray4f_value_get, _coin.SoShaderParameterArray4f_value_set, doc=r"""value : SoMFVec4f""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray4f self) -> SoShaderParameterArray4f"""
        _coin.SoShaderParameterArray4f_swiginit(self, _coin.new_SoShaderParameterArray4f())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray4f_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray4f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray4f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray4f in _coin:
_coin.SoShaderParameterArray4f_swigregister(SoShaderParameterArray4f)

def SoShaderParameterArray4f_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray4f_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray4f_getClassTypeId()

def SoShaderParameterArray4f_initClass() -> "void":
    r"""SoShaderParameterArray4f_initClass()"""
    return _coin.SoShaderParameterArray4f_initClass()

class SoShaderParameterArray4i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray4i class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray4i_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterArray4i self) -> SoType"""
        return _coin.SoShaderParameterArray4i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray4i_value_get, _coin.SoShaderParameterArray4i_value_set, doc=r"""value : SoMFVec4i32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray4i self) -> SoShaderParameterArray4i"""
        _coin.SoShaderParameterArray4i_swiginit(self, _coin.new_SoShaderParameterArray4i())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterArray4i_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterArray4i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray4i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray4i in _coin:
_coin.SoShaderParameterArray4i_swigregister(SoShaderParameterArray4i)

def SoShaderParameterArray4i_getClassTypeId() -> "SoType":
    r"""SoShaderParameterArray4i_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterArray4i_getClassTypeId()

def SoShaderParameterArray4i_initClass() -> "void":
    r"""SoShaderParameterArray4i_initClass()"""
    return _coin.SoShaderParameterArray4i_initClass()

class SoShaderParameterMatrix(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterMatrix class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterMatrix_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterMatrix self) -> SoType"""
        return _coin.SoShaderParameterMatrix_getTypeId(self)
    value = property(_coin.SoShaderParameterMatrix_value_get, _coin.SoShaderParameterMatrix_value_set, doc=r"""value : SoSFMatrix""")

    def __init__(self):
        r"""__init__(SoShaderParameterMatrix self) -> SoShaderParameterMatrix"""
        _coin.SoShaderParameterMatrix_swiginit(self, _coin.new_SoShaderParameterMatrix())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterMatrix_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterMatrix self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterMatrix_updateParameter(self, shaderObject)

# Register SoShaderParameterMatrix in _coin:
_coin.SoShaderParameterMatrix_swigregister(SoShaderParameterMatrix)

def SoShaderParameterMatrix_getClassTypeId() -> "SoType":
    r"""SoShaderParameterMatrix_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterMatrix_getClassTypeId()

def SoShaderParameterMatrix_initClass() -> "void":
    r"""SoShaderParameterMatrix_initClass()"""
    return _coin.SoShaderParameterMatrix_initClass()

class SoShaderParameterMatrixArray(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterMatrixArray class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterMatrixArray_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderParameterMatrixArray self) -> SoType"""
        return _coin.SoShaderParameterMatrixArray_getTypeId(self)
    value = property(_coin.SoShaderParameterMatrixArray_value_get, _coin.SoShaderParameterMatrixArray_value_set, doc=r"""value : SoMFMatrix""")

    def __init__(self):
        r"""__init__(SoShaderParameterMatrixArray self) -> SoShaderParameterMatrixArray"""
        _coin.SoShaderParameterMatrixArray_swiginit(self, _coin.new_SoShaderParameterMatrixArray())

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderParameterMatrixArray_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderParameterMatrixArray self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterMatrixArray_updateParameter(self, shaderObject)

# Register SoShaderParameterMatrixArray in _coin:
_coin.SoShaderParameterMatrixArray_swigregister(SoShaderParameterMatrixArray)

def SoShaderParameterMatrixArray_getClassTypeId() -> "SoType":
    r"""SoShaderParameterMatrixArray_getClassTypeId() -> SoType"""
    return _coin.SoShaderParameterMatrixArray_getClassTypeId()

def SoShaderParameterMatrixArray_initClass() -> "void":
    r"""SoShaderParameterMatrixArray_initClass()"""
    return _coin.SoShaderParameterMatrixArray_initClass()

class SoShaderStateMatrixParameter(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderStateMatrixParameter class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderStateMatrixParameter_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderStateMatrixParameter self) -> SoType"""
        return _coin.SoShaderStateMatrixParameter_getTypeId(self)
    MODELVIEW = _coin.SoShaderStateMatrixParameter_MODELVIEW
    
    PROJECTION = _coin.SoShaderStateMatrixParameter_PROJECTION
    
    TEXTURE = _coin.SoShaderStateMatrixParameter_TEXTURE
    
    MODELVIEW_PROJECTION = _coin.SoShaderStateMatrixParameter_MODELVIEW_PROJECTION
    
    IDENTITY = _coin.SoShaderStateMatrixParameter_IDENTITY
    
    TRANSPOSE = _coin.SoShaderStateMatrixParameter_TRANSPOSE
    
    INVERSE = _coin.SoShaderStateMatrixParameter_INVERSE
    
    INVERSE_TRANSPOSE = _coin.SoShaderStateMatrixParameter_INVERSE_TRANSPOSE
    
    matrixType = property(_coin.SoShaderStateMatrixParameter_matrixType_get, _coin.SoShaderStateMatrixParameter_matrixType_set, doc=r"""matrixType : SoSFEnum""")
    matrixTransform = property(_coin.SoShaderStateMatrixParameter_matrixTransform_get, _coin.SoShaderStateMatrixParameter_matrixTransform_set, doc=r"""matrixTransform : SoSFEnum""")

    def __init__(self):
        r"""__init__(SoShaderStateMatrixParameter self) -> SoShaderStateMatrixParameter"""
        _coin.SoShaderStateMatrixParameter_swiginit(self, _coin.new_SoShaderStateMatrixParameter())
    __swig_destroy__ = _coin.delete_SoShaderStateMatrixParameter

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderStateMatrixParameter_initClass()

    def updateParameter(self, shaderObject: "SoGLShaderObject *") -> "void":
        r"""updateParameter(SoShaderStateMatrixParameter self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderStateMatrixParameter_updateParameter(self, shaderObject)

    def updateValue(self, state: "SoState") -> "void":
        r"""updateValue(SoShaderStateMatrixParameter self, SoState state)"""
        return _coin.SoShaderStateMatrixParameter_updateValue(self, state)

# Register SoShaderStateMatrixParameter in _coin:
_coin.SoShaderStateMatrixParameter_swigregister(SoShaderStateMatrixParameter)

def SoShaderStateMatrixParameter_getClassTypeId() -> "SoType":
    r"""SoShaderStateMatrixParameter_getClassTypeId() -> SoType"""
    return _coin.SoShaderStateMatrixParameter_getClassTypeId()

def SoShaderStateMatrixParameter_initClass() -> "void":
    r"""SoShaderStateMatrixParameter_initClass()"""
    return _coin.SoShaderStateMatrixParameter_initClass()

class SoShaderProgram(SoNode):
    r"""Proxy of C++ SoShaderProgram class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderProgram_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoShaderProgram self) -> SoType"""
        return _coin.SoShaderProgram_getTypeId(self)
    shaderObject = property(_coin.SoShaderProgram_shaderObject_get, _coin.SoShaderProgram_shaderObject_set, doc=r"""shaderObject : SoMFNode""")

    def __init__(self):
        r"""__init__(SoShaderProgram self) -> SoShaderProgram"""
        _coin.SoShaderProgram_swiginit(self, _coin.new_SoShaderProgram())

    def setEnableCallback(self, cb: "SoShaderProgramEnableCB *", closure: "void *") -> "void":
        r"""setEnableCallback(SoShaderProgram self, SoShaderProgramEnableCB * cb, void * closure)"""
        return _coin.SoShaderProgram_setEnableCallback(self, cb, closure)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoShaderProgram self, SoGLRenderAction action)"""
        return _coin.SoShaderProgram_GLRender(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoShaderProgram self, SoSearchAction action)"""
        return _coin.SoShaderProgram_search(self, action)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoShaderProgram_initClass()

# Register SoShaderProgram in _coin:
_coin.SoShaderProgram_swigregister(SoShaderProgram)

def SoShaderProgram_getClassTypeId() -> "SoType":
    r"""SoShaderProgram_getClassTypeId() -> SoType"""
    return _coin.SoShaderProgram_getClassTypeId()

def SoShaderProgram_initClass() -> "void":
    r"""SoShaderProgram_initClass()"""
    return _coin.SoShaderProgram_initClass()

class SoFragmentShader(SoShaderObject):
    r"""Proxy of C++ SoFragmentShader class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFragmentShader_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoFragmentShader self) -> SoType"""
        return _coin.SoFragmentShader_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoFragmentShader_initClass()

    def __init__(self):
        r"""__init__(SoFragmentShader self) -> SoFragmentShader"""
        _coin.SoFragmentShader_swiginit(self, _coin.new_SoFragmentShader())
    __swig_destroy__ = _coin.delete_SoFragmentShader

    @staticmethod
    def isSupported(sourceType: "SoShaderObject::SourceType") -> "SbBool":
        r"""isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
        return _coin.SoFragmentShader_isSupported(sourceType)

# Register SoFragmentShader in _coin:
_coin.SoFragmentShader_swigregister(SoFragmentShader)

def SoFragmentShader_getClassTypeId() -> "SoType":
    r"""SoFragmentShader_getClassTypeId() -> SoType"""
    return _coin.SoFragmentShader_getClassTypeId()

def SoFragmentShader_initClass() -> "void":
    r"""SoFragmentShader_initClass()"""
    return _coin.SoFragmentShader_initClass()

def SoFragmentShader_isSupported(sourceType: "SoShaderObject::SourceType") -> "SbBool":
    r"""SoFragmentShader_isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
    return _coin.SoFragmentShader_isSupported(sourceType)

class SoVertexShader(SoShaderObject):
    r"""Proxy of C++ SoVertexShader class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexShader_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVertexShader self) -> SoType"""
        return _coin.SoVertexShader_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVertexShader_initClass()

    def __init__(self):
        r"""__init__(SoVertexShader self) -> SoVertexShader"""
        _coin.SoVertexShader_swiginit(self, _coin.new_SoVertexShader())
    __swig_destroy__ = _coin.delete_SoVertexShader

    @staticmethod
    def isSupported(sourceType: "SoShaderObject::SourceType") -> "SbBool":
        r"""isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
        return _coin.SoVertexShader_isSupported(sourceType)

# Register SoVertexShader in _coin:
_coin.SoVertexShader_swigregister(SoVertexShader)

def SoVertexShader_getClassTypeId() -> "SoType":
    r"""SoVertexShader_getClassTypeId() -> SoType"""
    return _coin.SoVertexShader_getClassTypeId()

def SoVertexShader_initClass() -> "void":
    r"""SoVertexShader_initClass()"""
    return _coin.SoVertexShader_initClass()

def SoVertexShader_isSupported(sourceType: "SoShaderObject::SourceType") -> "SbBool":
    r"""SoVertexShader_isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
    return _coin.SoVertexShader_isSupported(sourceType)

class SoTextureCoordinateNormalMap(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateNormalMap class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateNormalMap_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateNormalMap self) -> SoType"""
        return _coin.SoTextureCoordinateNormalMap_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateNormalMap_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateNormalMap self) -> SoTextureCoordinateNormalMap"""
        _coin.SoTextureCoordinateNormalMap_swiginit(self, _coin.new_SoTextureCoordinateNormalMap())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateNormalMap self, SoAction action)"""
        return _coin.SoTextureCoordinateNormalMap_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateNormalMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateNormalMap_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateNormalMap self, SoPickAction action)"""
        return _coin.SoTextureCoordinateNormalMap_pick(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateNormalMap self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateNormalMap_callback(self, action)

# Register SoTextureCoordinateNormalMap in _coin:
_coin.SoTextureCoordinateNormalMap_swigregister(SoTextureCoordinateNormalMap)

def SoTextureCoordinateNormalMap_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateNormalMap_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateNormalMap_getClassTypeId()

def SoTextureCoordinateNormalMap_initClass() -> "void":
    r"""SoTextureCoordinateNormalMap_initClass()"""
    return _coin.SoTextureCoordinateNormalMap_initClass()

class SoTextureCoordinateReflectionMap(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateReflectionMap class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateReflectionMap_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateReflectionMap self) -> SoType"""
        return _coin.SoTextureCoordinateReflectionMap_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateReflectionMap_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateReflectionMap self) -> SoTextureCoordinateReflectionMap"""
        _coin.SoTextureCoordinateReflectionMap_swiginit(self, _coin.new_SoTextureCoordinateReflectionMap())

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateReflectionMap self, SoAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateReflectionMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateReflectionMap self, SoPickAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_pick(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateReflectionMap self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_callback(self, action)

# Register SoTextureCoordinateReflectionMap in _coin:
_coin.SoTextureCoordinateReflectionMap_swigregister(SoTextureCoordinateReflectionMap)

def SoTextureCoordinateReflectionMap_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateReflectionMap_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateReflectionMap_getClassTypeId()

def SoTextureCoordinateReflectionMap_initClass() -> "void":
    r"""SoTextureCoordinateReflectionMap_initClass()"""
    return _coin.SoTextureCoordinateReflectionMap_initClass()

class SoTextureCoordinateObject(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateObject class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateObject_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCoordinateObject self) -> SoType"""
        return _coin.SoTextureCoordinateObject_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCoordinateObject_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateObject self) -> SoTextureCoordinateObject"""
        _coin.SoTextureCoordinateObject_swiginit(self, _coin.new_SoTextureCoordinateObject())
    factorS = property(_coin.SoTextureCoordinateObject_factorS_get, _coin.SoTextureCoordinateObject_factorS_set, doc=r"""factorS : SoSFVec4f""")
    factorT = property(_coin.SoTextureCoordinateObject_factorT_get, _coin.SoTextureCoordinateObject_factorT_set, doc=r"""factorT : SoSFVec4f""")
    factorR = property(_coin.SoTextureCoordinateObject_factorR_get, _coin.SoTextureCoordinateObject_factorR_set, doc=r"""factorR : SoSFVec4f""")
    factorQ = property(_coin.SoTextureCoordinateObject_factorQ_get, _coin.SoTextureCoordinateObject_factorQ_set, doc=r"""factorQ : SoSFVec4f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCoordinateObject self, SoAction action)"""
        return _coin.SoTextureCoordinateObject_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCoordinateObject self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateObject_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCoordinateObject self, SoPickAction action)"""
        return _coin.SoTextureCoordinateObject_pick(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCoordinateObject self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateObject_callback(self, action)

# Register SoTextureCoordinateObject in _coin:
_coin.SoTextureCoordinateObject_swigregister(SoTextureCoordinateObject)

def SoTextureCoordinateObject_getClassTypeId() -> "SoType":
    r"""SoTextureCoordinateObject_getClassTypeId() -> SoType"""
    return _coin.SoTextureCoordinateObject_getClassTypeId()

def SoTextureCoordinateObject_initClass() -> "void":
    r"""SoTextureCoordinateObject_initClass()"""
    return _coin.SoTextureCoordinateObject_initClass()

class SoTextureScalePolicy(SoNode):
    r"""Proxy of C++ SoTextureScalePolicy class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureScalePolicy_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureScalePolicy self) -> SoType"""
        return _coin.SoTextureScalePolicy_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureScalePolicy_initClass()

    def __init__(self):
        r"""__init__(SoTextureScalePolicy self) -> SoTextureScalePolicy"""
        _coin.SoTextureScalePolicy_swiginit(self, _coin.new_SoTextureScalePolicy())
    USE_TEXTURE_QUALITY = _coin.SoTextureScalePolicy_USE_TEXTURE_QUALITY
    
    SCALE_DOWN = _coin.SoTextureScalePolicy_SCALE_DOWN
    
    SCALE_UP = _coin.SoTextureScalePolicy_SCALE_UP
    
    FRACTURE = _coin.SoTextureScalePolicy_FRACTURE
    
    policy = property(_coin.SoTextureScalePolicy_policy_get, _coin.SoTextureScalePolicy_policy_set, doc=r"""policy : SoSFEnum""")
    quality = property(_coin.SoTextureScalePolicy_quality_get, _coin.SoTextureScalePolicy_quality_set, doc=r"""quality : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureScalePolicy self, SoGLRenderAction action)"""
        return _coin.SoTextureScalePolicy_GLRender(self, action)

# Register SoTextureScalePolicy in _coin:
_coin.SoTextureScalePolicy_swigregister(SoTextureScalePolicy)

def SoTextureScalePolicy_getClassTypeId() -> "SoType":
    r"""SoTextureScalePolicy_getClassTypeId() -> SoType"""
    return _coin.SoTextureScalePolicy_getClassTypeId()

def SoTextureScalePolicy_initClass() -> "void":
    r"""SoTextureScalePolicy_initClass()"""
    return _coin.SoTextureScalePolicy_initClass()

class SoTextureUnit(SoNode):
    r"""Proxy of C++ SoTextureUnit class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureUnit_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureUnit self) -> SoType"""
        return _coin.SoTextureUnit_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureUnit_initClass()

    def __init__(self):
        r"""__init__(SoTextureUnit self) -> SoTextureUnit"""
        _coin.SoTextureUnit_swiginit(self, _coin.new_SoTextureUnit())
    BUMP_MAPPING = _coin.SoTextureUnit_BUMP_MAPPING
    
    IMAGE_MAPPING = _coin.SoTextureUnit_IMAGE_MAPPING
    
    unit = property(_coin.SoTextureUnit_unit_get, _coin.SoTextureUnit_unit_set, doc=r"""unit : SoSFInt32""")
    mappingMethod = property(_coin.SoTextureUnit_mappingMethod_get, _coin.SoTextureUnit_mappingMethod_set, doc=r"""mappingMethod : SoSFEnum""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureUnit self, SoAction action)"""
        return _coin.SoTextureUnit_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureUnit self, SoCallbackAction action)"""
        return _coin.SoTextureUnit_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureUnit self, SoGLRenderAction action)"""
        return _coin.SoTextureUnit_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureUnit self, SoPickAction action)"""
        return _coin.SoTextureUnit_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoTextureUnit self, SoGetBoundingBoxAction action)"""
        return _coin.SoTextureUnit_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoTextureUnit self, SoGetMatrixAction action)"""
        return _coin.SoTextureUnit_getMatrix(self, action)

    @staticmethod
    def getMaxTextureUnit() -> "uint32_t":
        r"""getMaxTextureUnit() -> uint32_t"""
        return _coin.SoTextureUnit_getMaxTextureUnit()

# Register SoTextureUnit in _coin:
_coin.SoTextureUnit_swigregister(SoTextureUnit)

def SoTextureUnit_getClassTypeId() -> "SoType":
    r"""SoTextureUnit_getClassTypeId() -> SoType"""
    return _coin.SoTextureUnit_getClassTypeId()

def SoTextureUnit_initClass() -> "void":
    r"""SoTextureUnit_initClass()"""
    return _coin.SoTextureUnit_initClass()

def SoTextureUnit_getMaxTextureUnit() -> "uint32_t":
    r"""SoTextureUnit_getMaxTextureUnit() -> uint32_t"""
    return _coin.SoTextureUnit_getMaxTextureUnit()

class SoTextureCombine(SoNode):
    r"""Proxy of C++ SoTextureCombine class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCombine_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoTextureCombine self) -> SoType"""
        return _coin.SoTextureCombine_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoTextureCombine_initClass()

    def __init__(self):
        r"""__init__(SoTextureCombine self) -> SoTextureCombine"""
        _coin.SoTextureCombine_swiginit(self, _coin.new_SoTextureCombine())
    PRIMARY_COLOR = _coin.SoTextureCombine_PRIMARY_COLOR
    
    TEXTURE = _coin.SoTextureCombine_TEXTURE
    
    CONSTANT = _coin.SoTextureCombine_CONSTANT
    
    PREVIOUS = _coin.SoTextureCombine_PREVIOUS
    
    SRC_COLOR = _coin.SoTextureCombine_SRC_COLOR
    
    ONE_MINUS_SRC_COLOR = _coin.SoTextureCombine_ONE_MINUS_SRC_COLOR
    
    SRC_ALPHA = _coin.SoTextureCombine_SRC_ALPHA
    
    ONE_MINUS_SRC_ALPHA = _coin.SoTextureCombine_ONE_MINUS_SRC_ALPHA
    
    REPLACE = _coin.SoTextureCombine_REPLACE
    
    MODULATE = _coin.SoTextureCombine_MODULATE
    
    ADD = _coin.SoTextureCombine_ADD
    
    ADD_SIGNED = _coin.SoTextureCombine_ADD_SIGNED
    
    SUBTRACT = _coin.SoTextureCombine_SUBTRACT
    
    INTERPOLATE = _coin.SoTextureCombine_INTERPOLATE
    
    DOT3_RGB = _coin.SoTextureCombine_DOT3_RGB
    
    DOT3_RGBA = _coin.SoTextureCombine_DOT3_RGBA
    
    rgbSource = property(_coin.SoTextureCombine_rgbSource_get, _coin.SoTextureCombine_rgbSource_set, doc=r"""rgbSource : SoMFEnum""")
    alphaSource = property(_coin.SoTextureCombine_alphaSource_get, _coin.SoTextureCombine_alphaSource_set, doc=r"""alphaSource : SoMFEnum""")
    rgbOperand = property(_coin.SoTextureCombine_rgbOperand_get, _coin.SoTextureCombine_rgbOperand_set, doc=r"""rgbOperand : SoMFEnum""")
    alphaOperand = property(_coin.SoTextureCombine_alphaOperand_get, _coin.SoTextureCombine_alphaOperand_set, doc=r"""alphaOperand : SoMFEnum""")
    rgbOperation = property(_coin.SoTextureCombine_rgbOperation_get, _coin.SoTextureCombine_rgbOperation_set, doc=r"""rgbOperation : SoSFEnum""")
    alphaOperation = property(_coin.SoTextureCombine_alphaOperation_get, _coin.SoTextureCombine_alphaOperation_set, doc=r"""alphaOperation : SoSFEnum""")
    rgbScale = property(_coin.SoTextureCombine_rgbScale_get, _coin.SoTextureCombine_rgbScale_set, doc=r"""rgbScale : SoSFFloat""")
    alphaScale = property(_coin.SoTextureCombine_alphaScale_get, _coin.SoTextureCombine_alphaScale_set, doc=r"""alphaScale : SoSFFloat""")
    constantColor = property(_coin.SoTextureCombine_constantColor_get, _coin.SoTextureCombine_constantColor_set, doc=r"""constantColor : SoSFVec4f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoTextureCombine self, SoAction action)"""
        return _coin.SoTextureCombine_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoTextureCombine self, SoCallbackAction action)"""
        return _coin.SoTextureCombine_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoTextureCombine self, SoGLRenderAction action)"""
        return _coin.SoTextureCombine_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoTextureCombine self, SoPickAction action)"""
        return _coin.SoTextureCombine_pick(self, action)

# Register SoTextureCombine in _coin:
_coin.SoTextureCombine_swigregister(SoTextureCombine)

def SoTextureCombine_getClassTypeId() -> "SoType":
    r"""SoTextureCombine_getClassTypeId() -> SoType"""
    return _coin.SoTextureCombine_getClassTypeId()

def SoTextureCombine_initClass() -> "void":
    r"""SoTextureCombine_initClass()"""
    return _coin.SoTextureCombine_initClass()

class SoSceneTexture2(SoNode):
    r"""Proxy of C++ SoSceneTexture2 class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSceneTexture2_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSceneTexture2 self) -> SoType"""
        return _coin.SoSceneTexture2_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSceneTexture2_initClass()

    def __init__(self):
        r"""__init__(SoSceneTexture2 self) -> SoSceneTexture2"""
        _coin.SoSceneTexture2_swiginit(self, _coin.new_SoSceneTexture2())
    MODULATE = _coin.SoSceneTexture2_MODULATE
    
    DECAL = _coin.SoSceneTexture2_DECAL
    
    BLEND = _coin.SoSceneTexture2_BLEND
    
    REPLACE = _coin.SoSceneTexture2_REPLACE
    
    REPEAT = _coin.SoSceneTexture2_REPEAT
    
    CLAMP = _coin.SoSceneTexture2_CLAMP
    
    CLAMP_TO_BORDER = _coin.SoSceneTexture2_CLAMP_TO_BORDER
    
    NONE = _coin.SoSceneTexture2_NONE
    
    ALPHA_BLEND = _coin.SoSceneTexture2_ALPHA_BLEND
    
    ALPHA_TEST = _coin.SoSceneTexture2_ALPHA_TEST
    
    DEPTH = _coin.SoSceneTexture2_DEPTH
    
    RGBA8 = _coin.SoSceneTexture2_RGBA8
    
    RGBA32F = _coin.SoSceneTexture2_RGBA32F
    
    RGB32F = _coin.SoSceneTexture2_RGB32F
    
    RGBA16F = _coin.SoSceneTexture2_RGBA16F
    
    RGB16F = _coin.SoSceneTexture2_RGB16F
    
    R3_G3_B2 = _coin.SoSceneTexture2_R3_G3_B2
    
    RGB = _coin.SoSceneTexture2_RGB
    
    RGB4 = _coin.SoSceneTexture2_RGB4
    
    RGB5 = _coin.SoSceneTexture2_RGB5
    
    RGB8 = _coin.SoSceneTexture2_RGB8
    
    RGB10 = _coin.SoSceneTexture2_RGB10
    
    RGB12 = _coin.SoSceneTexture2_RGB12
    
    RGB16 = _coin.SoSceneTexture2_RGB16
    
    RGBA = _coin.SoSceneTexture2_RGBA
    
    RGBA2 = _coin.SoSceneTexture2_RGBA2
    
    RGBA4 = _coin.SoSceneTexture2_RGBA4
    
    RGB5_A1 = _coin.SoSceneTexture2_RGB5_A1
    
    RGB10_A2 = _coin.SoSceneTexture2_RGB10_A2
    
    RGBA12 = _coin.SoSceneTexture2_RGBA12
    
    RGBA16 = _coin.SoSceneTexture2_RGBA16
    
    wrapS = property(_coin.SoSceneTexture2_wrapS_get, _coin.SoSceneTexture2_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoSceneTexture2_wrapT_get, _coin.SoSceneTexture2_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoSceneTexture2_model_get, _coin.SoSceneTexture2_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoSceneTexture2_blendColor_get, _coin.SoSceneTexture2_blendColor_set, doc=r"""blendColor : SoSFColor""")
    backgroundColor = property(_coin.SoSceneTexture2_backgroundColor_get, _coin.SoSceneTexture2_backgroundColor_set, doc=r"""backgroundColor : SoSFVec4f""")
    size = property(_coin.SoSceneTexture2_size_get, _coin.SoSceneTexture2_size_set, doc=r"""size : SoSFVec2s""")
    scene = property(_coin.SoSceneTexture2_scene_get, _coin.SoSceneTexture2_scene_set, doc=r"""scene : SoSFNode""")
    sceneTransparencyType = property(_coin.SoSceneTexture2_sceneTransparencyType_get, _coin.SoSceneTexture2_sceneTransparencyType_set, doc=r"""sceneTransparencyType : SoSFNode""")
    transparencyFunction = property(_coin.SoSceneTexture2_transparencyFunction_get, _coin.SoSceneTexture2_transparencyFunction_set, doc=r"""transparencyFunction : SoSFEnum""")
    type = property(_coin.SoSceneTexture2_type_get, _coin.SoSceneTexture2_type_set, doc=r"""type : SoSFEnum""")

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoSceneTexture2 self, SoNotList list)"""
        return _coin.SoSceneTexture2_notify(self, list)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoSceneTexture2 self, SoWriteAction action)"""
        return _coin.SoSceneTexture2_write(self, action)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoSceneTexture2 self, SoAction action)"""
        return _coin.SoSceneTexture2_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoSceneTexture2 self, SoGLRenderAction action)"""
        return _coin.SoSceneTexture2_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoSceneTexture2 self, SoCallbackAction action)"""
        return _coin.SoSceneTexture2_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoSceneTexture2 self, SoRayPickAction action)"""
        return _coin.SoSceneTexture2_rayPick(self, action)

# Register SoSceneTexture2 in _coin:
_coin.SoSceneTexture2_swigregister(SoSceneTexture2)

def SoSceneTexture2_getClassTypeId() -> "SoType":
    r"""SoSceneTexture2_getClassTypeId() -> SoType"""
    return _coin.SoSceneTexture2_getClassTypeId()

def SoSceneTexture2_initClass() -> "void":
    r"""SoSceneTexture2_initClass()"""
    return _coin.SoSceneTexture2_initClass()

class SoSceneTextureCubeMap(SoNode):
    r"""Proxy of C++ SoSceneTextureCubeMap class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSceneTextureCubeMap_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoSceneTextureCubeMap self) -> SoType"""
        return _coin.SoSceneTextureCubeMap_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoSceneTextureCubeMap_initClass()

    def __init__(self):
        r"""__init__(SoSceneTextureCubeMap self) -> SoSceneTextureCubeMap"""
        _coin.SoSceneTextureCubeMap_swiginit(self, _coin.new_SoSceneTextureCubeMap())
    MODULATE = _coin.SoSceneTextureCubeMap_MODULATE
    
    DECAL = _coin.SoSceneTextureCubeMap_DECAL
    
    BLEND = _coin.SoSceneTextureCubeMap_BLEND
    
    REPLACE = _coin.SoSceneTextureCubeMap_REPLACE
    
    REPEAT = _coin.SoSceneTextureCubeMap_REPEAT
    
    CLAMP = _coin.SoSceneTextureCubeMap_CLAMP
    
    NONE = _coin.SoSceneTextureCubeMap_NONE
    
    ALPHA_BLEND = _coin.SoSceneTextureCubeMap_ALPHA_BLEND
    
    ALPHA_TEST = _coin.SoSceneTextureCubeMap_ALPHA_TEST
    
    size = property(_coin.SoSceneTextureCubeMap_size_get, _coin.SoSceneTextureCubeMap_size_set, doc=r"""size : SoSFVec2s""")
    scene = property(_coin.SoSceneTextureCubeMap_scene_get, _coin.SoSceneTextureCubeMap_scene_set, doc=r"""scene : SoSFNode""")
    wrapS = property(_coin.SoSceneTextureCubeMap_wrapS_get, _coin.SoSceneTextureCubeMap_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoSceneTextureCubeMap_wrapT_get, _coin.SoSceneTextureCubeMap_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    wrapR = property(_coin.SoSceneTextureCubeMap_wrapR_get, _coin.SoSceneTextureCubeMap_wrapR_set, doc=r"""wrapR : SoSFEnum""")
    model = property(_coin.SoSceneTextureCubeMap_model_get, _coin.SoSceneTextureCubeMap_model_set, doc=r"""model : SoSFEnum""")
    backgroundColor = property(_coin.SoSceneTextureCubeMap_backgroundColor_get, _coin.SoSceneTextureCubeMap_backgroundColor_set, doc=r"""backgroundColor : SoSFColor""")
    transparencyFunction = property(_coin.SoSceneTextureCubeMap_transparencyFunction_get, _coin.SoSceneTextureCubeMap_transparencyFunction_set, doc=r"""transparencyFunction : SoSFEnum""")
    blendColor = property(_coin.SoSceneTextureCubeMap_blendColor_get, _coin.SoSceneTextureCubeMap_blendColor_set, doc=r"""blendColor : SoSFColor""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoSceneTextureCubeMap self, SoAction action)"""
        return _coin.SoSceneTextureCubeMap_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoSceneTextureCubeMap self, SoGLRenderAction action)"""
        return _coin.SoSceneTextureCubeMap_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoSceneTextureCubeMap self, SoCallbackAction action)"""
        return _coin.SoSceneTextureCubeMap_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoSceneTextureCubeMap self, SoRayPickAction action)"""
        return _coin.SoSceneTextureCubeMap_rayPick(self, action)

# Register SoSceneTextureCubeMap in _coin:
_coin.SoSceneTextureCubeMap_swigregister(SoSceneTextureCubeMap)

def SoSceneTextureCubeMap_getClassTypeId() -> "SoType":
    r"""SoSceneTextureCubeMap_getClassTypeId() -> SoType"""
    return _coin.SoSceneTextureCubeMap_getClassTypeId()

def SoSceneTextureCubeMap_initClass() -> "void":
    r"""SoSceneTextureCubeMap_initClass()"""
    return _coin.SoSceneTextureCubeMap_initClass()

class SoCacheHintElement(SoElement):
    r"""Proxy of C++ SoCacheHintElement class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCacheHintElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex() -> "int":
        r"""getClassStackIndex() -> int"""
        return _coin.SoCacheHintElement_getClassStackIndex()

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoCacheHintElement_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCacheHintElement_initClass()

    def init(self, state: "SoState") -> "void":
        r"""init(SoCacheHintElement self, SoState state)"""
        return _coin.SoCacheHintElement_init(self, state)

    def push(self, state: "SoState") -> "void":
        r"""push(SoCacheHintElement self, SoState state)"""
        return _coin.SoCacheHintElement_push(self, state)

    def pop(self, state: "SoState", prevtopelement: "SoElement") -> "void":
        r"""pop(SoCacheHintElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoCacheHintElement_pop(self, state, prevtopelement)

    def matches(self, element: "SoElement") -> "SbBool":
        r"""matches(SoCacheHintElement self, SoElement element) -> SbBool"""
        return _coin.SoCacheHintElement_matches(self, element)

    def copyMatchInfo(self) -> "SoElement *":
        r"""copyMatchInfo(SoCacheHintElement self) -> SoElement"""
        return _coin.SoCacheHintElement_copyMatchInfo(self)

    @staticmethod
    def set(state: "SoState", node: "SoNode", memvalue: "float const", gfxvalue: "float const") -> "void":
        r"""set(SoState state, SoNode node, float const memvalue, float const gfxvalue)"""
        return _coin.SoCacheHintElement_set(state, node, memvalue, gfxvalue)

    @staticmethod
    def get(state: "SoState", memvalue: "float &", gfxvalue: "float &") -> "void":
        r"""get(SoState state, float & memvalue, float & gfxvalue)"""
        return _coin.SoCacheHintElement_get(state, memvalue, gfxvalue)

# Register SoCacheHintElement in _coin:
_coin.SoCacheHintElement_swigregister(SoCacheHintElement)

def SoCacheHintElement_getClassTypeId() -> "SoType":
    r"""SoCacheHintElement_getClassTypeId() -> SoType"""
    return _coin.SoCacheHintElement_getClassTypeId()

def SoCacheHintElement_getClassStackIndex() -> "int":
    r"""SoCacheHintElement_getClassStackIndex() -> int"""
    return _coin.SoCacheHintElement_getClassStackIndex()

def SoCacheHintElement_createInstance() -> "void *":
    r"""SoCacheHintElement_createInstance() -> void *"""
    return _coin.SoCacheHintElement_createInstance()

def SoCacheHintElement_initClass() -> "void":
    r"""SoCacheHintElement_initClass()"""
    return _coin.SoCacheHintElement_initClass()

def SoCacheHintElement_set(state: "SoState", node: "SoNode", memvalue: "float const", gfxvalue: "float const") -> "void":
    r"""SoCacheHintElement_set(SoState state, SoNode node, float const memvalue, float const gfxvalue)"""
    return _coin.SoCacheHintElement_set(state, node, memvalue, gfxvalue)

def SoCacheHintElement_get(state: "SoState", memvalue: "float &", gfxvalue: "float &") -> "void":
    r"""SoCacheHintElement_get(SoState state, float & memvalue, float & gfxvalue)"""
    return _coin.SoCacheHintElement_get(state, memvalue, gfxvalue)

class SoCacheHint(SoNode):
    r"""Proxy of C++ SoCacheHint class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCacheHint_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoCacheHint self) -> SoType"""
        return _coin.SoCacheHint_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoCacheHint_initClass()

    def __init__(self):
        r"""__init__(SoCacheHint self) -> SoCacheHint"""
        _coin.SoCacheHint_swiginit(self, _coin.new_SoCacheHint())
    memValue = property(_coin.SoCacheHint_memValue_get, _coin.SoCacheHint_memValue_set, doc=r"""memValue : SoSFFloat""")
    gfxValue = property(_coin.SoCacheHint_gfxValue_get, _coin.SoCacheHint_gfxValue_set, doc=r"""gfxValue : SoSFFloat""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoCacheHint self, SoAction action)"""
        return _coin.SoCacheHint_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoCacheHint self, SoGLRenderAction action)"""
        return _coin.SoCacheHint_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoCacheHint self, SoCallbackAction action)"""
        return _coin.SoCacheHint_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoCacheHint self, SoGetBoundingBoxAction action)"""
        return _coin.SoCacheHint_getBoundingBox(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoCacheHint self, SoPickAction action)"""
        return _coin.SoCacheHint_pick(self, action)

# Register SoCacheHint in _coin:
_coin.SoCacheHint_swigregister(SoCacheHint)

def SoCacheHint_getClassTypeId() -> "SoType":
    r"""SoCacheHint_getClassTypeId() -> SoType"""
    return _coin.SoCacheHint_getClassTypeId()

def SoCacheHint_initClass() -> "void":
    r"""SoCacheHint_initClass()"""
    return _coin.SoCacheHint_initClass()

class SoDepthBuffer(SoNode):
    r"""Proxy of C++ SoDepthBuffer class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDepthBuffer_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoDepthBuffer self) -> SoType"""
        return _coin.SoDepthBuffer_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoDepthBuffer_initClass()

    def __init__(self):
        r"""__init__(SoDepthBuffer self) -> SoDepthBuffer"""
        _coin.SoDepthBuffer_swiginit(self, _coin.new_SoDepthBuffer())
    NEVER = _coin.SoDepthBuffer_NEVER
    
    ALWAYS = _coin.SoDepthBuffer_ALWAYS
    
    LESS = _coin.SoDepthBuffer_LESS
    
    LEQUAL = _coin.SoDepthBuffer_LEQUAL
    
    EQUAL = _coin.SoDepthBuffer_EQUAL
    
    GEQUAL = _coin.SoDepthBuffer_GEQUAL
    
    GREATER = _coin.SoDepthBuffer_GREATER
    
    NOTEQUAL = _coin.SoDepthBuffer_NOTEQUAL
    
    test = property(_coin.SoDepthBuffer_test_get, _coin.SoDepthBuffer_test_set, doc=r"""test : SoSFBool""")
    write = property(_coin.SoDepthBuffer_write_get, _coin.SoDepthBuffer_write_set, doc=r"""write : SoSFBool""")
    function = property(_coin.SoDepthBuffer_function_get, _coin.SoDepthBuffer_function_set, doc=r"""function : SoSFEnum""")
    range = property(_coin.SoDepthBuffer_range_get, _coin.SoDepthBuffer_range_set, doc=r"""range : SoSFVec2f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoDepthBuffer self, SoGLRenderAction action)"""
        return _coin.SoDepthBuffer_GLRender(self, action)

# Register SoDepthBuffer in _coin:
_coin.SoDepthBuffer_swigregister(SoDepthBuffer)

def SoDepthBuffer_getClassTypeId() -> "SoType":
    r"""SoDepthBuffer_getClassTypeId() -> SoType"""
    return _coin.SoDepthBuffer_getClassTypeId()

def SoDepthBuffer_initClass() -> "void":
    r"""SoDepthBuffer_initClass()"""
    return _coin.SoDepthBuffer_initClass()

class SoAlphaTest(SoNode):
    r"""Proxy of C++ SoAlphaTest class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAlphaTest_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoAlphaTest self) -> SoType"""
        return _coin.SoAlphaTest_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoAlphaTest_initClass()

    def __init__(self):
        r"""__init__(SoAlphaTest self) -> SoAlphaTest"""
        _coin.SoAlphaTest_swiginit(self, _coin.new_SoAlphaTest())
    NONE = _coin.SoAlphaTest_NONE
    
    NEVER = _coin.SoAlphaTest_NEVER
    
    ALWAYS = _coin.SoAlphaTest_ALWAYS
    
    LESS = _coin.SoAlphaTest_LESS
    
    LEQUAL = _coin.SoAlphaTest_LEQUAL
    
    EQUAL = _coin.SoAlphaTest_EQUAL
    
    GEQUAL = _coin.SoAlphaTest_GEQUAL
    
    GREATER = _coin.SoAlphaTest_GREATER
    
    NOTEQUAL = _coin.SoAlphaTest_NOTEQUAL
    
    function = property(_coin.SoAlphaTest_function_get, _coin.SoAlphaTest_function_set, doc=r"""function : SoSFEnum""")
    value = property(_coin.SoAlphaTest_value_get, _coin.SoAlphaTest_value_set, doc=r"""value : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoAlphaTest self, SoGLRenderAction action)"""
        return _coin.SoAlphaTest_GLRender(self, action)

# Register SoAlphaTest in _coin:
_coin.SoAlphaTest_swigregister(SoAlphaTest)

def SoAlphaTest_getClassTypeId() -> "SoType":
    r"""SoAlphaTest_getClassTypeId() -> SoType"""
    return _coin.SoAlphaTest_getClassTypeId()

def SoAlphaTest_initClass() -> "void":
    r"""SoAlphaTest_initClass()"""
    return _coin.SoAlphaTest_initClass()

class SbLine(object):
    r"""Proxy of C++ SbLine class."""

    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):
        r"""
        __init__(SbLine self) -> SbLine
        __init__(SbLine self, SbVec3f origin, SbVec3f point) -> SbLine
        """
        _coin.SbLine_swiginit(self, _coin.new_SbLine(*args))

    def setValue(self, origin: "SbVec3f", point: "SbVec3f") -> "void":
        r"""setValue(SbLine self, SbVec3f origin, SbVec3f point)"""
        return _coin.SbLine_setValue(self, origin, point)

    def setPosDir(self, position: "SbVec3f", direction: "SbVec3f") -> "void":
        r"""setPosDir(SbLine self, SbVec3f position, SbVec3f direction)"""
        return _coin.SbLine_setPosDir(self, position, direction)

    def getClosestPoints(self, line2: "SbLine", ptOnThis: "SbVec3f", ptOnLine2: "SbVec3f") -> "SbBool":
        r"""getClosestPoints(SbLine self, SbLine line2, SbVec3f ptOnThis, SbVec3f ptOnLine2) -> SbBool"""
        return _coin.SbLine_getClosestPoints(self, line2, ptOnThis, ptOnLine2)

    def getClosestPoint(self, point: "SbVec3f") -> "SbVec3f":
        r"""getClosestPoint(SbLine self, SbVec3f point) -> SbVec3f"""
        return _coin.SbLine_getClosestPoint(self, point)

    def getPosition(self) -> "SbVec3f const &":
        r"""getPosition(SbLine self) -> SbVec3f"""
        return _coin.SbLine_getPosition(self)

    def getDirection(self) -> "SbVec3f const &":
        r"""getDirection(SbLine self) -> SbVec3f"""
        return _coin.SbLine_getDirection(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbLine self, FILE * file)"""
        return _coin.SbLine_output(self, file)
    __swig_destroy__ = _coin.delete_SbLine

# Register SbLine in _coin:
_coin.SbLine_swigregister(SbLine)

class SbProjector(object):
    r"""Proxy of C++ SbProjector class."""

    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 project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbProjector_project(self, point)

    def setViewVolume(self, vol: "SbViewVolume") -> "void":
        r"""setViewVolume(SbProjector self, SbViewVolume vol)"""
        return _coin.SbProjector_setViewVolume(self, vol)

    def getViewVolume(self) -> "SbViewVolume const &":
        r"""getViewVolume(SbProjector self) -> SbViewVolume"""
        return _coin.SbProjector_getViewVolume(self)

    def setWorkingSpace(self, space: "SbMatrix") -> "void":
        r"""setWorkingSpace(SbProjector self, SbMatrix space)"""
        return _coin.SbProjector_setWorkingSpace(self, space)

    def getWorkingSpace(self) -> "SbMatrix const &":
        r"""getWorkingSpace(SbProjector self) -> SbMatrix"""
        return _coin.SbProjector_getWorkingSpace(self)

    def copy(self) -> "SbProjector *":
        r"""copy(SbProjector self) -> SbProjector"""
        return _coin.SbProjector_copy(self)

    def tryProject(self, point: "SbVec2f", epsilon: "float const", result: "SbVec3f") -> "SbBool":
        r"""tryProject(SbProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbProjector_tryProject(self, point, epsilon, result)

# Register SbProjector in _coin:
_coin.SbProjector_swigregister(SbProjector)

class SbCylinder(object):
    r"""Proxy of C++ SbCylinder class."""

    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):
        r"""
        __init__(SbCylinder self) -> SbCylinder
        __init__(SbCylinder self, SbLine a, float const r) -> SbCylinder
        """
        _coin.SbCylinder_swiginit(self, _coin.new_SbCylinder(*args))

    def setValue(self, a: "SbLine", r: "float const") -> "void":
        r"""setValue(SbCylinder self, SbLine a, float const r)"""
        return _coin.SbCylinder_setValue(self, a, r)

    def setAxis(self, a: "SbLine") -> "void":
        r"""setAxis(SbCylinder self, SbLine a)"""
        return _coin.SbCylinder_setAxis(self, a)

    def setRadius(self, r: "float const") -> "void":
        r"""setRadius(SbCylinder self, float const r)"""
        return _coin.SbCylinder_setRadius(self, r)

    def getAxis(self) -> "SbLine const &":
        r"""getAxis(SbCylinder self) -> SbLine"""
        return _coin.SbCylinder_getAxis(self)

    def getRadius(self) -> "float":
        r"""getRadius(SbCylinder self) -> float"""
        return _coin.SbCylinder_getRadius(self)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbCylinder self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(SbCylinder self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool
        """
        return _coin.SbCylinder_intersect(self, *args)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbCylinder self, FILE * file)"""
        return _coin.SbCylinder_output(self, file)
    __swig_destroy__ = _coin.delete_SbCylinder

# Register SbCylinder in _coin:
_coin.SbCylinder_swigregister(SbCylinder)

class SbCylinderProjector(SbProjector):
    r"""Proxy of C++ SbCylinderProjector class."""

    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 project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbCylinderProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderProjector_project(self, point)

    def projectAndGetRotation(self, point: "SbVec2f", rot: "SbRotation") -> "SbVec3f":
        r"""projectAndGetRotation(SbCylinderProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbCylinderProjector_projectAndGetRotation(self, point, rot)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbCylinderProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderProjector_getRotation(self, point1, point2)

    def setCylinder(self, cyl: "SbCylinder") -> "void":
        r"""setCylinder(SbCylinderProjector self, SbCylinder cyl)"""
        return _coin.SbCylinderProjector_setCylinder(self, cyl)

    def getCylinder(self) -> "SbCylinder const &":
        r"""getCylinder(SbCylinderProjector self) -> SbCylinder"""
        return _coin.SbCylinderProjector_getCylinder(self)

    def setOrientToEye(self, orienttoeye: "SbBool const") -> "void":
        r"""setOrientToEye(SbCylinderProjector self, SbBool const orienttoeye)"""
        return _coin.SbCylinderProjector_setOrientToEye(self, orienttoeye)

    def isOrientToEye(self) -> "SbBool":
        r"""isOrientToEye(SbCylinderProjector self) -> SbBool"""
        return _coin.SbCylinderProjector_isOrientToEye(self)

    def setFront(self, infront: "SbBool const") -> "void":
        r"""setFront(SbCylinderProjector self, SbBool const infront)"""
        return _coin.SbCylinderProjector_setFront(self, infront)

    def isFront(self) -> "SbBool":
        r"""isFront(SbCylinderProjector self) -> SbBool"""
        return _coin.SbCylinderProjector_isFront(self)

    def isPointInFront(self, point: "SbVec3f") -> "SbBool":
        r"""isPointInFront(SbCylinderProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderProjector_isPointInFront(self, point)

    def setWorkingSpace(self, space: "SbMatrix") -> "void":
        r"""setWorkingSpace(SbCylinderProjector self, SbMatrix space)"""
        return _coin.SbCylinderProjector_setWorkingSpace(self, space)
    __swig_destroy__ = _coin.delete_SbCylinderProjector

# Register SbCylinderProjector in _coin:
_coin.SbCylinderProjector_swigregister(SbCylinderProjector)

class SbCylinderSectionProjector(SbCylinderProjector):
    r"""Proxy of C++ SbCylinderSectionProjector class."""

    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):
        r"""
        __init__(SbCylinderSectionProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderSectionProjector
        __init__(SbCylinderSectionProjector self, SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderSectionProjector
        """
        _coin.SbCylinderSectionProjector_swiginit(self, _coin.new_SbCylinderSectionProjector(*args))

    def copy(self) -> "SbProjector *":
        r"""copy(SbCylinderSectionProjector self) -> SbProjector"""
        return _coin.SbCylinderSectionProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbCylinderSectionProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSectionProjector_project(self, point)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbCylinderSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSectionProjector_getRotation(self, point1, point2)

    def setTolerance(self, edgetol: "float const") -> "void":
        r"""setTolerance(SbCylinderSectionProjector self, float const edgetol)"""
        return _coin.SbCylinderSectionProjector_setTolerance(self, edgetol)

    def getTolerance(self) -> "float":
        r"""getTolerance(SbCylinderSectionProjector self) -> float"""
        return _coin.SbCylinderSectionProjector_getTolerance(self)

    def isWithinTolerance(self, point: "SbVec3f") -> "SbBool":
        r"""isWithinTolerance(SbCylinderSectionProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderSectionProjector_isWithinTolerance(self, point)
    __swig_destroy__ = _coin.delete_SbCylinderSectionProjector

# Register SbCylinderSectionProjector in _coin:
_coin.SbCylinderSectionProjector_swigregister(SbCylinderSectionProjector)

class SbCylinderPlaneProjector(SbCylinderSectionProjector):
    r"""Proxy of C++ SbCylinderPlaneProjector class."""

    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):
        r"""
        __init__(SbCylinderPlaneProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderPlaneProjector
        __init__(SbCylinderPlaneProjector self, SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderPlaneProjector
        """
        _coin.SbCylinderPlaneProjector_swiginit(self, _coin.new_SbCylinderPlaneProjector(*args))

    def copy(self) -> "SbProjector *":
        r"""copy(SbCylinderPlaneProjector self) -> SbProjector"""
        return _coin.SbCylinderPlaneProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbCylinderPlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderPlaneProjector_project(self, point)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbCylinderPlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderPlaneProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbCylinderPlaneProjector

# Register SbCylinderPlaneProjector in _coin:
_coin.SbCylinderPlaneProjector_swigregister(SbCylinderPlaneProjector)

class SbCylinderSheetProjector(SbCylinderProjector):
    r"""Proxy of C++ SbCylinderSheetProjector class."""

    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):
        r"""
        __init__(SbCylinderSheetProjector self, SbBool const orienttoeye=1) -> SbCylinderSheetProjector
        __init__(SbCylinderSheetProjector self, SbCylinder cyl, SbBool const orienttoeye=1) -> SbCylinderSheetProjector
        """
        _coin.SbCylinderSheetProjector_swiginit(self, _coin.new_SbCylinderSheetProjector(*args))

    def copy(self) -> "SbProjector *":
        r"""copy(SbCylinderSheetProjector self) -> SbProjector"""
        return _coin.SbCylinderSheetProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbCylinderSheetProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSheetProjector_project(self, point)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbCylinderSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSheetProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbCylinderSheetProjector

# Register SbCylinderSheetProjector in _coin:
_coin.SbCylinderSheetProjector_swigregister(SbCylinderSheetProjector)

class SbLineProjector(SbProjector):
    r"""Proxy of C++ SbLineProjector class."""

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

    def __init__(self):
        r"""__init__(SbLineProjector self) -> SbLineProjector"""
        _coin.SbLineProjector_swiginit(self, _coin.new_SbLineProjector())

    def copy(self) -> "SbProjector *":
        r"""copy(SbLineProjector self) -> SbProjector"""
        return _coin.SbLineProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbLineProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbLineProjector_project(self, point)

    def tryProject(self, point: "SbVec2f", epsilon: "float const", result: "SbVec3f") -> "SbBool":
        r"""tryProject(SbLineProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbLineProjector_tryProject(self, point, epsilon, result)

    def setLine(self, line: "SbLine") -> "void":
        r"""setLine(SbLineProjector self, SbLine line)"""
        return _coin.SbLineProjector_setLine(self, line)

    def getLine(self) -> "SbLine const &":
        r"""getLine(SbLineProjector self) -> SbLine"""
        return _coin.SbLineProjector_getLine(self)

    def getVector(self, *args) -> "SbVec3f":
        r"""
        getVector(SbLineProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(SbLineProjector self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbLineProjector_getVector(self, *args)

    def setStartPosition(self, *args) -> "void":
        r"""
        setStartPosition(SbLineProjector self, SbVec2f viewpos)
        setStartPosition(SbLineProjector self, SbVec3f point)
        """
        return _coin.SbLineProjector_setStartPosition(self, *args)
    __swig_destroy__ = _coin.delete_SbLineProjector

# Register SbLineProjector in _coin:
_coin.SbLineProjector_swigregister(SbLineProjector)

class SbPlaneProjector(SbProjector):
    r"""Proxy of C++ SbPlaneProjector class."""

    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):
        r"""
        __init__(SbPlaneProjector self, SbBool const orient=0) -> SbPlaneProjector
        __init__(SbPlaneProjector self, SbPlane plane, SbBool const orient=0) -> SbPlaneProjector
        """
        _coin.SbPlaneProjector_swiginit(self, _coin.new_SbPlaneProjector(*args))

    def copy(self) -> "SbProjector *":
        r"""copy(SbPlaneProjector self) -> SbProjector"""
        return _coin.SbPlaneProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbPlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbPlaneProjector_project(self, point)

    def tryProject(self, point: "SbVec2f", epsilon: "float const", result: "SbVec3f") -> "SbBool":
        r"""tryProject(SbPlaneProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbPlaneProjector_tryProject(self, point, epsilon, result)

    def setPlane(self, plane: "SbPlane") -> "void":
        r"""setPlane(SbPlaneProjector self, SbPlane plane)"""
        return _coin.SbPlaneProjector_setPlane(self, plane)

    def getPlane(self) -> "SbPlane const &":
        r"""getPlane(SbPlaneProjector self) -> SbPlane"""
        return _coin.SbPlaneProjector_getPlane(self)

    def setOrientToEye(self, orienttoeye: "SbBool const") -> "void":
        r"""setOrientToEye(SbPlaneProjector self, SbBool const orienttoeye)"""
        return _coin.SbPlaneProjector_setOrientToEye(self, orienttoeye)

    def isOrientToEye(self) -> "SbBool":
        r"""isOrientToEye(SbPlaneProjector self) -> SbBool"""
        return _coin.SbPlaneProjector_isOrientToEye(self)

    def getVector(self, *args) -> "SbVec3f":
        r"""
        getVector(SbPlaneProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(SbPlaneProjector self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbPlaneProjector_getVector(self, *args)

    def setStartPosition(self, *args) -> "void":
        r"""
        setStartPosition(SbPlaneProjector self, SbVec2f viewpos)
        setStartPosition(SbPlaneProjector self, SbVec3f point)
        """
        return _coin.SbPlaneProjector_setStartPosition(self, *args)
    __swig_destroy__ = _coin.delete_SbPlaneProjector

# Register SbPlaneProjector in _coin:
_coin.SbPlaneProjector_swigregister(SbPlaneProjector)

class SbSphere(object):
    r"""Proxy of C++ SbSphere class."""

    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):
        r"""
        __init__(SbSphere self) -> SbSphere
        __init__(SbSphere self, SbVec3f center, float const radius) -> SbSphere
        """
        _coin.SbSphere_swiginit(self, _coin.new_SbSphere(*args))

    def setValue(self, center: "SbVec3f", radius: "float const") -> "void":
        r"""setValue(SbSphere self, SbVec3f center, float const radius)"""
        return _coin.SbSphere_setValue(self, center, radius)

    def setCenter(self, center: "SbVec3f") -> "void":
        r"""setCenter(SbSphere self, SbVec3f center)"""
        return _coin.SbSphere_setCenter(self, center)

    def setRadius(self, radius: "float const") -> "void":
        r"""setRadius(SbSphere self, float const radius)"""
        return _coin.SbSphere_setRadius(self, radius)

    def getCenter(self) -> "SbVec3f const &":
        r"""getCenter(SbSphere self) -> SbVec3f"""
        return _coin.SbSphere_getCenter(self)

    def getRadius(self) -> "float":
        r"""getRadius(SbSphere self) -> float"""
        return _coin.SbSphere_getRadius(self)

    def circumscribe(self, box: "SbBox3f") -> "void":
        r"""circumscribe(SbSphere self, SbBox3f box)"""
        return _coin.SbSphere_circumscribe(self, box)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbSphere self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(SbSphere self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool
        """
        return _coin.SbSphere_intersect(self, *args)

    def pointInside(self, p: "SbVec3f") -> "SbBool":
        r"""pointInside(SbSphere self, SbVec3f p) -> SbBool"""
        return _coin.SbSphere_pointInside(self, p)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbSphere self, FILE * file)"""
        return _coin.SbSphere_output(self, file)
    __swig_destroy__ = _coin.delete_SbSphere

# Register SbSphere in _coin:
_coin.SbSphere_swigregister(SbSphere)

class SbSphereProjector(SbProjector):
    r"""Proxy of C++ SbSphereProjector class."""

    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 projectAndGetRotation(self, point: "SbVec2f", rot: "SbRotation") -> "SbVec3f":
        r"""projectAndGetRotation(SbSphereProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbSphereProjector_projectAndGetRotation(self, point, rot)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbSphereProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereProjector_getRotation(self, point1, point2)

    def setSphere(self, sph: "SbSphere") -> "void":
        r"""setSphere(SbSphereProjector self, SbSphere sph)"""
        return _coin.SbSphereProjector_setSphere(self, sph)

    def getSphere(self) -> "SbSphere const &":
        r"""getSphere(SbSphereProjector self) -> SbSphere"""
        return _coin.SbSphereProjector_getSphere(self)

    def setOrientToEye(self, orienttoeye: "SbBool const") -> "void":
        r"""setOrientToEye(SbSphereProjector self, SbBool const orienttoeye)"""
        return _coin.SbSphereProjector_setOrientToEye(self, orienttoeye)

    def isOrientToEye(self) -> "SbBool":
        r"""isOrientToEye(SbSphereProjector self) -> SbBool"""
        return _coin.SbSphereProjector_isOrientToEye(self)

    def setFront(self, infront: "SbBool const") -> "void":
        r"""setFront(SbSphereProjector self, SbBool const infront)"""
        return _coin.SbSphereProjector_setFront(self, infront)

    def isFront(self) -> "SbBool":
        r"""isFront(SbSphereProjector self) -> SbBool"""
        return _coin.SbSphereProjector_isFront(self)

    def isPointInFront(self, point: "SbVec3f") -> "SbBool":
        r"""isPointInFront(SbSphereProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereProjector_isPointInFront(self, point)

    def setWorkingSpace(self, space: "SbMatrix") -> "void":
        r"""setWorkingSpace(SbSphereProjector self, SbMatrix space)"""
        return _coin.SbSphereProjector_setWorkingSpace(self, space)
    __swig_destroy__ = _coin.delete_SbSphereProjector

# Register SbSphereProjector in _coin:
_coin.SbSphereProjector_swigregister(SbSphereProjector)

class SbSphereSheetProjector(SbSphereProjector):
    r"""Proxy of C++ SbSphereSheetProjector class."""

    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):
        r"""
        __init__(SbSphereSheetProjector self, SbBool const orienttoeye=1) -> SbSphereSheetProjector
        __init__(SbSphereSheetProjector self, SbSphere sph, SbBool const orienttoeye=1) -> SbSphereSheetProjector
        """
        _coin.SbSphereSheetProjector_swiginit(self, _coin.new_SbSphereSheetProjector(*args))

    def copy(self) -> "SbProjector *":
        r"""copy(SbSphereSheetProjector self) -> SbProjector"""
        return _coin.SbSphereSheetProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbSphereSheetProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSheetProjector_project(self, point)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbSphereSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSheetProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbSphereSheetProjector

# Register SbSphereSheetProjector in _coin:
_coin.SbSphereSheetProjector_swigregister(SbSphereSheetProjector)

class SbSphereSectionProjector(SbSphereProjector):
    r"""Proxy of C++ SbSphereSectionProjector class."""

    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):
        r"""
        __init__(SbSphereSectionProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSphereSectionProjector
        __init__(SbSphereSectionProjector self, SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSphereSectionProjector
        """
        _coin.SbSphereSectionProjector_swiginit(self, _coin.new_SbSphereSectionProjector(*args))

    def copy(self) -> "SbProjector *":
        r"""copy(SbSphereSectionProjector self) -> SbProjector"""
        return _coin.SbSphereSectionProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbSphereSectionProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSectionProjector_project(self, point)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbSphereSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSectionProjector_getRotation(self, point1, point2)

    def setTolerance(self, edgetol: "float const") -> "void":
        r"""setTolerance(SbSphereSectionProjector self, float const edgetol)"""
        return _coin.SbSphereSectionProjector_setTolerance(self, edgetol)

    def getTolerance(self) -> "float":
        r"""getTolerance(SbSphereSectionProjector self) -> float"""
        return _coin.SbSphereSectionProjector_getTolerance(self)

    def setRadialFactor(self, rad: "float const"=0.0) -> "void":
        r"""setRadialFactor(SbSphereSectionProjector self, float const rad=0.0)"""
        return _coin.SbSphereSectionProjector_setRadialFactor(self, rad)

    def getRadialFactor(self) -> "float":
        r"""getRadialFactor(SbSphereSectionProjector self) -> float"""
        return _coin.SbSphereSectionProjector_getRadialFactor(self)

    def isWithinTolerance(self, point: "SbVec3f") -> "SbBool":
        r"""isWithinTolerance(SbSphereSectionProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereSectionProjector_isWithinTolerance(self, point)
    __swig_destroy__ = _coin.delete_SbSphereSectionProjector

# Register SbSphereSectionProjector in _coin:
_coin.SbSphereSectionProjector_swigregister(SbSphereSectionProjector)

class SbSpherePlaneProjector(SbSphereSectionProjector):
    r"""Proxy of C++ SbSpherePlaneProjector class."""

    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):
        r"""
        __init__(SbSpherePlaneProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSpherePlaneProjector
        __init__(SbSpherePlaneProjector self, SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSpherePlaneProjector
        """
        _coin.SbSpherePlaneProjector_swiginit(self, _coin.new_SbSpherePlaneProjector(*args))

    def copy(self) -> "SbProjector *":
        r"""copy(SbSpherePlaneProjector self) -> SbProjector"""
        return _coin.SbSpherePlaneProjector_copy(self)

    def project(self, point: "SbVec2f") -> "SbVec3f":
        r"""project(SbSpherePlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSpherePlaneProjector_project(self, point)

    def getRotation(self, point1: "SbVec3f", point2: "SbVec3f") -> "SbRotation":
        r"""getRotation(SbSpherePlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSpherePlaneProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbSpherePlaneProjector

# Register SbSpherePlaneProjector in _coin:
_coin.SbSpherePlaneProjector_swigregister(SbSpherePlaneProjector)

class SbClip(object):
    r"""Proxy of C++ SbClip class."""

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

    def __init__(self, callback: "SbClipCallback *"=None, userdata: "void *"=None):
        r"""__init__(SbClip self, SbClipCallback * callback=None, void * userdata=None) -> SbClip"""
        _coin.SbClip_swiginit(self, _coin.new_SbClip(callback, userdata))

    def addVertex(self, v: "SbVec3f", vdata: "void *"=None) -> "void":
        r"""addVertex(SbClip self, SbVec3f v, void * vdata=None)"""
        return _coin.SbClip_addVertex(self, v, vdata)

    def reset(self) -> "void":
        r"""reset(SbClip self)"""
        return _coin.SbClip_reset(self)

    def clip(self, plane: "SbPlane") -> "void":
        r"""clip(SbClip self, SbPlane plane)"""
        return _coin.SbClip_clip(self, plane)

    def getNumVertices(self) -> "int":
        r"""getNumVertices(SbClip self) -> int"""
        return _coin.SbClip_getNumVertices(self)

    def getVertex(self, idx: "int const", v: "SbVec3f", vdata: "void **"=None) -> "void":
        r"""getVertex(SbClip self, int const idx, SbVec3f v, void ** vdata=None)"""
        return _coin.SbClip_getVertex(self, idx, v, vdata)

    def getVertexData(self, idx: "int const") -> "void *":
        r"""getVertexData(SbClip self, int const idx) -> void *"""
        return _coin.SbClip_getVertexData(self, idx)
    __swig_destroy__ = _coin.delete_SbClip

# Register SbClip in _coin:
_coin.SbClip_swigregister(SbClip)

class SbDPRotation(object):
    r"""Proxy of C++ SbDPRotation class."""

    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):
        r"""
        __init__(SbDPRotation self) -> SbDPRotation
        __init__(SbDPRotation self, SbVec3d axis, double const radians) -> SbDPRotation
        __init__(SbDPRotation self, double const [4] q) -> SbDPRotation
        __init__(SbDPRotation self, double const q0, double const q1, double const q2, double const q3) -> SbDPRotation
        __init__(SbDPRotation self, SbDPMatrix m) -> SbDPRotation
        __init__(SbDPRotation self, SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation
        """
        _coin.SbDPRotation_swiginit(self, _coin.new_SbDPRotation(*args))

    def getValue(self) -> "double const *":
        r"""getValue(SbDPRotation self) -> double const *"""
        return _coin.SbDPRotation_getValue(self)

    def getAxisAngle(self) -> "void":
        r"""getAxisAngle(SbDPRotation self)"""
        return _coin.SbDPRotation_getAxisAngle(self)

    def getMatrix(self) -> "void":
        r"""getMatrix(SbDPRotation self)"""
        return _coin.SbDPRotation_getMatrix(self)

    def invert(self) -> "SbDPRotation &":
        r"""invert(SbDPRotation self) -> SbDPRotation"""
        return _coin.SbDPRotation_invert(self)

    def inverse(self) -> "SbDPRotation":
        r"""inverse(SbDPRotation self) -> SbDPRotation"""
        return _coin.SbDPRotation_inverse(self)

    def setValue(self, *args) -> "SbDPRotation &":
        r"""
        setValue(SbDPRotation self, double const q0, double const q1, double const q2, double const q3) -> SbDPRotation
        setValue(SbDPRotation self, double const [4] q) -> SbDPRotation
        setValue(SbDPRotation self, SbDPMatrix m) -> SbDPRotation
        setValue(SbDPRotation self, SbVec3d axis, double const radians) -> SbDPRotation
        setValue(SbDPRotation self, SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation
        """
        return _coin.SbDPRotation_setValue(self, *args)

    def equals(self, r: "SbDPRotation", tolerance: "double") -> "SbBool":
        r"""equals(SbDPRotation self, SbDPRotation r, double tolerance) -> SbBool"""
        return _coin.SbDPRotation_equals(self, r, tolerance)

    def multVec(self, src: "SbVec3d", dst: "SbVec3d") -> "void":
        r"""multVec(SbDPRotation self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPRotation_multVec(self, src, dst)

    def scaleAngle(self, scaleFactor: "double const") -> "void":
        r"""scaleAngle(SbDPRotation self, double const scaleFactor)"""
        return _coin.SbDPRotation_scaleAngle(self, scaleFactor)

    @staticmethod
    def slerp(rot0: "SbDPRotation", rot1: "SbDPRotation", t: "double") -> "SbDPRotation":
        r"""slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"""
        return _coin.SbDPRotation_slerp(rot0, rot1, t)

    @staticmethod
    def identity() -> "SbDPRotation":
        r"""identity() -> SbDPRotation"""
        return _coin.SbDPRotation_identity()

    def output(self, fp: "FILE *") -> "void":
        r"""output(SbDPRotation self, FILE * fp)"""
        return _coin.SbDPRotation_output(self, fp)

    def __imul__(self, *args) -> "SbDPRotation &":
        r"""
        __imul__(SbDPRotation self, SbDPRotation q) -> SbDPRotation
        __imul__(SbDPRotation self, double const s) -> SbDPRotation
        """
        return _coin.SbDPRotation___imul__(self, *args)

    def __mul__(self, *args) -> "SbVec3d":
        r"""
        __mul__(SbDPRotation self, SbDPRotation u) -> SbDPRotation
        __mul__(SbDPRotation self, double const d) -> SbDPRotation
        __mul__(SbDPRotation self, SbVec3d v) -> SbVec3d
        """
        return _coin.SbDPRotation___mul__(self, *args)

    def __eq__(self, u: "SbDPRotation") -> "int":
        r"""__eq__(SbDPRotation self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___eq__(self, u)

    def __nq__(self, u: "SbDPRotation") -> "int":
        r"""__nq__(SbDPRotation self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___nq__(self, u)
    __swig_destroy__ = _coin.delete_SbDPRotation

# Register SbDPRotation in _coin:
_coin.SbDPRotation_swigregister(SbDPRotation)

def SbDPRotation_slerp(rot0: "SbDPRotation", rot1: "SbDPRotation", t: "double") -> "SbDPRotation":
    r"""SbDPRotation_slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"""
    return _coin.SbDPRotation_slerp(rot0, rot1, t)

def SbDPRotation_identity() -> "SbDPRotation":
    r"""SbDPRotation_identity() -> SbDPRotation"""
    return _coin.SbDPRotation_identity()

class SbDPLine(object):
    r"""Proxy of C++ SbDPLine class."""

    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):
        r"""
        __init__(SbDPLine self) -> SbDPLine
        __init__(SbDPLine self, SbVec3d p0, SbVec3d p1) -> SbDPLine
        """
        _coin.SbDPLine_swiginit(self, _coin.new_SbDPLine(*args))

    def setValue(self, p0: "SbVec3d", p1: "SbVec3d") -> "void":
        r"""setValue(SbDPLine self, SbVec3d p0, SbVec3d p1)"""
        return _coin.SbDPLine_setValue(self, p0, p1)

    def setPosDir(self, position: "SbVec3d", direction: "SbVec3d") -> "void":
        r"""setPosDir(SbDPLine self, SbVec3d position, SbVec3d direction)"""
        return _coin.SbDPLine_setPosDir(self, position, direction)

    def getClosestPoints(self, line2: "SbDPLine", ptOnThis: "SbVec3d", ptOnLine2: "SbVec3d") -> "SbBool":
        r"""getClosestPoints(SbDPLine self, SbDPLine line2, SbVec3d ptOnThis, SbVec3d ptOnLine2) -> SbBool"""
        return _coin.SbDPLine_getClosestPoints(self, line2, ptOnThis, ptOnLine2)

    def getClosestPoint(self, point: "SbVec3d") -> "SbVec3d":
        r"""getClosestPoint(SbDPLine self, SbVec3d point) -> SbVec3d"""
        return _coin.SbDPLine_getClosestPoint(self, point)

    def getPosition(self) -> "SbVec3d const &":
        r"""getPosition(SbDPLine self) -> SbVec3d"""
        return _coin.SbDPLine_getPosition(self)

    def getDirection(self) -> "SbVec3d const &":
        r"""getDirection(SbDPLine self) -> SbVec3d"""
        return _coin.SbDPLine_getDirection(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbDPLine self, FILE * file)"""
        return _coin.SbDPLine_output(self, file)
    __swig_destroy__ = _coin.delete_SbDPLine

# Register SbDPLine in _coin:
_coin.SbDPLine_swigregister(SbDPLine)

class SbDPPlane(object):
    r"""Proxy of C++ SbDPPlane class."""

    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):
        r"""
        __init__(SbDPPlane self) -> SbDPPlane
        __init__(SbDPPlane self, SbVec3d normal, double const D) -> SbDPPlane
        __init__(SbDPPlane self, SbVec3d p0, SbVec3d p1, SbVec3d p2) -> SbDPPlane
        __init__(SbDPPlane self, SbVec3d normal, SbVec3d point) -> SbDPPlane
        """
        _coin.SbDPPlane_swiginit(self, _coin.new_SbDPPlane(*args))

    def offset(self, d: "double const") -> "void":
        r"""offset(SbDPPlane self, double const d)"""
        return _coin.SbDPPlane_offset(self, d)

    def transform(self) -> "void":
        r"""transform(SbDPPlane self)"""
        return _coin.SbDPPlane_transform(self)

    def isInHalfSpace(self, point: "SbVec3d") -> "SbBool":
        r"""isInHalfSpace(SbDPPlane self, SbVec3d point) -> SbBool"""
        return _coin.SbDPPlane_isInHalfSpace(self, point)

    def getDistance(self, point: "SbVec3d") -> "double":
        r"""getDistance(SbDPPlane self, SbVec3d point) -> double"""
        return _coin.SbDPPlane_getDistance(self, point)

    def getNormal(self) -> "SbVec3d const &":
        r"""getNormal(SbDPPlane self) -> SbVec3d"""
        return _coin.SbDPPlane_getNormal(self)

    def getDistanceFromOrigin(self) -> "double":
        r"""getDistanceFromOrigin(SbDPPlane self) -> double"""
        return _coin.SbDPPlane_getDistanceFromOrigin(self)

    def output(self, file: "FILE *") -> "void":
        r"""output(SbDPPlane self, FILE * file)"""
        return _coin.SbDPPlane_output(self, file)

    def intersect(self, *args) -> "SbBool":
        r"""
        intersect(SbDPPlane self, SbDPLine l, SbVec3d intersection) -> SbBool
        intersect(SbDPPlane self, SbDPPlane pl, SbDPLine line) -> SbBool
        """
        return _coin.SbDPPlane_intersect(self, *args)

    def __eq__(self, u: "SbDPPlane") -> "int":
        r"""__eq__(SbDPPlane self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___eq__(self, u)

    def __ne__(self, u: "SbDPPlane") -> "int":
        r"""__ne__(SbDPPlane self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbDPPlane

# Register SbDPPlane in _coin:
_coin.SbDPPlane_swigregister(SbDPPlane)

class SbHeapFuncs(object):
    r"""Proxy of C++ SbHeapFuncs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    eval_func = property(_coin.SbHeapFuncs_eval_func_get, _coin.SbHeapFuncs_eval_func_set, doc=r"""eval_func : p.f(p.void).float""")
    get_index_func = property(_coin.SbHeapFuncs_get_index_func_get, _coin.SbHeapFuncs_get_index_func_set, doc=r"""get_index_func : p.f(p.void).int""")
    set_index_func = property(_coin.SbHeapFuncs_set_index_func_get, _coin.SbHeapFuncs_set_index_func_set, doc=r"""set_index_func : p.f(p.void,int).void""")

    def __init__(self):
        r"""__init__(SbHeapFuncs self) -> SbHeapFuncs"""
        _coin.SbHeapFuncs_swiginit(self, _coin.new_SbHeapFuncs())
    __swig_destroy__ = _coin.delete_SbHeapFuncs

# Register SbHeapFuncs in _coin:
_coin.SbHeapFuncs_swigregister(SbHeapFuncs)

class SbHeap(object):
    r"""Proxy of C++ SbHeap class."""

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

    def __init__(self, SbHeapFuncs: "SbHeapFuncs", initsize: "int const"=1024):
        r"""__init__(SbHeap self, SbHeapFuncs SbHeapFuncs, int const initsize=1024) -> SbHeap"""
        _coin.SbHeap_swiginit(self, _coin.new_SbHeap(SbHeapFuncs, initsize))
    __swig_destroy__ = _coin.delete_SbHeap

    def emptyHeap(self) -> "void":
        r"""emptyHeap(SbHeap self)"""
        return _coin.SbHeap_emptyHeap(self)

    def size(self) -> "int":
        r"""size(SbHeap self) -> int"""
        return _coin.SbHeap_size(self)

    def add(self, obj: "void *") -> "int":
        r"""add(SbHeap self, void * obj) -> int"""
        return _coin.SbHeap_add(self, obj)

    def remove(self, *args) -> "void":
        r"""
        remove(SbHeap self, int const pos)
        remove(SbHeap self, void * obj)
        """
        return _coin.SbHeap_remove(self, *args)

    def extractMin(self) -> "void *":
        r"""extractMin(SbHeap self) -> void *"""
        return _coin.SbHeap_extractMin(self)

    def getMin(self) -> "void *":
        r"""getMin(SbHeap self) -> void *"""
        return _coin.SbHeap_getMin(self)

    def newWeight(self, obj: "void *", hpos: "int"=-1) -> "void":
        r"""newWeight(SbHeap self, void * obj, int hpos=-1)"""
        return _coin.SbHeap_newWeight(self, obj, hpos)

    def buildHeap(self, progresscb: "SbBool (*)(float,void *)"=None, data: "void *"=None) -> "SbBool":
        r"""buildHeap(SbHeap self, SbBool (*)(float,void *) progresscb=None, void * data=None) -> SbBool"""
        return _coin.SbHeap_buildHeap(self, progresscb, data)

    def traverseHeap(self, func: "SbBool (*)(void *,void *)", userdata: "void *") -> "SbBool":
        r"""traverseHeap(SbHeap self, SbBool (*)(void *,void *) func, void * userdata) -> SbBool"""
        return _coin.SbHeap_traverseHeap(self, func, userdata)

# Register SbHeap in _coin:
_coin.SbHeap_swigregister(SbHeap)

class SbImage(object):
    r"""Proxy of C++ SbImage class."""

    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):
        r"""
        __init__(SbImage self) -> SbImage
        __init__(SbImage self, unsigned char const * bytes) -> SbImage
        __init__(SbImage self, unsigned char const * bytes) -> SbImage
        __init__(SbImage self, SbImage image) -> SbImage
        """
        _coin.SbImage_swiginit(self, _coin.new_SbImage(*args))
    __swig_destroy__ = _coin.delete_SbImage

    def setValue(self, *args) -> "void":
        r"""
        setValue(SbImage self, SbVec2s size)
        setValue(SbImage self, SbVec3s size)
        """
        return _coin.SbImage_setValue(self, *args)

    def setValuePtr(self, *args) -> "void":
        r"""
        setValuePtr(SbImage self, SbVec2s size)
        setValuePtr(SbImage self, SbVec3s size)
        """
        return _coin.SbImage_setValuePtr(self, *args)

    def getSize(self) -> "SbVec3s":
        r"""getSize(SbImage self) -> SbVec3s"""
        return _coin.SbImage_getSize(self)

    def readFile(self, filename: "SbString", searchdirectories: "SbString const *const *"=None, numdirectories: "int const"=0) -> "SbBool":
        r"""readFile(SbImage self, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool"""
        return _coin.SbImage_readFile(self, filename, searchdirectories, numdirectories)

    def __eq__(self, image: "SbImage") -> "int":
        r"""__eq__(SbImage self, SbImage image) -> int"""
        return _coin.SbImage___eq__(self, image)

    def __ne__(self, image: "SbImage") -> "int":
        r"""__ne__(SbImage self, SbImage image) -> int"""
        return _coin.SbImage___ne__(self, image)

    @staticmethod
    def addReadImageCB(cb: "SbImageReadImageCB *", closure: "void *") -> "void":
        r"""addReadImageCB(SbImageReadImageCB * cb, void * closure)"""
        return _coin.SbImage_addReadImageCB(cb, closure)

    @staticmethod
    def removeReadImageCB(cb: "SbImageReadImageCB *", closure: "void *") -> "void":
        r"""removeReadImageCB(SbImageReadImageCB * cb, void * closure)"""
        return _coin.SbImage_removeReadImageCB(cb, closure)

    @staticmethod
    def searchForFile(basename: "SbString", dirlist: "SbString const *const *", numdirs: "int const") -> "SbString":
        r"""searchForFile(SbString basename, SbString const *const * dirlist, int const numdirs) -> SbString"""
        return _coin.SbImage_searchForFile(basename, dirlist, numdirs)

    def hasData(self) -> "SbBool":
        r"""hasData(SbImage self) -> SbBool"""
        return _coin.SbImage_hasData(self)

    def readLock(self) -> "void":
        r"""readLock(SbImage self)"""
        return _coin.SbImage_readLock(self)

    def readUnlock(self) -> "void":
        r"""readUnlock(SbImage self)"""
        return _coin.SbImage_readUnlock(self)

    def scheduleReadFile(self, cb: "SbImageScheduleReadCB *", closure: "void *", filename: "SbString", searchdirectories: "SbString const *const *"=None, numdirectories: "int const"=0) -> "SbBool":
        r"""scheduleReadFile(SbImage self, SbImageScheduleReadCB * cb, void * closure, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool"""
        return _coin.SbImage_scheduleReadFile(self, cb, closure, filename, searchdirectories, numdirectories)

    def getValue(self, *args) -> "PyObject *":
        r"""
        getValue(SbImage self, SbVec2s size, int & bytesperpixel) -> unsigned char
        getValue(SbImage self, SbVec3s size, int & bytesperpixel) -> unsigned char
        getValue(SbImage self) -> PyObject *
        """
        return _coin.SbImage_getValue(self, *args)

# Register SbImage in _coin:
_coin.SbImage_swigregister(SbImage)

def SbImage_addReadImageCB(cb: "SbImageReadImageCB *", closure: "void *") -> "void":
    r"""SbImage_addReadImageCB(SbImageReadImageCB * cb, void * closure)"""
    return _coin.SbImage_addReadImageCB(cb, closure)

def SbImage_removeReadImageCB(cb: "SbImageReadImageCB *", closure: "void *") -> "void":
    r"""SbImage_removeReadImageCB(SbImageReadImageCB * cb, void * closure)"""
    return _coin.SbImage_removeReadImageCB(cb, closure)

def SbImage_searchForFile(basename: "SbString", dirlist: "SbString const *const *", numdirs: "int const") -> "SbString":
    r"""SbImage_searchForFile(SbString basename, SbString const *const * dirlist, int const numdirs) -> SbString"""
    return _coin.SbImage_searchForFile(basename, dirlist, numdirs)

class SbOctTreeFuncs(object):
    r"""Proxy of C++ SbOctTreeFuncs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ptinsidefunc = property(_coin.SbOctTreeFuncs_ptinsidefunc_get, _coin.SbOctTreeFuncs_ptinsidefunc_set, doc=r"""ptinsidefunc : p.f(q(const).p.void,r.q(const).SbVec3f).SbBool""")
    insideboxfunc = property(_coin.SbOctTreeFuncs_insideboxfunc_get, _coin.SbOctTreeFuncs_insideboxfunc_set, doc=r"""insideboxfunc : p.f(q(const).p.void,r.q(const).SbBox3f).SbBool""")
    insidespherefunc = property(_coin.SbOctTreeFuncs_insidespherefunc_get, _coin.SbOctTreeFuncs_insidespherefunc_set, doc=r"""insidespherefunc : p.f(q(const).p.void,r.q(const).SbSphere).SbBool""")
    insideplanesfunc = property(_coin.SbOctTreeFuncs_insideplanesfunc_get, _coin.SbOctTreeFuncs_insideplanesfunc_set, doc=r"""insideplanesfunc : p.f(q(const).p.void,q(const).p.q(const).SbPlane,q(const).int).SbBool""")

    def __init__(self):
        r"""__init__(SbOctTreeFuncs self) -> SbOctTreeFuncs"""
        _coin.SbOctTreeFuncs_swiginit(self, _coin.new_SbOctTreeFuncs())
    __swig_destroy__ = _coin.delete_SbOctTreeFuncs

# Register SbOctTreeFuncs in _coin:
_coin.SbOctTreeFuncs_swigregister(SbOctTreeFuncs)

class SbOctTree(object):
    r"""Proxy of C++ SbOctTree class."""

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

    def __init__(self, bbox: "SbBox3f", itemfuncs: "SbOctTreeFuncs", maxitemspernode: "int const"=64):
        r"""__init__(SbOctTree self, SbBox3f bbox, SbOctTreeFuncs itemfuncs, int const maxitemspernode=64) -> SbOctTree"""
        _coin.SbOctTree_swiginit(self, _coin.new_SbOctTree(bbox, itemfuncs, maxitemspernode))
    __swig_destroy__ = _coin.delete_SbOctTree

    def addItem(self, item: "void *const") -> "void":
        r"""addItem(SbOctTree self, void *const item)"""
        return _coin.SbOctTree_addItem(self, item)

    def removeItem(self, item: "void *const") -> "void":
        r"""removeItem(SbOctTree self, void *const item)"""
        return _coin.SbOctTree_removeItem(self, item)

    def findItems(self, *args) -> "void":
        r"""
        findItems(SbOctTree self, SbVec3f pos, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbBox3f box, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbSphere sphere, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbPlane planes, int const numplanes, SbList< void * > & destarray, SbBool const removeduplicates=1)
        """
        return _coin.SbOctTree_findItems(self, *args)

    def getBoundingBox(self) -> "SbBox3f const &":
        r"""getBoundingBox(SbOctTree self) -> SbBox3f"""
        return _coin.SbOctTree_getBoundingBox(self)

    def clear(self) -> "void":
        r"""clear(SbOctTree self)"""
        return _coin.SbOctTree_clear(self)

    def debugTree(self, fp: "FILE *") -> "void":
        r"""debugTree(SbOctTree self, FILE * fp)"""
        return _coin.SbOctTree_debugTree(self, fp)

# Register SbOctTree in _coin:
_coin.SbOctTree_swigregister(SbOctTree)

class SbTesselator(object):
    r"""Proxy of C++ SbTesselator class."""

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

    def __init__(self, func: "SbTesselatorCB *"=None, data: "void *"=None):
        r"""__init__(SbTesselator self, SbTesselatorCB * func=None, void * data=None) -> SbTesselator"""
        _coin.SbTesselator_swiginit(self, _coin.new_SbTesselator(func, data))
    __swig_destroy__ = _coin.delete_SbTesselator

    def beginPolygon(self, *args) -> "void":
        r"""beginPolygon(SbTesselator self, SbBool keepVertices=0, SbVec3f normal=SbVec3f(0.0f, 0.0f, 0.0f))"""
        return _coin.SbTesselator_beginPolygon(self, *args)

    def addVertex(self, v: "SbVec3f", data: "void *") -> "void":
        r"""addVertex(SbTesselator self, SbVec3f v, void * data)"""
        return _coin.SbTesselator_addVertex(self, v, data)

    def endPolygon(self) -> "void":
        r"""endPolygon(SbTesselator self)"""
        return _coin.SbTesselator_endPolygon(self)

    def setCallback(self, func: "SbTesselatorCB *", data: "void *") -> "void":
        r"""setCallback(SbTesselator self, SbTesselatorCB * func, void * data)"""
        return _coin.SbTesselator_setCallback(self, func, data)

# Register SbTesselator in _coin:
_coin.SbTesselator_swigregister(SbTesselator)

class SoTimerQueueSensor(SoSensor):
    r"""Proxy of C++ SoTimerQueueSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoTimerQueueSensor *"))
          newobj = _coin.new_SoTimerQueueSensor_scb_v(*args)
       else:
          self.this = _coin.new_SoTimerQueueSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoTimerQueueSensor

    def getTriggerTime(self) -> "SbTime const &":
        r"""getTriggerTime(SoTimerQueueSensor self) -> SbTime"""
        return _coin.SoTimerQueueSensor_getTriggerTime(self)

    def schedule(self) -> "void":
        r"""schedule(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_schedule(self)

    def unschedule(self) -> "void":
        r"""unschedule(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_unschedule(self)

    def isScheduled(self) -> "SbBool":
        r"""isScheduled(SoTimerQueueSensor self) -> SbBool"""
        return _coin.SoTimerQueueSensor_isScheduled(self)

    def trigger(self) -> "void":
        r"""trigger(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_trigger(self)

# Register SoTimerQueueSensor in _coin:
_coin.SoTimerQueueSensor_swigregister(SoTimerQueueSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoTimerQueueSensor *"))
      newobj = _coin.new_SoTimerQueueSensor_scb_v(*args)
   else:
      self.this = _coin.new_SoTimerQueueSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoAlarmSensor(SoTimerQueueSensor):
    r"""Proxy of C++ SoAlarmSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoAlarmSensor *"))
          newobj = _coin.new_SoAlarmSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoAlarmSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoAlarmSensor

    def setTime(self, abstime: "SbTime") -> "void":
        r"""setTime(SoAlarmSensor self, SbTime abstime)"""
        return _coin.SoAlarmSensor_setTime(self, abstime)

    def setTimeFromNow(self, reltime: "SbTime") -> "void":
        r"""setTimeFromNow(SoAlarmSensor self, SbTime reltime)"""
        return _coin.SoAlarmSensor_setTimeFromNow(self, reltime)

    def getTime(self) -> "SbTime const &":
        r"""getTime(SoAlarmSensor self) -> SbTime"""
        return _coin.SoAlarmSensor_getTime(self)

    def schedule(self) -> "void":
        r"""schedule(SoAlarmSensor self)"""
        return _coin.SoAlarmSensor_schedule(self)

# Register SoAlarmSensor in _coin:
_coin.SoAlarmSensor_swigregister(SoAlarmSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoAlarmSensor *"))
      newobj = _coin.new_SoAlarmSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoAlarmSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoIdleSensor(SoDelayQueueSensor):
    r"""Proxy of C++ SoIdleSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoIdleSensor *"))
          newobj = _coin.new_SoIdleSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoIdleSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoIdleSensor

# Register SoIdleSensor in _coin:
_coin.SoIdleSensor_swigregister(SoIdleSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoIdleSensor *"))
      newobj = _coin.new_SoIdleSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoIdleSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoNodeSensor(SoDataSensor):
    r"""Proxy of C++ SoNodeSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoNodeSensor *"))
          newobj = _coin.new_SoNodeSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoNodeSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoNodeSensor

    def attach(self, node: "SoNode") -> "void":
        r"""attach(SoNodeSensor self, SoNode node)"""
        return _coin.SoNodeSensor_attach(self, node)

    def detach(self) -> "void":
        r"""detach(SoNodeSensor self)"""
        return _coin.SoNodeSensor_detach(self)

    def getAttachedNode(self) -> "SoNode *":
        r"""getAttachedNode(SoNodeSensor self) -> SoNode"""
        return _coin.SoNodeSensor_getAttachedNode(self)

# Register SoNodeSensor in _coin:
_coin.SoNodeSensor_swigregister(SoNodeSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoNodeSensor *"))
      newobj = _coin.new_SoNodeSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoNodeSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoOneShotSensor(SoDelayQueueSensor):
    r"""Proxy of C++ SoOneShotSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoOneShotSensor *"))
          newobj = _coin.new_SoOneShotSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoOneShotSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoOneShotSensor

# Register SoOneShotSensor in _coin:
_coin.SoOneShotSensor_swigregister(SoOneShotSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoOneShotSensor *"))
      newobj = _coin.new_SoOneShotSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoOneShotSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoPathSensor(SoDataSensor):
    r"""Proxy of C++ SoPathSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoPathSensor *"))
          newobj = _coin.new_SoPathSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoPathSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoPathSensor
    PATH = _coin.SoPathSensor_PATH
    
    NODES = _coin.SoPathSensor_NODES
    
    PATH_AND_NODES = _coin.SoPathSensor_PATH_AND_NODES
    

    def setTriggerFilter(self, type: "SoPathSensor::TriggerFilter const") -> "void":
        r"""setTriggerFilter(SoPathSensor self, SoPathSensor::TriggerFilter const type)"""
        return _coin.SoPathSensor_setTriggerFilter(self, type)

    def getTriggerFilter(self) -> "SoPathSensor::TriggerFilter":
        r"""getTriggerFilter(SoPathSensor self) -> SoPathSensor::TriggerFilter"""
        return _coin.SoPathSensor_getTriggerFilter(self)

    def attach(self, path: "SoPath") -> "void":
        r"""attach(SoPathSensor self, SoPath path)"""
        return _coin.SoPathSensor_attach(self, path)

    def detach(self) -> "void":
        r"""detach(SoPathSensor self)"""
        return _coin.SoPathSensor_detach(self)

    def getAttachedPath(self) -> "SoPath *":
        r"""getAttachedPath(SoPathSensor self) -> SoPath"""
        return _coin.SoPathSensor_getAttachedPath(self)

# Register SoPathSensor in _coin:
_coin.SoPathSensor_swigregister(SoPathSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoPathSensor *"))
      newobj = _coin.new_SoPathSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoPathSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoTimerSensor(SoTimerQueueSensor):
    r"""Proxy of C++ SoTimerSensor class."""

    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):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoTimerSensor *"))
          newobj = _coin.new_SoTimerSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoTimerSensor(*args)


       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoTimerSensor

    def setBaseTime(self, base: "SbTime") -> "void":
        r"""setBaseTime(SoTimerSensor self, SbTime base)"""
        return _coin.SoTimerSensor_setBaseTime(self, base)

    def getBaseTime(self) -> "SbTime const &":
        r"""getBaseTime(SoTimerSensor self) -> SbTime"""
        return _coin.SoTimerSensor_getBaseTime(self)

    def setInterval(self, interval: "SbTime") -> "void":
        r"""setInterval(SoTimerSensor self, SbTime interval)"""
        return _coin.SoTimerSensor_setInterval(self, interval)

    def getInterval(self) -> "SbTime const &":
        r"""getInterval(SoTimerSensor self) -> SbTime"""
        return _coin.SoTimerSensor_getInterval(self)

    def schedule(self) -> "void":
        r"""schedule(SoTimerSensor self)"""
        return _coin.SoTimerSensor_schedule(self)

    def unschedule(self) -> "void":
        r"""unschedule(SoTimerSensor self)"""
        return _coin.SoTimerSensor_unschedule(self)

    def reschedule(self, schedtime: "SbTime") -> "void":
        r"""reschedule(SoTimerSensor self, SbTime schedtime)"""
        return _coin.SoTimerSensor_reschedule(self, schedtime)

# Register SoTimerSensor in _coin:
_coin.SoTimerSensor_swigregister(SoTimerSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoTimerSensor *"))
      newobj = _coin.new_SoTimerSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoTimerSensor(*args)


   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoInteraction(object):
    r"""Proxy of C++ SoInteraction class."""

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

    @staticmethod
    def init() -> "void":
        r"""init()"""
        return _coin.SoInteraction_init()

    def __init__(self):
        r"""__init__(SoInteraction self) -> SoInteraction"""
        _coin.SoInteraction_swiginit(self, _coin.new_SoInteraction())
    __swig_destroy__ = _coin.delete_SoInteraction

# Register SoInteraction in _coin:
_coin.SoInteraction_swigregister(SoInteraction)

def SoInteraction_init() -> "void":
    r"""SoInteraction_init()"""
    return _coin.SoInteraction_init()

class SoOffscreenRenderer(object):
    r"""Proxy of C++ SoOffscreenRenderer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LUMINANCE = _coin.SoOffscreenRenderer_LUMINANCE
    
    LUMINANCE_TRANSPARENCY = _coin.SoOffscreenRenderer_LUMINANCE_TRANSPARENCY
    
    RGB = _coin.SoOffscreenRenderer_RGB
    
    RGB_TRANSPARENCY = _coin.SoOffscreenRenderer_RGB_TRANSPARENCY
    

    def __init__(self, *args):
        r"""
        __init__(SoOffscreenRenderer self, SbViewportRegion viewportregion) -> SoOffscreenRenderer
        __init__(SoOffscreenRenderer self, SoGLRenderAction action) -> SoOffscreenRenderer
        """
        _coin.SoOffscreenRenderer_swiginit(self, _coin.new_SoOffscreenRenderer(*args))
    __swig_destroy__ = _coin.delete_SoOffscreenRenderer

    @staticmethod
    def getScreenPixelsPerInch() -> "float":
        r"""getScreenPixelsPerInch() -> float"""
        return _coin.SoOffscreenRenderer_getScreenPixelsPerInch()

    @staticmethod
    def getMaximumResolution() -> "SbVec2s":
        r"""getMaximumResolution() -> SbVec2s"""
        return _coin.SoOffscreenRenderer_getMaximumResolution()

    def setComponents(self, components: "SoOffscreenRenderer::Components const") -> "void":
        r"""setComponents(SoOffscreenRenderer self, SoOffscreenRenderer::Components const components)"""
        return _coin.SoOffscreenRenderer_setComponents(self, components)

    def getComponents(self) -> "SoOffscreenRenderer::Components":
        r"""getComponents(SoOffscreenRenderer self) -> SoOffscreenRenderer::Components"""
        return _coin.SoOffscreenRenderer_getComponents(self)

    def setViewportRegion(self, region: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoOffscreenRenderer self, SbViewportRegion region)"""
        return _coin.SoOffscreenRenderer_setViewportRegion(self, region)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoOffscreenRenderer self) -> SbViewportRegion"""
        return _coin.SoOffscreenRenderer_getViewportRegion(self)

    def setBackgroundColor(self, color: "SbColor") -> "void":
        r"""setBackgroundColor(SoOffscreenRenderer self, SbColor color)"""
        return _coin.SoOffscreenRenderer_setBackgroundColor(self, color)

    def getBackgroundColor(self) -> "SbColor const &":
        r"""getBackgroundColor(SoOffscreenRenderer self) -> SbColor"""
        return _coin.SoOffscreenRenderer_getBackgroundColor(self)

    def setGLRenderAction(self, action: "SoGLRenderAction") -> "void":
        r"""setGLRenderAction(SoOffscreenRenderer self, SoGLRenderAction action)"""
        return _coin.SoOffscreenRenderer_setGLRenderAction(self, action)

    def getGLRenderAction(self) -> "SoGLRenderAction *":
        r"""getGLRenderAction(SoOffscreenRenderer self) -> SoGLRenderAction"""
        return _coin.SoOffscreenRenderer_getGLRenderAction(self)

    def render(self, *args) -> "SbBool":
        r"""
        render(SoOffscreenRenderer self, SoNode scene) -> SbBool
        render(SoOffscreenRenderer self, SoPath scene) -> SbBool
        """
        return _coin.SoOffscreenRenderer_render(self, *args)

    def getDC(self) -> "void const *const &":
        r"""getDC(SoOffscreenRenderer self) -> void const *const &"""
        return _coin.SoOffscreenRenderer_getDC(self)

    def writeToRGB(self, *args) -> "SbBool":
        r"""
        writeToRGB(SoOffscreenRenderer self, FILE * fp) -> SbBool
        writeToRGB(SoOffscreenRenderer self, char const * filename) -> SbBool
        """
        return _coin.SoOffscreenRenderer_writeToRGB(self, *args)

    def writeToPostScript(self, *args) -> "SbBool":
        r"""
        writeToPostScript(SoOffscreenRenderer self, FILE * fp) -> SbBool
        writeToPostScript(SoOffscreenRenderer self, FILE * fp, SbVec2f printsize) -> SbBool
        writeToPostScript(SoOffscreenRenderer self, char const * filename) -> SbBool
        writeToPostScript(SoOffscreenRenderer self, char const * filename, SbVec2f printsize) -> SbBool
        """
        return _coin.SoOffscreenRenderer_writeToPostScript(self, *args)

    def isWriteSupported(self, filetypeextension: "SbName") -> "SbBool":
        r"""isWriteSupported(SoOffscreenRenderer self, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_isWriteSupported(self, filetypeextension)

    def getNumWriteFiletypes(self) -> "int":
        r"""getNumWriteFiletypes(SoOffscreenRenderer self) -> int"""
        return _coin.SoOffscreenRenderer_getNumWriteFiletypes(self)

    def getWriteFiletypeInfo(self, idx: "int const", extlist: "SbPList", fullname: "SbString", description: "SbString") -> "void":
        r"""getWriteFiletypeInfo(SoOffscreenRenderer self, int const idx, SbPList extlist, SbString fullname, SbString description)"""
        return _coin.SoOffscreenRenderer_getWriteFiletypeInfo(self, idx, extlist, fullname, description)

    def writeToFile(self, filename: "SbString", filetypeextension: "SbName") -> "SbBool":
        r"""writeToFile(SoOffscreenRenderer self, SbString filename, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_writeToFile(self, filename, filetypeextension)

    def setPbufferEnable(self, enable: "SbBool") -> "void":
        r"""setPbufferEnable(SoOffscreenRenderer self, SbBool enable)"""
        return _coin.SoOffscreenRenderer_setPbufferEnable(self, enable)

    def getPbufferEnable(self) -> "SbBool":
        r"""getPbufferEnable(SoOffscreenRenderer self) -> SbBool"""
        return _coin.SoOffscreenRenderer_getPbufferEnable(self)

    def getBuffer(self, *args) -> "PyObject *":
        r"""
        getBuffer(SoOffscreenRenderer self) -> unsigned char
        getBuffer(SoOffscreenRenderer self) -> PyObject *
        """
        return _coin.SoOffscreenRenderer_getBuffer(self, *args)

# Register SoOffscreenRenderer in _coin:
_coin.SoOffscreenRenderer_swigregister(SoOffscreenRenderer)

def SoOffscreenRenderer_getScreenPixelsPerInch() -> "float":
    r"""SoOffscreenRenderer_getScreenPixelsPerInch() -> float"""
    return _coin.SoOffscreenRenderer_getScreenPixelsPerInch()

def SoOffscreenRenderer_getMaximumResolution() -> "SbVec2s":
    r"""SoOffscreenRenderer_getMaximumResolution() -> SbVec2s"""
    return _coin.SoOffscreenRenderer_getMaximumResolution()

class SoPickedPoint(object):
    r"""Proxy of C++ SoPickedPoint class."""

    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):
        r"""
        __init__(SoPickedPoint self, SoPickedPoint pp) -> SoPickedPoint
        __init__(SoPickedPoint self, SoPath path, SoState state, SbVec3f objSpacePoint) -> SoPickedPoint
        """
        _coin.SoPickedPoint_swiginit(self, _coin.new_SoPickedPoint(*args))
    __swig_destroy__ = _coin.delete_SoPickedPoint

    def copy(self) -> "SoPickedPoint *":
        r"""copy(SoPickedPoint self) -> SoPickedPoint"""
        return _coin.SoPickedPoint_copy(self)

    def getPoint(self) -> "SbVec3f const &":
        r"""getPoint(SoPickedPoint self) -> SbVec3f"""
        return _coin.SoPickedPoint_getPoint(self)

    def getNormal(self) -> "SbVec3f const &":
        r"""getNormal(SoPickedPoint self) -> SbVec3f"""
        return _coin.SoPickedPoint_getNormal(self)

    def getTextureCoords(self) -> "SbVec4f const &":
        r"""getTextureCoords(SoPickedPoint self) -> SbVec4f"""
        return _coin.SoPickedPoint_getTextureCoords(self)

    def getMaterialIndex(self) -> "int":
        r"""getMaterialIndex(SoPickedPoint self) -> int"""
        return _coin.SoPickedPoint_getMaterialIndex(self)

    def getPath(self) -> "SoPath *":
        r"""getPath(SoPickedPoint self) -> SoPath"""
        return _coin.SoPickedPoint_getPath(self)

    def isOnGeometry(self) -> "SbBool":
        r"""isOnGeometry(SoPickedPoint self) -> SbBool"""
        return _coin.SoPickedPoint_isOnGeometry(self)

    def getDetail(self, node: "SoNode"=None) -> "SoDetail const *":
        r"""getDetail(SoPickedPoint self, SoNode node=None) -> SoDetail"""
        return _coin.SoPickedPoint_getDetail(self, node)

    def getObjectToWorld(self, node: "SoNode"=None) -> "SbMatrix const &":
        r"""getObjectToWorld(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getObjectToWorld(self, node)

    def getWorldToObject(self, node: "SoNode"=None) -> "SbMatrix const &":
        r"""getWorldToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getWorldToObject(self, node)

    def getObjectToImage(self, node: "SoNode"=None) -> "SbMatrix const &":
        r"""getObjectToImage(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getObjectToImage(self, node)

    def getImageToObject(self, node: "SoNode"=None) -> "SbMatrix const &":
        r"""getImageToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getImageToObject(self, node)

    def getObjectPoint(self, node: "SoNode"=None) -> "SbVec3f":
        r"""getObjectPoint(SoPickedPoint self, SoNode node=None) -> SbVec3f"""
        return _coin.SoPickedPoint_getObjectPoint(self, node)

    def getObjectNormal(self, node: "SoNode"=None) -> "SbVec3f":
        r"""getObjectNormal(SoPickedPoint self, SoNode node=None) -> SbVec3f"""
        return _coin.SoPickedPoint_getObjectNormal(self, node)

    def getObjectTextureCoords(self, node: "SoNode"=None) -> "SbVec4f":
        r"""getObjectTextureCoords(SoPickedPoint self, SoNode node=None) -> SbVec4f"""
        return _coin.SoPickedPoint_getObjectTextureCoords(self, node)

    def setObjectNormal(self, normal: "SbVec3f") -> "void":
        r"""setObjectNormal(SoPickedPoint self, SbVec3f normal)"""
        return _coin.SoPickedPoint_setObjectNormal(self, normal)

    def setObjectTextureCoords(self, texCoords: "SbVec4f") -> "void":
        r"""setObjectTextureCoords(SoPickedPoint self, SbVec4f texCoords)"""
        return _coin.SoPickedPoint_setObjectTextureCoords(self, texCoords)

    def setMaterialIndex(self, index: "int const") -> "void":
        r"""setMaterialIndex(SoPickedPoint self, int const index)"""
        return _coin.SoPickedPoint_setMaterialIndex(self, index)

    def setDetail(self, detail: "SoDetail", node: "SoNode") -> "void":
        r"""setDetail(SoPickedPoint self, SoDetail detail, SoNode node)"""
        return _coin.SoPickedPoint_setDetail(self, detail, node)

# Register SoPickedPoint in _coin:
_coin.SoPickedPoint_swigregister(SoPickedPoint)

class SoPrimitiveVertex(object):
    r"""Proxy of C++ SoPrimitiveVertex class."""

    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):
        r"""
        __init__(SoPrimitiveVertex self) -> SoPrimitiveVertex
        __init__(SoPrimitiveVertex self, SoPrimitiveVertex pv) -> SoPrimitiveVertex
        """
        _coin.SoPrimitiveVertex_swiginit(self, _coin.new_SoPrimitiveVertex(*args))
    __swig_destroy__ = _coin.delete_SoPrimitiveVertex

    def getPoint(self) -> "SbVec3f const &":
        r"""getPoint(SoPrimitiveVertex self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getPoint(self)

    def getNormal(self) -> "SbVec3f const &":
        r"""getNormal(SoPrimitiveVertex self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getNormal(self)

    def getTextureCoords(self) -> "SbVec4f const &":
        r"""getTextureCoords(SoPrimitiveVertex self) -> SbVec4f"""
        return _coin.SoPrimitiveVertex_getTextureCoords(self)

    def getMaterialIndex(self) -> "int":
        r"""getMaterialIndex(SoPrimitiveVertex self) -> int"""
        return _coin.SoPrimitiveVertex_getMaterialIndex(self)

    def getPackedColor(self) -> "uint32_t":
        r"""getPackedColor(SoPrimitiveVertex self) -> uint32_t"""
        return _coin.SoPrimitiveVertex_getPackedColor(self)

    def getDetail(self) -> "SoDetail const *":
        r"""getDetail(SoPrimitiveVertex self) -> SoDetail"""
        return _coin.SoPrimitiveVertex_getDetail(self)

    def setPoint(self, *args) -> "void":
        r"""
        setPoint(SoPrimitiveVertex self, SbVec3f pt)
        setPoint(SoPrimitiveVertex self, float x, float y, float z)
        """
        return _coin.SoPrimitiveVertex_setPoint(self, *args)

    def setNormal(self, *args) -> "void":
        r"""
        setNormal(SoPrimitiveVertex self, SbVec3f n)
        setNormal(SoPrimitiveVertex self, float nx, float ny, float nz)
        """
        return _coin.SoPrimitiveVertex_setNormal(self, *args)

    def setTextureCoords(self, *args) -> "void":
        r"""
        setTextureCoords(SoPrimitiveVertex self, SbVec2f tex)
        setTextureCoords(SoPrimitiveVertex self, float tx, float ty)
        setTextureCoords(SoPrimitiveVertex self, SbVec3f tex)
        setTextureCoords(SoPrimitiveVertex self, float tx, float ty, float tz)
        setTextureCoords(SoPrimitiveVertex self, SbVec4f tex)
        setTextureCoords(SoPrimitiveVertex self, float tx, float ty, float tz, float tw)
        """
        return _coin.SoPrimitiveVertex_setTextureCoords(self, *args)

    def setMaterialIndex(self, index: "int") -> "void":
        r"""setMaterialIndex(SoPrimitiveVertex self, int index)"""
        return _coin.SoPrimitiveVertex_setMaterialIndex(self, index)

    def setPackedColor(self, rgba: "uint32_t") -> "void":
        r"""setPackedColor(SoPrimitiveVertex self, uint32_t rgba)"""
        return _coin.SoPrimitiveVertex_setPackedColor(self, rgba)

    def setDetail(self, d: "SoDetail") -> "void":
        r"""setDetail(SoPrimitiveVertex self, SoDetail d)"""
        return _coin.SoPrimitiveVertex_setDetail(self, d)

# Register SoPrimitiveVertex in _coin:
_coin.SoPrimitiveVertex_swigregister(SoPrimitiveVertex)

class SoSceneManager(object):
    r"""Proxy of C++ SoSceneManager class."""

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

    def __init__(self):
        r"""__init__(SoSceneManager self) -> SoSceneManager"""
        _coin.SoSceneManager_swiginit(self, _coin.new_SoSceneManager())
    __swig_destroy__ = _coin.delete_SoSceneManager

    def render(self, *args) -> "void":
        r"""
        render(SoSceneManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoSceneManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        """
        return _coin.SoSceneManager_render(self, *args)

    def setCamera(self, camera: "SoCamera") -> "void":
        r"""setCamera(SoSceneManager self, SoCamera camera)"""
        return _coin.SoSceneManager_setCamera(self, camera)

    def getCamera(self) -> "SoCamera *":
        r"""getCamera(SoSceneManager self) -> SoCamera"""
        return _coin.SoSceneManager_getCamera(self)

    def processEvent(self, event: "SoEvent") -> "SbBool":
        r"""processEvent(SoSceneManager self, SoEvent event) -> SbBool"""
        return _coin.SoSceneManager_processEvent(self, event)

    def reinitialize(self) -> "void":
        r"""reinitialize(SoSceneManager self)"""
        return _coin.SoSceneManager_reinitialize(self)

    def scheduleRedraw(self) -> "void":
        r"""scheduleRedraw(SoSceneManager self)"""
        return _coin.SoSceneManager_scheduleRedraw(self)

    def setSceneGraph(self, sceneroot: "SoNode") -> "void":
        r"""setSceneGraph(SoSceneManager self, SoNode sceneroot)"""
        return _coin.SoSceneManager_setSceneGraph(self, sceneroot)

    def getSceneGraph(self) -> "SoNode *":
        r"""getSceneGraph(SoSceneManager self) -> SoNode"""
        return _coin.SoSceneManager_getSceneGraph(self)

    def setWindowSize(self, newsize: "SbVec2s") -> "void":
        r"""setWindowSize(SoSceneManager self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setWindowSize(self, newsize)

    def getWindowSize(self) -> "SbVec2s const &":
        r"""getWindowSize(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getWindowSize(self)

    def setSize(self, newsize: "SbVec2s") -> "void":
        r"""setSize(SoSceneManager self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setSize(self, newsize)

    def getSize(self) -> "SbVec2s const &":
        r"""getSize(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getSize(self)

    def setOrigin(self, newOrigin: "SbVec2s") -> "void":
        r"""setOrigin(SoSceneManager self, SbVec2s newOrigin)"""
        return _coin.SoSceneManager_setOrigin(self, newOrigin)

    def getOrigin(self) -> "SbVec2s const &":
        r"""getOrigin(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getOrigin(self)

    def setViewportRegion(self, newRegion: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoSceneManager self, SbViewportRegion newRegion)"""
        return _coin.SoSceneManager_setViewportRegion(self, newRegion)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoSceneManager self) -> SbViewportRegion"""
        return _coin.SoSceneManager_getViewportRegion(self)

    def setBackgroundColor(self, color: "SbColor") -> "void":
        r"""setBackgroundColor(SoSceneManager self, SbColor color)"""
        return _coin.SoSceneManager_setBackgroundColor(self, color)

    def getBackgroundColor(self) -> "SbColor const &":
        r"""getBackgroundColor(SoSceneManager self) -> SbColor"""
        return _coin.SoSceneManager_getBackgroundColor(self)

    def setBackgroundIndex(self, index: "int const") -> "void":
        r"""setBackgroundIndex(SoSceneManager self, int const index)"""
        return _coin.SoSceneManager_setBackgroundIndex(self, index)

    def getBackgroundIndex(self) -> "int":
        r"""getBackgroundIndex(SoSceneManager self) -> int"""
        return _coin.SoSceneManager_getBackgroundIndex(self)

    def setRGBMode(self, onOrOff: "SbBool const") -> "void":
        r"""setRGBMode(SoSceneManager self, SbBool const onOrOff)"""
        return _coin.SoSceneManager_setRGBMode(self, onOrOff)

    def isRGBMode(self) -> "SbBool":
        r"""isRGBMode(SoSceneManager self) -> SbBool"""
        return _coin.SoSceneManager_isRGBMode(self)

    def activate(self) -> "void":
        r"""activate(SoSceneManager self)"""
        return _coin.SoSceneManager_activate(self)

    def deactivate(self) -> "void":
        r"""deactivate(SoSceneManager self)"""
        return _coin.SoSceneManager_deactivate(self)

    def isAutoRedraw(self) -> "SbBool":
        r"""isAutoRedraw(SoSceneManager self) -> SbBool"""
        return _coin.SoSceneManager_isAutoRedraw(self)

    def setRedrawPriority(self, priority: "uint32_t const") -> "void":
        r"""setRedrawPriority(SoSceneManager self, uint32_t const priority)"""
        return _coin.SoSceneManager_setRedrawPriority(self, priority)

    def getRedrawPriority(self) -> "uint32_t":
        r"""getRedrawPriority(SoSceneManager self) -> uint32_t"""
        return _coin.SoSceneManager_getRedrawPriority(self)

    def setAntialiasing(self, smoothing: "SbBool const", numPasses: "int const") -> "void":
        r"""setAntialiasing(SoSceneManager self, SbBool const smoothing, int const numPasses)"""
        return _coin.SoSceneManager_setAntialiasing(self, smoothing, numPasses)

    def getAntialiasing(self, smoothing: "SbBool &", numPasses: "int &") -> "void":
        r"""getAntialiasing(SoSceneManager self, SbBool & smoothing, int & numPasses)"""
        return _coin.SoSceneManager_getAntialiasing(self, smoothing, numPasses)

    def setGLRenderAction(self, action: "SoGLRenderAction") -> "void":
        r"""setGLRenderAction(SoSceneManager self, SoGLRenderAction action)"""
        return _coin.SoSceneManager_setGLRenderAction(self, action)

    def getGLRenderAction(self) -> "SoGLRenderAction *":
        r"""getGLRenderAction(SoSceneManager self) -> SoGLRenderAction"""
        return _coin.SoSceneManager_getGLRenderAction(self)

    def setAudioRenderAction(self, action: "SoAudioRenderAction") -> "void":
        r"""setAudioRenderAction(SoSceneManager self, SoAudioRenderAction action)"""
        return _coin.SoSceneManager_setAudioRenderAction(self, action)

    def getAudioRenderAction(self) -> "SoAudioRenderAction *":
        r"""getAudioRenderAction(SoSceneManager self) -> SoAudioRenderAction"""
        return _coin.SoSceneManager_getAudioRenderAction(self)

    def setHandleEventAction(self, hea: "SoHandleEventAction") -> "void":
        r"""setHandleEventAction(SoSceneManager self, SoHandleEventAction hea)"""
        return _coin.SoSceneManager_setHandleEventAction(self, hea)

    def getHandleEventAction(self) -> "SoHandleEventAction *":
        r"""getHandleEventAction(SoSceneManager self) -> SoHandleEventAction"""
        return _coin.SoSceneManager_getHandleEventAction(self)

    @staticmethod
    def getDefaultRedrawPriority() -> "uint32_t":
        r"""getDefaultRedrawPriority() -> uint32_t"""
        return _coin.SoSceneManager_getDefaultRedrawPriority()

    @staticmethod
    def enableRealTimeUpdate(flag: "SbBool const") -> "void":
        r"""enableRealTimeUpdate(SbBool const flag)"""
        return _coin.SoSceneManager_enableRealTimeUpdate(flag)

    @staticmethod
    def isRealTimeUpdateEnabled() -> "SbBool":
        r"""isRealTimeUpdateEnabled() -> SbBool"""
        return _coin.SoSceneManager_isRealTimeUpdateEnabled()

    def setRenderCallback(self, *args) -> "void":
        r"""
        setRenderCallback(SoSceneManager self, SoSceneManagerRenderCB * f, void *const userData=None)
        setRenderCallback(SoSceneManager self, PyObject * pyfunc, PyObject * userData=None)
        """
        return _coin.SoSceneManager_setRenderCallback(self, *args)

# Register SoSceneManager in _coin:
_coin.SoSceneManager_swigregister(SoSceneManager)

def SoSceneManager_getDefaultRedrawPriority() -> "uint32_t":
    r"""SoSceneManager_getDefaultRedrawPriority() -> uint32_t"""
    return _coin.SoSceneManager_getDefaultRedrawPriority()

def SoSceneManager_enableRealTimeUpdate(flag: "SbBool const") -> "void":
    r"""SoSceneManager_enableRealTimeUpdate(SbBool const flag)"""
    return _coin.SoSceneManager_enableRealTimeUpdate(flag)

def SoSceneManager_isRealTimeUpdateEnabled() -> "SbBool":
    r"""SoSceneManager_isRealTimeUpdateEnabled() -> SbBool"""
    return _coin.SoSceneManager_isRealTimeUpdateEnabled()

GL_GLEXT_PROTOTYPES = _coin.GL_GLEXT_PROTOTYPES

GL_CLAMP_TO_EDGE = _coin.GL_CLAMP_TO_EDGE

GL_CLAMP_TO_BORDER = _coin.GL_CLAMP_TO_BORDER

GL_REPLACE = _coin.GL_REPLACE

GL_MAX_3D_TEXTURE_SIZE = _coin.GL_MAX_3D_TEXTURE_SIZE

GL_PACK_IMAGE_HEIGHT = _coin.GL_PACK_IMAGE_HEIGHT

GL_PACK_SKIP_IMAGES = _coin.GL_PACK_SKIP_IMAGES

GL_PROXY_TEXTURE_2D = _coin.GL_PROXY_TEXTURE_2D

GL_PROXY_TEXTURE_3D = _coin.GL_PROXY_TEXTURE_3D

GL_TEXTURE_3D = _coin.GL_TEXTURE_3D

GL_TEXTURE_DEPTH = _coin.GL_TEXTURE_DEPTH

GL_TEXTURE_WRAP_R = _coin.GL_TEXTURE_WRAP_R

GL_UNPACK_IMAGE_HEIGHT = _coin.GL_UNPACK_IMAGE_HEIGHT

GL_UNPACK_SKIP_IMAGES = _coin.GL_UNPACK_SKIP_IMAGES

GL_COLOR_TABLE_WIDTH = _coin.GL_COLOR_TABLE_WIDTH

GL_TEXTURE0 = _coin.GL_TEXTURE0

GL_TEXTURE1 = _coin.GL_TEXTURE1

GL_TEXTURE2 = _coin.GL_TEXTURE2

GL_TEXTURE3 = _coin.GL_TEXTURE3

GL_TEXTURE4 = _coin.GL_TEXTURE4

GL_TEXTURE5 = _coin.GL_TEXTURE5

GL_TEXTURE6 = _coin.GL_TEXTURE6

GL_TEXTURE7 = _coin.GL_TEXTURE7

GL_TEXTURE8 = _coin.GL_TEXTURE8

GL_TEXTURE9 = _coin.GL_TEXTURE9

GL_TEXTURE10 = _coin.GL_TEXTURE10

GL_TEXTURE11 = _coin.GL_TEXTURE11

GL_TEXTURE12 = _coin.GL_TEXTURE12

GL_TEXTURE13 = _coin.GL_TEXTURE13

GL_TEXTURE14 = _coin.GL_TEXTURE14

GL_TEXTURE15 = _coin.GL_TEXTURE15

GL_MAX_TEXTURE_UNITS = _coin.GL_MAX_TEXTURE_UNITS

GL_ACTIVE_TEXTURE = _coin.GL_ACTIVE_TEXTURE

GL_CLIENT_ACTIVE_TEXTURE = _coin.GL_CLIENT_ACTIVE_TEXTURE

GL_POLYGON_OFFSET_EXT = _coin.GL_POLYGON_OFFSET_EXT

GL_COLOR_TABLE = _coin.GL_COLOR_TABLE

GL_COLOR_INDEX1_EXT = _coin.GL_COLOR_INDEX1_EXT

GL_COLOR_INDEX2_EXT = _coin.GL_COLOR_INDEX2_EXT

GL_COLOR_INDEX4_EXT = _coin.GL_COLOR_INDEX4_EXT

GL_COLOR_INDEX8_EXT = _coin.GL_COLOR_INDEX8_EXT

GL_COLOR_INDEX12_EXT = _coin.GL_COLOR_INDEX12_EXT

GL_COLOR_INDEX16_EXT = _coin.GL_COLOR_INDEX16_EXT

GL_COLOR_TABLE_FORMAT_EXT = _coin.GL_COLOR_TABLE_FORMAT_EXT

GL_COLOR_TABLE_RED_SIZE_EXT = _coin.GL_COLOR_TABLE_RED_SIZE_EXT

GL_COLOR_TABLE_GREEN_SIZE_EXT = _coin.GL_COLOR_TABLE_GREEN_SIZE_EXT

GL_COLOR_TABLE_BLUE_SIZE_EXT = _coin.GL_COLOR_TABLE_BLUE_SIZE_EXT

GL_COLOR_TABLE_ALPHA_SIZE_EXT = _coin.GL_COLOR_TABLE_ALPHA_SIZE_EXT

GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = _coin.GL_COLOR_TABLE_LUMINANCE_SIZE_EXT

GL_COLOR_TABLE_INTENSITY_SIZE_EXT = _coin.GL_COLOR_TABLE_INTENSITY_SIZE_EXT

GL_TEXTURE_INDEX_SIZE_EXT = _coin.GL_TEXTURE_INDEX_SIZE_EXT

GL_COMPRESSED_ALPHA_ARB = _coin.GL_COMPRESSED_ALPHA_ARB

GL_COMPRESSED_LUMINANCE_ARB = _coin.GL_COMPRESSED_LUMINANCE_ARB

GL_COMPRESSED_LUMINANCE_ALPHA_ARB = _coin.GL_COMPRESSED_LUMINANCE_ALPHA_ARB

GL_COMPRESSED_INTENSITY_ARB = _coin.GL_COMPRESSED_INTENSITY_ARB

GL_COMPRESSED_RGB_ARB = _coin.GL_COMPRESSED_RGB_ARB

GL_COMPRESSED_RGBA_ARB = _coin.GL_COMPRESSED_RGBA_ARB

GL_TEXTURE_COMPRESSION_HINT_ARB = _coin.GL_TEXTURE_COMPRESSION_HINT_ARB

GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = _coin.GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB

GL_TEXTURE_COMPRESSED_ARB = _coin.GL_TEXTURE_COMPRESSED_ARB

GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB

GL_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_COMPRESSED_TEXTURE_FORMATS_ARB

GL_DEPTH_COMPONENT16 = _coin.GL_DEPTH_COMPONENT16

GL_DEPTH_COMPONENT24 = _coin.GL_DEPTH_COMPONENT24

GL_DEPTH_COMPONENT32 = _coin.GL_DEPTH_COMPONENT32

GL_TEXTURE_DEPTH_SIZE = _coin.GL_TEXTURE_DEPTH_SIZE

GL_DEPTH_TEXTURE_MODE = _coin.GL_DEPTH_TEXTURE_MODE

GL_R3_G3_B2 = _coin.GL_R3_G3_B2

GL_RGB4 = _coin.GL_RGB4

GL_RGB5 = _coin.GL_RGB5

GL_RGB8 = _coin.GL_RGB8

GL_RGB10 = _coin.GL_RGB10

GL_RGB12 = _coin.GL_RGB12

GL_RGB16 = _coin.GL_RGB16

GL_RGBA2 = _coin.GL_RGBA2

GL_RGBA4 = _coin.GL_RGBA4

GL_RGB5_A1 = _coin.GL_RGB5_A1

GL_RGBA8 = _coin.GL_RGBA8

GL_RGB10_A2 = _coin.GL_RGB10_A2

GL_RGBA12 = _coin.GL_RGBA12

GL_RGBA16 = _coin.GL_RGBA16

GL_BGR = _coin.GL_BGR

GL_RGBA32F_ARB = _coin.GL_RGBA32F_ARB

GL_RGB32F_ARB = _coin.GL_RGB32F_ARB

GL_ALPHA32F_ARB = _coin.GL_ALPHA32F_ARB

GL_INTENSITY32F_ARB = _coin.GL_INTENSITY32F_ARB

GL_LUMINANCE32F_ARB = _coin.GL_LUMINANCE32F_ARB

GL_LUMINANCE_ALPHA32F_ARB = _coin.GL_LUMINANCE_ALPHA32F_ARB

GL_RGBA16F_ARB = _coin.GL_RGBA16F_ARB

GL_RGB16F_ARB = _coin.GL_RGB16F_ARB

GL_ALPHA16F_ARB = _coin.GL_ALPHA16F_ARB

GL_INTENSITY16F_ARB = _coin.GL_INTENSITY16F_ARB

GL_LUMINANCE16F_ARB = _coin.GL_LUMINANCE16F_ARB

GL_LUMINANCE_ALPHA16F_ARB = _coin.GL_LUMINANCE_ALPHA16F_ARB

GL_RGBA16_EXT = _coin.GL_RGBA16_EXT

GL_TEXTURE_COMPARE_MODE = _coin.GL_TEXTURE_COMPARE_MODE

GL_TEXTURE_COMPARE_FUNC = _coin.GL_TEXTURE_COMPARE_FUNC

GL_COMPARE_R_TO_TEXTURE = _coin.GL_COMPARE_R_TO_TEXTURE

GL_MIN = _coin.GL_MIN

GL_MAX = _coin.GL_MAX

GL_FUNC_ADD = _coin.GL_FUNC_ADD

GL_FUNC_SUBTRACT = _coin.GL_FUNC_SUBTRACT

GL_FUNC_REVERSE_SUBTRACT = _coin.GL_FUNC_REVERSE_SUBTRACT

GL_VERTEX_ARRAY = _coin.GL_VERTEX_ARRAY

GL_NORMAL_ARRAY = _coin.GL_NORMAL_ARRAY

GL_COLOR_ARRAY = _coin.GL_COLOR_ARRAY

GL_INDEX_ARRAY = _coin.GL_INDEX_ARRAY

GL_TEXTURE_COORD_ARRAY = _coin.GL_TEXTURE_COORD_ARRAY

GL_V3F = _coin.GL_V3F

GL_C4UB_V3F = _coin.GL_C4UB_V3F

GL_C3F_V3F = _coin.GL_C3F_V3F

GL_N3F_V3F = _coin.GL_N3F_V3F

GL_C4F_N3F_V3F = _coin.GL_C4F_N3F_V3F

GL_T2F_V3F = _coin.GL_T2F_V3F

GL_T2F_C4UB_V3F = _coin.GL_T2F_C4UB_V3F

GL_T2F_C3F_V3F = _coin.GL_T2F_C3F_V3F

GL_T2F_N3F_V3F = _coin.GL_T2F_N3F_V3F

GL_T2F_C4F_N3F_V3F = _coin.GL_T2F_C4F_N3F_V3F

GL_VERTEX_ARRAY_RANGE_NV = _coin.GL_VERTEX_ARRAY_RANGE_NV

GL_VERTEX_ARRAY_RANGE_LENGTH_NV = _coin.GL_VERTEX_ARRAY_RANGE_LENGTH_NV

GL_VERTEX_ARRAY_RANGE_VALID_NV = _coin.GL_VERTEX_ARRAY_RANGE_VALID_NV

GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = _coin.GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV

GL_VERTEX_ARRAY_RANGE_POINTER_NV = _coin.GL_VERTEX_ARRAY_RANGE_POINTER_NV

GL_ARRAY_BUFFER = _coin.GL_ARRAY_BUFFER

GL_ELEMENT_ARRAY_BUFFER = _coin.GL_ELEMENT_ARRAY_BUFFER

GL_READ_ONLY = _coin.GL_READ_ONLY

GL_WRITE_ONLY = _coin.GL_WRITE_ONLY

GL_READ_WRITE = _coin.GL_READ_WRITE

GL_BUFFER_ACCESS = _coin.GL_BUFFER_ACCESS

GL_BUFFER_MAPPED = _coin.GL_BUFFER_MAPPED

GL_BUFFER_MAP_POINTER = _coin.GL_BUFFER_MAP_POINTER

GL_STREAM_DRAW = _coin.GL_STREAM_DRAW

GL_STREAM_READ = _coin.GL_STREAM_READ

GL_STREAM_COPY = _coin.GL_STREAM_COPY

GL_STATIC_DRAW = _coin.GL_STATIC_DRAW

GL_STATIC_READ = _coin.GL_STATIC_READ

GL_STATIC_COPY = _coin.GL_STATIC_COPY

GL_DYNAMIC_DRAW = _coin.GL_DYNAMIC_DRAW

GL_DYNAMIC_READ = _coin.GL_DYNAMIC_READ

GL_DYNAMIC_COPY = _coin.GL_DYNAMIC_COPY

GL_REGISTER_COMBINERS_NV = _coin.GL_REGISTER_COMBINERS_NV

GL_COMBINER0_NV = _coin.GL_COMBINER0_NV

GL_COMBINER1_NV = _coin.GL_COMBINER1_NV

GL_COMBINER2_NV = _coin.GL_COMBINER2_NV

GL_COMBINER3_NV = _coin.GL_COMBINER3_NV

GL_COMBINER4_NV = _coin.GL_COMBINER4_NV

GL_COMBINER5_NV = _coin.GL_COMBINER5_NV

GL_COMBINER6_NV = _coin.GL_COMBINER6_NV

GL_COMBINER7_NV = _coin.GL_COMBINER7_NV

GL_VARIABLE_A_NV = _coin.GL_VARIABLE_A_NV

GL_VARIABLE_B_NV = _coin.GL_VARIABLE_B_NV

GL_VARIABLE_C_NV = _coin.GL_VARIABLE_C_NV

GL_VARIABLE_D_NV = _coin.GL_VARIABLE_D_NV

GL_VARIABLE_E_NV = _coin.GL_VARIABLE_E_NV

GL_VARIABLE_F_NV = _coin.GL_VARIABLE_F_NV

GL_VARIABLE_G_NV = _coin.GL_VARIABLE_G_NV

GL_CONSTANT_COLOR0_NV = _coin.GL_CONSTANT_COLOR0_NV

GL_CONSTANT_COLOR1_NV = _coin.GL_CONSTANT_COLOR1_NV

GL_PRIMARY_COLOR_NV = _coin.GL_PRIMARY_COLOR_NV

GL_SECONDARY_COLOR_NV = _coin.GL_SECONDARY_COLOR_NV

GL_SPARE0_NV = _coin.GL_SPARE0_NV

GL_SPARE1_NV = _coin.GL_SPARE1_NV

GL_UNSIGNED_IDENTITY_NV = _coin.GL_UNSIGNED_IDENTITY_NV

GL_UNSIGNED_INVERT_NV = _coin.GL_UNSIGNED_INVERT_NV

GL_EXPAND_NORMAL_NV = _coin.GL_EXPAND_NORMAL_NV

GL_EXPAND_NEGATE_NV = _coin.GL_EXPAND_NEGATE_NV

GL_HALF_BIAS_NORMAL_NV = _coin.GL_HALF_BIAS_NORMAL_NV

GL_HALF_BIAS_NEGATE_NV = _coin.GL_HALF_BIAS_NEGATE_NV

GL_SIGNED_IDENTITY_NV = _coin.GL_SIGNED_IDENTITY_NV

GL_SIGNED_NEGATE_NV = _coin.GL_SIGNED_NEGATE_NV

GL_E_TIMES_F_NV = _coin.GL_E_TIMES_F_NV

GL_SPARE0_PLUS_SECONDARY_COLOR_NV = _coin.GL_SPARE0_PLUS_SECONDARY_COLOR_NV

GL_SCALE_BY_TWO_NV = _coin.GL_SCALE_BY_TWO_NV

GL_SCALE_BY_FOUR_NV = _coin.GL_SCALE_BY_FOUR_NV

GL_SCALE_BY_ONE_HALF_NV = _coin.GL_SCALE_BY_ONE_HALF_NV

GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = _coin.GL_BIAS_BY_NEGATIVE_ONE_HALF_NV

GL_DISCARD_NV = _coin.GL_DISCARD_NV

GL_COMBINER_INPUT_NV = _coin.GL_COMBINER_INPUT_NV

GL_COMBINER_MAPPING_NV = _coin.GL_COMBINER_MAPPING_NV

GL_COMBINER_COMPONENT_USAGE_NV = _coin.GL_COMBINER_COMPONENT_USAGE_NV

GL_COMBINER_AB_DOT_PRODUCT_NV = _coin.GL_COMBINER_AB_DOT_PRODUCT_NV

GL_COMBINER_CD_DOT_PRODUCT_NV = _coin.GL_COMBINER_CD_DOT_PRODUCT_NV

GL_COMBINER_MUX_SUM_NV = _coin.GL_COMBINER_MUX_SUM_NV

GL_COMBINER_SCALE_NV = _coin.GL_COMBINER_SCALE_NV

GL_COMBINER_BIAS_NV = _coin.GL_COMBINER_BIAS_NV

GL_COMBINER_AB_OUTPUT_NV = _coin.GL_COMBINER_AB_OUTPUT_NV

GL_COMBINER_CD_OUTPUT_NV = _coin.GL_COMBINER_CD_OUTPUT_NV

GL_COMBINER_SUM_OUTPUT_NV = _coin.GL_COMBINER_SUM_OUTPUT_NV

GL_MAX_GENERAL_COMBINERS_NV = _coin.GL_MAX_GENERAL_COMBINERS_NV

GL_NUM_GENERAL_COMBINERS_NV = _coin.GL_NUM_GENERAL_COMBINERS_NV

GL_COLOR_SUM_CLAMP_NV = _coin.GL_COLOR_SUM_CLAMP_NV

GL_TEXTURE_RECTANGLE_NV = _coin.GL_TEXTURE_RECTANGLE_NV

GL_TEXTURE_BINDING_RECTANGLE_NV = _coin.GL_TEXTURE_BINDING_RECTANGLE_NV

GL_PROXY_TEXTURE_RECTANGLE_NV = _coin.GL_PROXY_TEXTURE_RECTANGLE_NV

GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_NV

GL_TEXTURE_RECTANGLE_EXT = _coin.GL_TEXTURE_RECTANGLE_EXT

GL_TEXTURE_BINDING_RECTANGLE_EXT = _coin.GL_TEXTURE_BINDING_RECTANGLE_EXT

GL_PROXY_TEXTURE_RECTANGLE_EXT = _coin.GL_PROXY_TEXTURE_RECTANGLE_EXT

GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT

GL_OFFSET_TEXTURE_RECTANGLE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_NV

GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV

GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = _coin.GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV

GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = _coin.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV

GL_UNSIGNED_INT_S8_S8_8_8_NV = _coin.GL_UNSIGNED_INT_S8_S8_8_8_NV

GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = _coin.GL_UNSIGNED_INT_8_8_S8_S8_REV_NV

GL_DSDT_MAG_INTENSITY_NV = _coin.GL_DSDT_MAG_INTENSITY_NV

GL_SHADER_CONSISTENT_NV = _coin.GL_SHADER_CONSISTENT_NV

GL_TEXTURE_SHADER_NV = _coin.GL_TEXTURE_SHADER_NV

GL_SHADER_OPERATION_NV = _coin.GL_SHADER_OPERATION_NV

GL_CULL_MODES_NV = _coin.GL_CULL_MODES_NV

GL_OFFSET_TEXTURE_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_MATRIX_NV

GL_OFFSET_TEXTURE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_SCALE_NV

GL_OFFSET_TEXTURE_BIAS_NV = _coin.GL_OFFSET_TEXTURE_BIAS_NV

GL_OFFSET_TEXTURE_2D_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_2D_MATRIX_NV

GL_OFFSET_TEXTURE_2D_SCALE_NV = _coin.GL_OFFSET_TEXTURE_2D_SCALE_NV

GL_OFFSET_TEXTURE_2D_BIAS_NV = _coin.GL_OFFSET_TEXTURE_2D_BIAS_NV

GL_PREVIOUS_TEXTURE_INPUT_NV = _coin.GL_PREVIOUS_TEXTURE_INPUT_NV

GL_CONST_EYE_NV = _coin.GL_CONST_EYE_NV

GL_PASS_THROUGH_NV = _coin.GL_PASS_THROUGH_NV

GL_CULL_FRAGMENT_NV = _coin.GL_CULL_FRAGMENT_NV

GL_OFFSET_TEXTURE_2D_NV = _coin.GL_OFFSET_TEXTURE_2D_NV

GL_DEPENDENT_AR_TEXTURE_2D_NV = _coin.GL_DEPENDENT_AR_TEXTURE_2D_NV

GL_DEPENDENT_GB_TEXTURE_2D_NV = _coin.GL_DEPENDENT_GB_TEXTURE_2D_NV

GL_DOT_PRODUCT_NV = _coin.GL_DOT_PRODUCT_NV

GL_DOT_PRODUCT_DEPTH_REPLACE_NV = _coin.GL_DOT_PRODUCT_DEPTH_REPLACE_NV

GL_DOT_PRODUCT_TEXTURE_2D_NV = _coin.GL_DOT_PRODUCT_TEXTURE_2D_NV

GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV

GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV

GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV

GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV

GL_HILO_NV = _coin.GL_HILO_NV

GL_DSDT_NV = _coin.GL_DSDT_NV

GL_DSDT_MAG_NV = _coin.GL_DSDT_MAG_NV

GL_DSDT_MAG_VIB_NV = _coin.GL_DSDT_MAG_VIB_NV

GL_HILO16_NV = _coin.GL_HILO16_NV

GL_SIGNED_HILO_NV = _coin.GL_SIGNED_HILO_NV

GL_SIGNED_HILO16_NV = _coin.GL_SIGNED_HILO16_NV

GL_SIGNED_RGBA_NV = _coin.GL_SIGNED_RGBA_NV

GL_SIGNED_RGBA8_NV = _coin.GL_SIGNED_RGBA8_NV

GL_SIGNED_RGB_NV = _coin.GL_SIGNED_RGB_NV

GL_SIGNED_RGB8_NV = _coin.GL_SIGNED_RGB8_NV

GL_SIGNED_LUMINANCE_NV = _coin.GL_SIGNED_LUMINANCE_NV

GL_SIGNED_LUMINANCE8_NV = _coin.GL_SIGNED_LUMINANCE8_NV

GL_SIGNED_LUMINANCE_ALPHA_NV = _coin.GL_SIGNED_LUMINANCE_ALPHA_NV

GL_SIGNED_LUMINANCE8_ALPHA8_NV = _coin.GL_SIGNED_LUMINANCE8_ALPHA8_NV

GL_SIGNED_ALPHA_NV = _coin.GL_SIGNED_ALPHA_NV

GL_SIGNED_ALPHA8_NV = _coin.GL_SIGNED_ALPHA8_NV

GL_SIGNED_INTENSITY_NV = _coin.GL_SIGNED_INTENSITY_NV

GL_SIGNED_INTENSITY8_NV = _coin.GL_SIGNED_INTENSITY8_NV

GL_DSDT8_NV = _coin.GL_DSDT8_NV

GL_DSDT8_MAG8_NV = _coin.GL_DSDT8_MAG8_NV

GL_DSDT8_MAG8_INTENSITY8_NV = _coin.GL_DSDT8_MAG8_INTENSITY8_NV

GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = _coin.GL_SIGNED_RGB_UNSIGNED_ALPHA_NV

GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = _coin.GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV

GL_HI_SCALE_NV = _coin.GL_HI_SCALE_NV

GL_LO_SCALE_NV = _coin.GL_LO_SCALE_NV

GL_DS_SCALE_NV = _coin.GL_DS_SCALE_NV

GL_DT_SCALE_NV = _coin.GL_DT_SCALE_NV

GL_MAGNITUDE_SCALE_NV = _coin.GL_MAGNITUDE_SCALE_NV

GL_VIBRANCE_SCALE_NV = _coin.GL_VIBRANCE_SCALE_NV

GL_HI_BIAS_NV = _coin.GL_HI_BIAS_NV

GL_LO_BIAS_NV = _coin.GL_LO_BIAS_NV

GL_DS_BIAS_NV = _coin.GL_DS_BIAS_NV

GL_DT_BIAS_NV = _coin.GL_DT_BIAS_NV

GL_MAGNITUDE_BIAS_NV = _coin.GL_MAGNITUDE_BIAS_NV

GL_VIBRANCE_BIAS_NV = _coin.GL_VIBRANCE_BIAS_NV

GL_TEXTURE_BORDER_VALUES_NV = _coin.GL_TEXTURE_BORDER_VALUES_NV

GL_TEXTURE_HI_SIZE_NV = _coin.GL_TEXTURE_HI_SIZE_NV

GL_TEXTURE_LO_SIZE_NV = _coin.GL_TEXTURE_LO_SIZE_NV

GL_TEXTURE_DS_SIZE_NV = _coin.GL_TEXTURE_DS_SIZE_NV

GL_TEXTURE_DT_SIZE_NV = _coin.GL_TEXTURE_DT_SIZE_NV

GL_TEXTURE_MAG_SIZE_NV = _coin.GL_TEXTURE_MAG_SIZE_NV

GL_NORMAL_MAP = _coin.GL_NORMAL_MAP

GL_REFLECTION_MAP = _coin.GL_REFLECTION_MAP

GL_TEXTURE_CUBE_MAP = _coin.GL_TEXTURE_CUBE_MAP

GL_TEXTURE_BINDING_CUBE_MAP = _coin.GL_TEXTURE_BINDING_CUBE_MAP

GL_TEXTURE_CUBE_MAP_POSITIVE_X = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_X

GL_TEXTURE_CUBE_MAP_NEGATIVE_X = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_X

GL_TEXTURE_CUBE_MAP_POSITIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Y

GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y

GL_TEXTURE_CUBE_MAP_POSITIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Z

GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z

GL_MAX_CUBE_MAP_TEXTURE_SIZE = _coin.GL_MAX_CUBE_MAP_TEXTURE_SIZE

GL_COMBINE = _coin.GL_COMBINE

GL_COMBINE_RGB = _coin.GL_COMBINE_RGB

GL_COMBINE_ALPHA = _coin.GL_COMBINE_ALPHA

GL_RGB_SCALE = _coin.GL_RGB_SCALE

GL_ADD_SIGNED = _coin.GL_ADD_SIGNED

GL_INTERPOLATE = _coin.GL_INTERPOLATE

GL_CONSTANT = _coin.GL_CONSTANT

GL_PRIMARY_COLOR = _coin.GL_PRIMARY_COLOR

GL_PREVIOUS = _coin.GL_PREVIOUS

GL_SOURCE0_RGB = _coin.GL_SOURCE0_RGB

GL_SOURCE1_RGB = _coin.GL_SOURCE1_RGB

GL_SOURCE2_RGB = _coin.GL_SOURCE2_RGB

GL_SOURCE0_ALPHA = _coin.GL_SOURCE0_ALPHA

GL_SOURCE1_ALPHA = _coin.GL_SOURCE1_ALPHA

GL_SOURCE2_ALPHA = _coin.GL_SOURCE2_ALPHA

GL_OPERAND0_RGB = _coin.GL_OPERAND0_RGB

GL_OPERAND1_RGB = _coin.GL_OPERAND1_RGB

GL_OPERAND2_RGB = _coin.GL_OPERAND2_RGB

GL_OPERAND0_ALPHA = _coin.GL_OPERAND0_ALPHA

GL_OPERAND1_ALPHA = _coin.GL_OPERAND1_ALPHA

GL_OPERAND2_ALPHA = _coin.GL_OPERAND2_ALPHA

GL_SUBTRACT = _coin.GL_SUBTRACT

GL_DOT3_RGB = _coin.GL_DOT3_RGB

GL_DOT3_RGBA = _coin.GL_DOT3_RGBA

GL_GENERATE_MIPMAP_SGIS = _coin.GL_GENERATE_MIPMAP_SGIS

GL_GENERATE_MIPMAP_HINT_SGIS = _coin.GL_GENERATE_MIPMAP_HINT_SGIS

GL_FRAGMENT_PROGRAM_ARB = _coin.GL_FRAGMENT_PROGRAM_ARB

GL_PROGRAM_FORMAT_ASCII_ARB = _coin.GL_PROGRAM_FORMAT_ASCII_ARB

GL_PROGRAM_LENGTH_ARB = _coin.GL_PROGRAM_LENGTH_ARB

GL_PROGRAM_FORMAT_ARB = _coin.GL_PROGRAM_FORMAT_ARB

GL_PROGRAM_BINDING_ARB = _coin.GL_PROGRAM_BINDING_ARB

GL_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_INSTRUCTIONS_ARB

GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB

GL_PROGRAM_TEMPORARIES_ARB = _coin.GL_PROGRAM_TEMPORARIES_ARB

GL_MAX_PROGRAM_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_TEMPORARIES_ARB

GL_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_PROGRAM_NATIVE_TEMPORARIES_ARB

GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB

GL_PROGRAM_PARAMETERS_ARB = _coin.GL_PROGRAM_PARAMETERS_ARB

GL_MAX_PROGRAM_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_PARAMETERS_ARB

GL_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_PROGRAM_NATIVE_PARAMETERS_ARB

GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB

GL_PROGRAM_ATTRIBS_ARB = _coin.GL_PROGRAM_ATTRIBS_ARB

GL_MAX_PROGRAM_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_ATTRIBS_ARB

GL_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_PROGRAM_NATIVE_ATTRIBS_ARB

GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB

GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB

GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_ENV_PARAMETERS_ARB

GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = _coin.GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB

GL_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_ALU_INSTRUCTIONS_ARB

GL_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_TEX_INSTRUCTIONS_ARB

GL_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_TEX_INDIRECTIONS_ARB

GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB

GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB

GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB

GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB

GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB

GL_PROGRAM_STRING_ARB = _coin.GL_PROGRAM_STRING_ARB

GL_PROGRAM_ERROR_POSITION_ARB = _coin.GL_PROGRAM_ERROR_POSITION_ARB

GL_CURRENT_MATRIX_ARB = _coin.GL_CURRENT_MATRIX_ARB

GL_TRANSPOSE_CURRENT_MATRIX_ARB = _coin.GL_TRANSPOSE_CURRENT_MATRIX_ARB

GL_CURRENT_MATRIX_STACK_DEPTH_ARB = _coin.GL_CURRENT_MATRIX_STACK_DEPTH_ARB

GL_MAX_PROGRAM_MATRICES_ARB = _coin.GL_MAX_PROGRAM_MATRICES_ARB

GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = _coin.GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB

GL_MAX_TEXTURE_COORDS_ARB = _coin.GL_MAX_TEXTURE_COORDS_ARB

GL_MAX_TEXTURE_IMAGE_UNITS_ARB = _coin.GL_MAX_TEXTURE_IMAGE_UNITS_ARB

GL_PROGRAM_ERROR_STRING_ARB = _coin.GL_PROGRAM_ERROR_STRING_ARB

GL_MATRIX0_ARB = _coin.GL_MATRIX0_ARB

GL_MATRIX1_ARB = _coin.GL_MATRIX1_ARB

GL_MATRIX2_ARB = _coin.GL_MATRIX2_ARB

GL_MATRIX3_ARB = _coin.GL_MATRIX3_ARB

GL_MATRIX4_ARB = _coin.GL_MATRIX4_ARB

GL_MATRIX5_ARB = _coin.GL_MATRIX5_ARB

GL_MATRIX6_ARB = _coin.GL_MATRIX6_ARB

GL_MATRIX7_ARB = _coin.GL_MATRIX7_ARB

GL_MATRIX8_ARB = _coin.GL_MATRIX8_ARB

GL_MATRIX9_ARB = _coin.GL_MATRIX9_ARB

GL_MATRIX10_ARB = _coin.GL_MATRIX10_ARB

GL_MATRIX11_ARB = _coin.GL_MATRIX11_ARB

GL_MATRIX12_ARB = _coin.GL_MATRIX12_ARB

GL_MATRIX13_ARB = _coin.GL_MATRIX13_ARB

GL_MATRIX14_ARB = _coin.GL_MATRIX14_ARB

GL_MATRIX15_ARB = _coin.GL_MATRIX15_ARB

GL_MATRIX16_ARB = _coin.GL_MATRIX16_ARB

GL_MATRIX17_ARB = _coin.GL_MATRIX17_ARB

GL_MATRIX18_ARB = _coin.GL_MATRIX18_ARB

GL_MATRIX19_ARB = _coin.GL_MATRIX19_ARB

GL_MATRIX20_ARB = _coin.GL_MATRIX20_ARB

GL_MATRIX21_ARB = _coin.GL_MATRIX21_ARB

GL_MATRIX22_ARB = _coin.GL_MATRIX22_ARB

GL_MATRIX23_ARB = _coin.GL_MATRIX23_ARB

GL_MATRIX24_ARB = _coin.GL_MATRIX24_ARB

GL_MATRIX25_ARB = _coin.GL_MATRIX25_ARB

GL_MATRIX26_ARB = _coin.GL_MATRIX26_ARB

GL_MATRIX27_ARB = _coin.GL_MATRIX27_ARB

GL_MATRIX28_ARB = _coin.GL_MATRIX28_ARB

GL_MATRIX29_ARB = _coin.GL_MATRIX29_ARB

GL_MATRIX30_ARB = _coin.GL_MATRIX30_ARB

GL_MATRIX31_ARB = _coin.GL_MATRIX31_ARB

GL_VERTEX_PROGRAM_ARB = _coin.GL_VERTEX_PROGRAM_ARB

GL_VERTEX_PROGRAM_POINT_SIZE_ARB = _coin.GL_VERTEX_PROGRAM_POINT_SIZE_ARB

GL_VERTEX_PROGRAM_TWO_SIDE_ARB = _coin.GL_VERTEX_PROGRAM_TWO_SIDE_ARB

GL_COLOR_SUM_ARB = _coin.GL_COLOR_SUM_ARB

GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB

GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB

GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB

GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB

GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB

GL_CURRENT_VERTEX_ATTRIB_ARB = _coin.GL_CURRENT_VERTEX_ATTRIB_ARB

GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB

GL_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_ADDRESS_REGISTERS_ARB

GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB

GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB

GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB

GL_MAX_VERTEX_ATTRIBS_ARB = _coin.GL_MAX_VERTEX_ATTRIBS_ARB

GL_VERTEX_SHADER_ARB = _coin.GL_VERTEX_SHADER_ARB

GL_FRAGMENT_SHADER_ARB = _coin.GL_FRAGMENT_SHADER_ARB

GL_OBJECT_ACTIVE_UNIFORMS_ARB = _coin.GL_OBJECT_ACTIVE_UNIFORMS_ARB

GL_GEOMETRY_SHADER_EXT = _coin.GL_GEOMETRY_SHADER_EXT

GL_GEOMETRY_VERTICES_OUT_EXT = _coin.GL_GEOMETRY_VERTICES_OUT_EXT

GL_GEOMETRY_INPUT_TYPE_EXT = _coin.GL_GEOMETRY_INPUT_TYPE_EXT

GL_GEOMETRY_OUTPUT_TYPE_EXT = _coin.GL_GEOMETRY_OUTPUT_TYPE_EXT

GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = _coin.GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT

GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT

GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = _coin.GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT

GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT

GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VERTEX_VARYING_COMPONENTS_EXT

GL_MAX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VARYING_COMPONENTS_EXT

GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT

GL_INT_VEC2_ARB = _coin.GL_INT_VEC2_ARB

GL_INT_VEC3_ARB = _coin.GL_INT_VEC3_ARB

GL_INT_VEC4_ARB = _coin.GL_INT_VEC4_ARB

GL_FLOAT_VEC2_ARB = _coin.GL_FLOAT_VEC2_ARB

GL_FLOAT_VEC3_ARB = _coin.GL_FLOAT_VEC3_ARB

GL_FLOAT_VEC4_ARB = _coin.GL_FLOAT_VEC4_ARB

GL_FLOAT_MAT2_ARB = _coin.GL_FLOAT_MAT2_ARB

GL_FLOAT_MAT3_ARB = _coin.GL_FLOAT_MAT3_ARB

GL_FLOAT_MAT4_ARB = _coin.GL_FLOAT_MAT4_ARB

GL_SAMPLER_1D_ARB = _coin.GL_SAMPLER_1D_ARB

GL_SAMPLER_2D_ARB = _coin.GL_SAMPLER_2D_ARB

GL_SAMPLER_3D_ARB = _coin.GL_SAMPLER_3D_ARB

GL_SAMPLER_CUBE_ARB = _coin.GL_SAMPLER_CUBE_ARB

GL_SAMPLER_1D_SHADOW_ARB = _coin.GL_SAMPLER_1D_SHADOW_ARB

GL_SAMPLER_2D_SHADOW_ARB = _coin.GL_SAMPLER_2D_SHADOW_ARB

GL_SAMPLER_2D_RECT_ARB = _coin.GL_SAMPLER_2D_RECT_ARB

GL_SAMPLER_2D_RECT_SHADOW_ARB = _coin.GL_SAMPLER_2D_RECT_SHADOW_ARB

GL_OBJECT_COMPILE_STATUS_ARB = _coin.GL_OBJECT_COMPILE_STATUS_ARB

GL_OBJECT_INFO_LOG_LENGTH_ARB = _coin.GL_OBJECT_INFO_LOG_LENGTH_ARB

GL_OBJECT_LINK_STATUS_ARB = _coin.GL_OBJECT_LINK_STATUS_ARB

GL_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_TEXTURE_MAX_ANISOTROPY_EXT

GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT

GL_SAMPLES_PASSED = _coin.GL_SAMPLES_PASSED

GL_QUERY_COUNTER_BITS = _coin.GL_QUERY_COUNTER_BITS

GL_CURRENT_QUERY = _coin.GL_CURRENT_QUERY

GL_QUERY_RESULT = _coin.GL_QUERY_RESULT

GL_QUERY_RESULT_AVAILABLE = _coin.GL_QUERY_RESULT_AVAILABLE

GL_CLIENT_PIXEL_STORE_BIT = _coin.GL_CLIENT_PIXEL_STORE_BIT

GL_CLIENT_VERTEX_ARRAY_BIT = _coin.GL_CLIENT_VERTEX_ARRAY_BIT

GL_CLIENT_ALL_ATTRIB_BITS = _coin.GL_CLIENT_ALL_ATTRIB_BITS

GL_ALL_CLIENT_ATTRIB_BITS = _coin.GL_ALL_CLIENT_ATTRIB_BITS

GL_INVALID_FRAMEBUFFER_OPERATION_EXT = _coin.GL_INVALID_FRAMEBUFFER_OPERATION_EXT

GL_MAX_RENDERBUFFER_SIZE_EXT = _coin.GL_MAX_RENDERBUFFER_SIZE_EXT

GL_FRAMEBUFFER_BINDING_EXT = _coin.GL_FRAMEBUFFER_BINDING_EXT

GL_RENDERBUFFER_BINDING_EXT = _coin.GL_RENDERBUFFER_BINDING_EXT

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT

GL_FRAMEBUFFER_COMPLETE_EXT = _coin.GL_FRAMEBUFFER_COMPLETE_EXT

GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT

GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT

GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT

GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT

GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT

GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT

GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT

GL_FRAMEBUFFER_UNSUPPORTED_EXT = _coin.GL_FRAMEBUFFER_UNSUPPORTED_EXT

GL_MAX_COLOR_ATTACHMENTS_EXT = _coin.GL_MAX_COLOR_ATTACHMENTS_EXT

GL_COLOR_ATTACHMENT0_EXT = _coin.GL_COLOR_ATTACHMENT0_EXT

GL_COLOR_ATTACHMENT1_EXT = _coin.GL_COLOR_ATTACHMENT1_EXT

GL_COLOR_ATTACHMENT2_EXT = _coin.GL_COLOR_ATTACHMENT2_EXT

GL_COLOR_ATTACHMENT3_EXT = _coin.GL_COLOR_ATTACHMENT3_EXT

GL_COLOR_ATTACHMENT4_EXT = _coin.GL_COLOR_ATTACHMENT4_EXT

GL_COLOR_ATTACHMENT5_EXT = _coin.GL_COLOR_ATTACHMENT5_EXT

GL_COLOR_ATTACHMENT6_EXT = _coin.GL_COLOR_ATTACHMENT6_EXT

GL_COLOR_ATTACHMENT7_EXT = _coin.GL_COLOR_ATTACHMENT7_EXT

GL_COLOR_ATTACHMENT8_EXT = _coin.GL_COLOR_ATTACHMENT8_EXT

GL_COLOR_ATTACHMENT9_EXT = _coin.GL_COLOR_ATTACHMENT9_EXT

GL_COLOR_ATTACHMENT10_EXT = _coin.GL_COLOR_ATTACHMENT10_EXT

GL_COLOR_ATTACHMENT11_EXT = _coin.GL_COLOR_ATTACHMENT11_EXT

GL_COLOR_ATTACHMENT12_EXT = _coin.GL_COLOR_ATTACHMENT12_EXT

GL_COLOR_ATTACHMENT13_EXT = _coin.GL_COLOR_ATTACHMENT13_EXT

GL_COLOR_ATTACHMENT14_EXT = _coin.GL_COLOR_ATTACHMENT14_EXT

GL_COLOR_ATTACHMENT15_EXT = _coin.GL_COLOR_ATTACHMENT15_EXT

GL_DEPTH_ATTACHMENT_EXT = _coin.GL_DEPTH_ATTACHMENT_EXT

GL_STENCIL_ATTACHMENT_EXT = _coin.GL_STENCIL_ATTACHMENT_EXT

GL_FRAMEBUFFER_EXT = _coin.GL_FRAMEBUFFER_EXT

GL_RENDERBUFFER_EXT = _coin.GL_RENDERBUFFER_EXT

GL_RENDERBUFFER_WIDTH_EXT = _coin.GL_RENDERBUFFER_WIDTH_EXT

GL_RENDERBUFFER_HEIGHT_EXT = _coin.GL_RENDERBUFFER_HEIGHT_EXT

GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT_EXT

GL_STENCIL_INDEX1_EXT = _coin.GL_STENCIL_INDEX1_EXT

GL_STENCIL_INDEX4_EXT = _coin.GL_STENCIL_INDEX4_EXT

GL_STENCIL_INDEX8_EXT = _coin.GL_STENCIL_INDEX8_EXT

GL_STENCIL_INDEX16_EXT = _coin.GL_STENCIL_INDEX16_EXT

GL_RENDERBUFFER_RED_SIZE_EXT = _coin.GL_RENDERBUFFER_RED_SIZE_EXT

GL_RENDERBUFFER_GREEN_SIZE_EXT = _coin.GL_RENDERBUFFER_GREEN_SIZE_EXT

GL_RENDERBUFFER_BLUE_SIZE_EXT = _coin.GL_RENDERBUFFER_BLUE_SIZE_EXT

GL_RENDERBUFFER_ALPHA_SIZE_EXT = _coin.GL_RENDERBUFFER_ALPHA_SIZE_EXT

GL_RENDERBUFFER_DEPTH_SIZE_EXT = _coin.GL_RENDERBUFFER_DEPTH_SIZE_EXT

GL_RENDERBUFFER_STENCIL_SIZE_EXT = _coin.GL_RENDERBUFFER_STENCIL_SIZE_EXT

GL_INVALID_FRAMEBUFFER_OPERATION = _coin.GL_INVALID_FRAMEBUFFER_OPERATION

GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = _coin.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING

GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE

GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE

GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE

GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE

GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE

GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE

GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE

GL_DEPTH_STENCIL = _coin.GL_DEPTH_STENCIL

GL_UNSIGNED_INT_24_ = _coin.GL_UNSIGNED_INT_24_

GL_DEPTH24_STENCIL8 = _coin.GL_DEPTH24_STENCIL8

GL_TEXTURE_STENCIL_SIZE = _coin.GL_TEXTURE_STENCIL_SIZE

GL_SRGB = _coin.GL_SRGB

GL_UNSIGNED_NORMALIZED = _coin.GL_UNSIGNED_NORMALIZED

GL_FRAMEBUFFER_DEFAULT = _coin.GL_FRAMEBUFFER_DEFAULT

GL_FRAMEBUFFER_UNDEFINED = _coin.GL_FRAMEBUFFER_UNDEFINED

GL_DEPTH_STENCIL_ATTACHMENT = _coin.GL_DEPTH_STENCIL_ATTACHMENT

GL_INDEX = _coin.GL_INDEX

GL_MAX_RENDERBUFFER_SIZE = _coin.GL_MAX_RENDERBUFFER_SIZE

GL_FRAMEBUFFER_BINDING = _coin.GL_FRAMEBUFFER_BINDING

GL_DRAW_FRAMEBUFFER_BINDING = _coin.GL_DRAW_FRAMEBUFFER_BINDING

GL_RENDERBUFFER_BINDING = _coin.GL_RENDERBUFFER_BINDING

GL_READ_FRAMEBUFFER = _coin.GL_READ_FRAMEBUFFER

GL_DRAW_FRAMEBUFFER = _coin.GL_DRAW_FRAMEBUFFER

GL_READ_FRAMEBUFFER_BINDING = _coin.GL_READ_FRAMEBUFFER_BINDING

GL_RENDERBUFFER_SAMPLES = _coin.GL_RENDERBUFFER_SAMPLES

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET

GL_FRAMEBUFFER_COMPLETE = _coin.GL_FRAMEBUFFER_COMPLETE

GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT

GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT

GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT

GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER

GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER

GL_FRAMEBUFFER_UNSUPPORTED = _coin.GL_FRAMEBUFFER_UNSUPPORTED

GL_MAX_COLOR_ATTACHMENTS = _coin.GL_MAX_COLOR_ATTACHMENTS

GL_COLOR_ATTACHMENT0 = _coin.GL_COLOR_ATTACHMENT0

GL_COLOR_ATTACHMENT1 = _coin.GL_COLOR_ATTACHMENT1

GL_COLOR_ATTACHMENT2 = _coin.GL_COLOR_ATTACHMENT2

GL_COLOR_ATTACHMENT3 = _coin.GL_COLOR_ATTACHMENT3

GL_COLOR_ATTACHMENT4 = _coin.GL_COLOR_ATTACHMENT4

GL_COLOR_ATTACHMENT5 = _coin.GL_COLOR_ATTACHMENT5

GL_COLOR_ATTACHMENT6 = _coin.GL_COLOR_ATTACHMENT6

GL_COLOR_ATTACHMENT7 = _coin.GL_COLOR_ATTACHMENT7

GL_COLOR_ATTACHMENT8 = _coin.GL_COLOR_ATTACHMENT8

GL_COLOR_ATTACHMENT9 = _coin.GL_COLOR_ATTACHMENT9

GL_COLOR_ATTACHMENT10 = _coin.GL_COLOR_ATTACHMENT10

GL_COLOR_ATTACHMENT11 = _coin.GL_COLOR_ATTACHMENT11

GL_COLOR_ATTACHMENT12 = _coin.GL_COLOR_ATTACHMENT12

GL_COLOR_ATTACHMENT13 = _coin.GL_COLOR_ATTACHMENT13

GL_COLOR_ATTACHMENT14 = _coin.GL_COLOR_ATTACHMENT14

GL_COLOR_ATTACHMENT15 = _coin.GL_COLOR_ATTACHMENT15

GL_DEPTH_ATTACHMENT = _coin.GL_DEPTH_ATTACHMENT

GL_STENCIL_ATTACHMENT = _coin.GL_STENCIL_ATTACHMENT

GL_FRAMEBUFFER = _coin.GL_FRAMEBUFFER

GL_RENDERBUFFER = _coin.GL_RENDERBUFFER

GL_RENDERBUFFER_WIDTH = _coin.GL_RENDERBUFFER_WIDTH

GL_RENDERBUFFER_HEIGHT = _coin.GL_RENDERBUFFER_HEIGHT

GL_RENDERBUFFER_INTERNAL_FORMAT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT

GL_STENCIL_INDEX1 = _coin.GL_STENCIL_INDEX1

GL_STENCIL_INDEX4 = _coin.GL_STENCIL_INDEX4

GL_STENCIL_INDEX8 = _coin.GL_STENCIL_INDEX8

GL_STENCIL_INDEX16 = _coin.GL_STENCIL_INDEX16

GL_RENDERBUFFER_RED_SIZE = _coin.GL_RENDERBUFFER_RED_SIZE

GL_RENDERBUFFER_GREEN_SIZE = _coin.GL_RENDERBUFFER_GREEN_SIZE

GL_RENDERBUFFER_BLUE_SIZE = _coin.GL_RENDERBUFFER_BLUE_SIZE

GL_RENDERBUFFER_ALPHA_SIZE = _coin.GL_RENDERBUFFER_ALPHA_SIZE

GL_RENDERBUFFER_DEPTH_SIZE = _coin.GL_RENDERBUFFER_DEPTH_SIZE

GL_RENDERBUFFER_STENCIL_SIZE = _coin.GL_RENDERBUFFER_STENCIL_SIZE

GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = _coin.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE

GL_MAX_SAMPLES = _coin.GL_MAX_SAMPLES

GL_NUM_EXTENSIONS = _coin.GL_NUM_EXTENSIONS

GLX_PBUFFER_WIDTH = _coin.GLX_PBUFFER_WIDTH

GLX_PBUFFER_HEIGHT = _coin.GLX_PBUFFER_HEIGHT

GLX_DRAWABLE_TYPE = _coin.GLX_DRAWABLE_TYPE

GLX_RENDER_TYPE = _coin.GLX_RENDER_TYPE

GLX_RGBA_TYPE = _coin.GLX_RGBA_TYPE

GLX_RGBA_BIT = _coin.GLX_RGBA_BIT

GLX_PBUFFER_BIT = _coin.GLX_PBUFFER_BIT

GLX_MAX_PBUFFER_WIDTH = _coin.GLX_MAX_PBUFFER_WIDTH

GLX_MAX_PBUFFER_HEIGHT = _coin.GLX_MAX_PBUFFER_HEIGHT

GLX_MAX_PBUFFER_PIXELS = _coin.GLX_MAX_PBUFFER_PIXELS

GLU_VERSION = _coin.GLU_VERSION

GLU_EXTENSIONS = _coin.GLU_EXTENSIONS

GLU_OUTLINE_POLYGON = _coin.GLU_OUTLINE_POLYGON

GLU_OUTLINE_PATCH = _coin.GLU_OUTLINE_PATCH

GLU_NURBS_ERROR = _coin.GLU_NURBS_ERROR

GLU_ERROR = _coin.GLU_ERROR

GLU_NURBS_BEGIN = _coin.GLU_NURBS_BEGIN

GLU_NURBS_VERTEX = _coin.GLU_NURBS_VERTEX

GLU_NURBS_NORMAL = _coin.GLU_NURBS_NORMAL

GLU_NURBS_COLOR = _coin.GLU_NURBS_COLOR

GLU_NURBS_TEXTURE_COORD = _coin.GLU_NURBS_TEXTURE_COORD

GLU_NURBS_END = _coin.GLU_NURBS_END

GLU_NURBS_BEGIN_DATA = _coin.GLU_NURBS_BEGIN_DATA

GLU_NURBS_VERTEX_DATA = _coin.GLU_NURBS_VERTEX_DATA

GLU_NURBS_NORMAL_DATA = _coin.GLU_NURBS_NORMAL_DATA

GLU_NURBS_COLOR_DATA = _coin.GLU_NURBS_COLOR_DATA

GLU_NURBS_TEXTURE_COORD_DATA = _coin.GLU_NURBS_TEXTURE_COORD_DATA

GLU_NURBS_END_DATA = _coin.GLU_NURBS_END_DATA

GLU_AUTO_LOAD_MATRIX = _coin.GLU_AUTO_LOAD_MATRIX

GLU_CULLING = _coin.GLU_CULLING

GLU_SAMPLING_TOLERANCE = _coin.GLU_SAMPLING_TOLERANCE

GLU_DISPLAY_MODE = _coin.GLU_DISPLAY_MODE

GLU_PARAMETRIC_TOLERANCE = _coin.GLU_PARAMETRIC_TOLERANCE

GLU_SAMPLING_METHOD = _coin.GLU_SAMPLING_METHOD

GLU_U_STEP = _coin.GLU_U_STEP

GLU_V_STEP = _coin.GLU_V_STEP

GLU_NURBS_MODE = _coin.GLU_NURBS_MODE

GLU_NURBS_TESSELLATOR = _coin.GLU_NURBS_TESSELLATOR

GLU_NURBS_RENDERER = _coin.GLU_NURBS_RENDERER

GLU_OBJECT_PARAMETRIC_ERROR = _coin.GLU_OBJECT_PARAMETRIC_ERROR

GLU_OBJECT_PATH_LENGTH = _coin.GLU_OBJECT_PATH_LENGTH

GLU_PATH_LENGTH = _coin.GLU_PATH_LENGTH

GLU_PARAMETRIC_ERROR = _coin.GLU_PARAMETRIC_ERROR

GLU_DOMAIN_DISTANCE = _coin.GLU_DOMAIN_DISTANCE

GLU_MAP1_TRIM_2 = _coin.GLU_MAP1_TRIM_2

GLU_MAP1_TRIM_3 = _coin.GLU_MAP1_TRIM_3

GLU_POINT = _coin.GLU_POINT

GLU_LINE = _coin.GLU_LINE

GLU_FILL = _coin.GLU_FILL

GLU_SILHOUETTE = _coin.GLU_SILHOUETTE

GLU_TESS_BEGIN = _coin.GLU_TESS_BEGIN

GLU_TESS_VERTEX = _coin.GLU_TESS_VERTEX

GLU_TESS_END = _coin.GLU_TESS_END

GLU_TESS_ERROR = _coin.GLU_TESS_ERROR

GLU_TESS_COMBINE = _coin.GLU_TESS_COMBINE

GLU_TESS_BEGIN_DATA = _coin.GLU_TESS_BEGIN_DATA

GLU_TESS_VERTEX_DATA = _coin.GLU_TESS_VERTEX_DATA

GLU_TESS_END_DATA = _coin.GLU_TESS_END_DATA

GLU_TESS_ERROR_DATA = _coin.GLU_TESS_ERROR_DATA

GLU_TESS_MISSING_BEGIN_POLYGON = _coin.GLU_TESS_MISSING_BEGIN_POLYGON

GLU_TESS_MISSING_BEGIN_CONTOUR = _coin.GLU_TESS_MISSING_BEGIN_CONTOUR

GLU_TESS_MISSING_END_POLYGON = _coin.GLU_TESS_MISSING_END_POLYGON

GLU_TESS_MISSING_END_CONTOUR = _coin.GLU_TESS_MISSING_END_CONTOUR

GLU_TESS_NEED_COMBINE_CALLBACK = _coin.GLU_TESS_NEED_COMBINE_CALLBACK

WGL_COLOR_BITS_ARB = _coin.WGL_COLOR_BITS_ARB

WGL_ALPHA_BITS_ARB = _coin.WGL_ALPHA_BITS_ARB

WGL_DEPTH_BITS_ARB = _coin.WGL_DEPTH_BITS_ARB

WGL_STENCIL_BITS_ARB = _coin.WGL_STENCIL_BITS_ARB

WGL_DRAW_TO_PBUFFER_ARB = _coin.WGL_DRAW_TO_PBUFFER_ARB

WGL_PBUFFER_WIDTH_ARB = _coin.WGL_PBUFFER_WIDTH_ARB

WGL_PBUFFER_HEIGHT_ARB = _coin.WGL_PBUFFER_HEIGHT_ARB

WGL_BIND_TO_TEXTURE_RGB_ARB = _coin.WGL_BIND_TO_TEXTURE_RGB_ARB

WGL_BIND_TO_TEXTURE_RGBA_ARB = _coin.WGL_BIND_TO_TEXTURE_RGBA_ARB

WGL_TEXTURE_FORMAT_ARB = _coin.WGL_TEXTURE_FORMAT_ARB

WGL_TEXTURE_TARGET_ARB = _coin.WGL_TEXTURE_TARGET_ARB

WGL_MIPMAP_TEXTURE_ARB = _coin.WGL_MIPMAP_TEXTURE_ARB

WGL_TEXTURE_RGB_ARB = _coin.WGL_TEXTURE_RGB_ARB

WGL_TEXTURE_RGBA_ARB = _coin.WGL_TEXTURE_RGBA_ARB

WGL_NO_TEXTURE_ARB = _coin.WGL_NO_TEXTURE_ARB

WGL_TEXTURE_CUBE_MAP_ARB = _coin.WGL_TEXTURE_CUBE_MAP_ARB

WGL_TEXTURE_1D_ARB = _coin.WGL_TEXTURE_1D_ARB

WGL_TEXTURE_2D_ARB = _coin.WGL_TEXTURE_2D_ARB

WGL_MIPMAP_LEVEL_ARB = _coin.WGL_MIPMAP_LEVEL_ARB

WGL_FRONT_LEFT_ARB = _coin.WGL_FRONT_LEFT_ARB

WGL_FRONT_RIGHT_ARB = _coin.WGL_FRONT_RIGHT_ARB

WGL_BACK_LEFT_ARB = _coin.WGL_BACK_LEFT_ARB

WGL_BACK_RIGHT_ARB = _coin.WGL_BACK_RIGHT_ARB

WGL_MAX_PBUFFER_PIXELS_ARB = _coin.WGL_MAX_PBUFFER_PIXELS_ARB

WGL_MAX_PBUFFER_WIDTH_ARB = _coin.WGL_MAX_PBUFFER_WIDTH_ARB

WGL_MAX_PBUFFER_HEIGHT_ARB = _coin.WGL_MAX_PBUFFER_HEIGHT_ARB

class SbBarrier(object):
    r"""Proxy of C++ SbBarrier class."""

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

    def __init__(self, count: "unsigned int"):
        r"""__init__(SbBarrier self, unsigned int count) -> SbBarrier"""
        _coin.SbBarrier_swiginit(self, _coin.new_SbBarrier(count))
    __swig_destroy__ = _coin.delete_SbBarrier

    def enter(self) -> "int":
        r"""enter(SbBarrier self) -> int"""
        return _coin.SbBarrier_enter(self)

# Register SbBarrier in _coin:
_coin.SbBarrier_swigregister(SbBarrier)

class SbMutex(object):
    r"""Proxy of C++ SbMutex class."""

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

    def __init__(self):
        r"""__init__(SbMutex self) -> SbMutex"""
        _coin.SbMutex_swiginit(self, _coin.new_SbMutex())
    __swig_destroy__ = _coin.delete_SbMutex

    def lock(self) -> "int":
        r"""lock(SbMutex self) -> int"""
        return _coin.SbMutex_lock(self)

    def tryLock(self) -> "SbBool":
        r"""tryLock(SbMutex self) -> SbBool"""
        return _coin.SbMutex_tryLock(self)

    def unlock(self) -> "int":
        r"""unlock(SbMutex self) -> int"""
        return _coin.SbMutex_unlock(self)

# Register SbMutex in _coin:
_coin.SbMutex_swigregister(SbMutex)

class SbThreadMutex(object):
    r"""Proxy of C++ SbThreadMutex class."""

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

    def __init__(self):
        r"""__init__(SbThreadMutex self) -> SbThreadMutex"""
        _coin.SbThreadMutex_swiginit(self, _coin.new_SbThreadMutex())
    __swig_destroy__ = _coin.delete_SbThreadMutex

    def lock(self) -> "int":
        r"""lock(SbThreadMutex self) -> int"""
        return _coin.SbThreadMutex_lock(self)

    def tryLock(self) -> "SbBool":
        r"""tryLock(SbThreadMutex self) -> SbBool"""
        return _coin.SbThreadMutex_tryLock(self)

    def unlock(self) -> "int":
        r"""unlock(SbThreadMutex self) -> int"""
        return _coin.SbThreadMutex_unlock(self)

# Register SbThreadMutex in _coin:
_coin.SbThreadMutex_swigregister(SbThreadMutex)

class SbThreadAutoLock(object):
    r"""Proxy of C++ SbThreadAutoLock class."""

    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):
        r"""
        __init__(SbThreadAutoLock self, SbMutex mutexptr) -> SbThreadAutoLock
        __init__(SbThreadAutoLock self, SbThreadMutex mutexptr) -> SbThreadAutoLock
        """
        _coin.SbThreadAutoLock_swiginit(self, _coin.new_SbThreadAutoLock(*args))
    __swig_destroy__ = _coin.delete_SbThreadAutoLock

# Register SbThreadAutoLock in _coin:
_coin.SbThreadAutoLock_swigregister(SbThreadAutoLock)

class SbCondVar(object):
    r"""Proxy of C++ SbCondVar class."""

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

    def __init__(self):
        r"""__init__(SbCondVar self) -> SbCondVar"""
        _coin.SbCondVar_swiginit(self, _coin.new_SbCondVar())
    __swig_destroy__ = _coin.delete_SbCondVar

    def wait(self, mutex: "SbMutex") -> "SbBool":
        r"""wait(SbCondVar self, SbMutex mutex) -> SbBool"""
        return _coin.SbCondVar_wait(self, mutex)

    def timedWait(self, mutex: "SbMutex", period: "SbTime") -> "SbBool":
        r"""timedWait(SbCondVar self, SbMutex mutex, SbTime period) -> SbBool"""
        return _coin.SbCondVar_timedWait(self, mutex, period)

    def wakeOne(self) -> "void":
        r"""wakeOne(SbCondVar self)"""
        return _coin.SbCondVar_wakeOne(self)

    def wakeAll(self) -> "void":
        r"""wakeAll(SbCondVar self)"""
        return _coin.SbCondVar_wakeAll(self)

# Register SbCondVar in _coin:
_coin.SbCondVar_swigregister(SbCondVar)

class SbFifo(object):
    r"""Proxy of C++ SbFifo class."""

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

    def __init__(self):
        r"""__init__(SbFifo self) -> SbFifo"""
        _coin.SbFifo_swiginit(self, _coin.new_SbFifo())
    __swig_destroy__ = _coin.delete_SbFifo

    def assign(self, ptr: "void *", type: "uint32_t") -> "void":
        r"""assign(SbFifo self, void * ptr, uint32_t type)"""
        return _coin.SbFifo_assign(self, ptr, type)

    def retrieve(self, ptr: "void *&", type: "uint32_t &") -> "void":
        r"""retrieve(SbFifo self, void *& ptr, uint32_t & type)"""
        return _coin.SbFifo_retrieve(self, ptr, type)

    def tryRetrieve(self, ptr: "void *&", type: "uint32_t &") -> "SbBool":
        r"""tryRetrieve(SbFifo self, void *& ptr, uint32_t & type) -> SbBool"""
        return _coin.SbFifo_tryRetrieve(self, ptr, type)

    def size(self) -> "unsigned int":
        r"""size(SbFifo self) -> unsigned int"""
        return _coin.SbFifo_size(self)

    def lock(self) -> "void":
        r"""lock(SbFifo self)"""
        return _coin.SbFifo_lock(self)

    def unlock(self) -> "void":
        r"""unlock(SbFifo self)"""
        return _coin.SbFifo_unlock(self)

    def peek(self, item: "void *&", type: "uint32_t &") -> "SbBool":
        r"""peek(SbFifo self, void *& item, uint32_t & type) -> SbBool"""
        return _coin.SbFifo_peek(self, item, type)

    def contains(self, item: "void *") -> "SbBool":
        r"""contains(SbFifo self, void * item) -> SbBool"""
        return _coin.SbFifo_contains(self, item)

    def reclaim(self, item: "void *") -> "SbBool":
        r"""reclaim(SbFifo self, void * item) -> SbBool"""
        return _coin.SbFifo_reclaim(self, item)

# Register SbFifo in _coin:
_coin.SbFifo_swigregister(SbFifo)

class SbRWMutex(object):
    r"""Proxy of C++ SbRWMutex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    READ_PRECEDENCE = _coin.SbRWMutex_READ_PRECEDENCE
    
    WRITE_PRECEDENCE = _coin.SbRWMutex_WRITE_PRECEDENCE
    

    def __init__(self, policy: "SbRWMutex::Precedence"):
        r"""__init__(SbRWMutex self, SbRWMutex::Precedence policy) -> SbRWMutex"""
        _coin.SbRWMutex_swiginit(self, _coin.new_SbRWMutex(policy))
    __swig_destroy__ = _coin.delete_SbRWMutex

    def writeLock(self) -> "int":
        r"""writeLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_writeLock(self)

    def tryWriteLock(self) -> "SbBool":
        r"""tryWriteLock(SbRWMutex self) -> SbBool"""
        return _coin.SbRWMutex_tryWriteLock(self)

    def writeUnlock(self) -> "int":
        r"""writeUnlock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_writeUnlock(self)

    def readLock(self) -> "int":
        r"""readLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_readLock(self)

    def tryReadLock(self) -> "int":
        r"""tryReadLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_tryReadLock(self)

    def readUnlock(self) -> "int":
        r"""readUnlock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_readUnlock(self)

# Register SbRWMutex in _coin:
_coin.SbRWMutex_swigregister(SbRWMutex)

class SbStorage(object):
    r"""Proxy of C++ SbStorage class."""

    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):
        r"""
        __init__(SbStorage self, unsigned int size) -> SbStorage
        __init__(SbStorage self, unsigned int size, cc_storage_f * constr, cc_storage_f * destr) -> SbStorage
        """
        _coin.SbStorage_swiginit(self, _coin.new_SbStorage(*args))
    __swig_destroy__ = _coin.delete_SbStorage

    def get(self) -> "void *":
        r"""get(SbStorage self) -> void *"""
        return _coin.SbStorage_get(self)

    def applyToAll(self, func: "SbStorageApplyFunc *", closure: "void *") -> "void":
        r"""applyToAll(SbStorage self, SbStorageApplyFunc * func, void * closure)"""
        return _coin.SbStorage_applyToAll(self, func, closure)

# Register SbStorage in _coin:
_coin.SbStorage_swigregister(SbStorage)

class SbThread(object):
    r"""Proxy of C++ SbThread class."""

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

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

    @staticmethod
    def create(func: "void *(*)(void *)", closure: "void *") -> "SbThread *":
        r"""create(void *(*)(void *) func, void * closure) -> SbThread"""
        return _coin.SbThread_create(func, closure)

    @staticmethod
    def destroy(thread: "SbThread") -> "void":
        r"""destroy(SbThread thread)"""
        return _coin.SbThread_destroy(thread)

    @staticmethod
    def join(*args) -> "SbBool":
        r"""
        join(void ** retval=None) -> SbBool
        join(SbThread thread, void ** retval=None) -> SbBool
        """
        return _coin.SbThread_join(*args)

# Register SbThread in _coin:
_coin.SbThread_swigregister(SbThread)

def SbThread_create(func: "void *(*)(void *)", closure: "void *") -> "SbThread *":
    r"""SbThread_create(void *(*)(void *) func, void * closure) -> SbThread"""
    return _coin.SbThread_create(func, closure)

def SbThread_destroy(thread: "SbThread") -> "void":
    r"""SbThread_destroy(SbThread thread)"""
    return _coin.SbThread_destroy(thread)

def SbThread_join(*args) -> "SbBool":
    r"""
    SbThread_join(void ** retval=None) -> SbBool
    SbThread_join(SbThread thread, void ** retval=None) -> SbBool
    """
    return _coin.SbThread_join(*args)

class SoVRMLParent(SoGroup):
    r"""Proxy of C++ SoVRMLParent class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLParent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLParent self) -> SoType"""
        return _coin.SoVRMLParent_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLParent_initClass()
    children = property(_coin.SoVRMLParent_children_get, _coin.SoVRMLParent_children_set, doc=r"""children : SoMFNode""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoVRMLParent self) -> SbBool"""
        return _coin.SoVRMLParent_affectsState(self)

    def addChild(self, child: "SoNode") -> "void":
        r"""addChild(SoVRMLParent self, SoNode child)"""
        return _coin.SoVRMLParent_addChild(self, child)

    def insertChild(self, child: "SoNode", idx: "int") -> "void":
        r"""insertChild(SoVRMLParent self, SoNode child, int idx)"""
        return _coin.SoVRMLParent_insertChild(self, child, idx)

    def getChild(self, idx: "int") -> "SoNode *":
        r"""getChild(SoVRMLParent self, int idx) -> SoNode"""
        return _coin.SoVRMLParent_getChild(self, idx)

    def findChild(self, child: "SoNode") -> "int":
        r"""findChild(SoVRMLParent self, SoNode child) -> int"""
        return _coin.SoVRMLParent_findChild(self, child)

    def getNumChildren(self) -> "int":
        r"""getNumChildren(SoVRMLParent self) -> int"""
        return _coin.SoVRMLParent_getNumChildren(self)

    def removeChild(self, *args) -> "void":
        r"""
        removeChild(SoVRMLParent self, int idx)
        removeChild(SoVRMLParent self, SoNode child)
        """
        return _coin.SoVRMLParent_removeChild(self, *args)

    def removeAllChildren(self) -> "void":
        r"""removeAllChildren(SoVRMLParent self)"""
        return _coin.SoVRMLParent_removeAllChildren(self)

    def replaceChild(self, *args) -> "void":
        r"""
        replaceChild(SoVRMLParent self, int idx, SoNode child)
        replaceChild(SoVRMLParent self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLParent_replaceChild(self, *args)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoVRMLParent self) -> SoChildList"""
        return _coin.SoVRMLParent_getChildren(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLParent self, SoAction action)"""
        return _coin.SoVRMLParent_doAction(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLParent self, SoSearchAction action)"""
        return _coin.SoVRMLParent_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVRMLParent self, SoWriteAction action)"""
        return _coin.SoVRMLParent_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLParent self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLParent_getPrimitiveCount(self, action)

    @staticmethod
    def updateChildList(*args) -> "void":
        r"""
        updateChildList(SoNode const *const * nodes, int const numnodes, SoChildList cl)
        updateChildList(SoNode nodewithsfnode, SoChildList cl)
        """
        return _coin.SoVRMLParent_updateChildList(*args)

# Register SoVRMLParent in _coin:
_coin.SoVRMLParent_swigregister(SoVRMLParent)

def SoVRMLParent_getClassTypeId() -> "SoType":
    r"""SoVRMLParent_getClassTypeId() -> SoType"""
    return _coin.SoVRMLParent_getClassTypeId()

def SoVRMLParent_initClass() -> "void":
    r"""SoVRMLParent_initClass()"""
    return _coin.SoVRMLParent_initClass()

def SoVRMLParent_updateChildList(*args) -> "void":
    r"""
    SoVRMLParent_updateChildList(SoNode const *const * nodes, int const numnodes, SoChildList cl)
    SoVRMLParent_updateChildList(SoNode nodewithsfnode, SoChildList cl)
    """
    return _coin.SoVRMLParent_updateChildList(*args)

class SoVRMLAnchor(SoVRMLParent):
    r"""Proxy of C++ SoVRMLAnchor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLAnchor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLAnchor self) -> SoType"""
        return _coin.SoVRMLAnchor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLAnchor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLAnchor self) -> SoVRMLAnchor"""
        _coin.SoVRMLAnchor_swiginit(self, _coin.new_SoVRMLAnchor())
    url = property(_coin.SoVRMLAnchor_url_get, _coin.SoVRMLAnchor_url_set, doc=r"""url : SoMFString""")
    description = property(_coin.SoVRMLAnchor_description_get, _coin.SoVRMLAnchor_description_set, doc=r"""description : SoSFString""")
    parameter = property(_coin.SoVRMLAnchor_parameter_get, _coin.SoVRMLAnchor_parameter_set, doc=r"""parameter : SoMFString""")
    bboxCenter = property(_coin.SoVRMLAnchor_bboxCenter_get, _coin.SoVRMLAnchor_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLAnchor_bboxSize_get, _coin.SoVRMLAnchor_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")

    @staticmethod
    def setFetchURLCallBack(arg1: "SoVRMLAnchorCB *", closure: "void *") -> "void":
        r"""setFetchURLCallBack(SoVRMLAnchorCB * arg1, void * closure)"""
        return _coin.SoVRMLAnchor_setFetchURLCallBack(arg1, closure)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoVRMLAnchor self, SoHandleEventAction action)"""
        return _coin.SoVRMLAnchor_handleEvent(self, action)

# Register SoVRMLAnchor in _coin:
_coin.SoVRMLAnchor_swigregister(SoVRMLAnchor)

def SoVRMLAnchor_getClassTypeId() -> "SoType":
    r"""SoVRMLAnchor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLAnchor_getClassTypeId()

def SoVRMLAnchor_initClass() -> "void":
    r"""SoVRMLAnchor_initClass()"""
    return _coin.SoVRMLAnchor_initClass()

def SoVRMLAnchor_setFetchURLCallBack(arg1: "SoVRMLAnchorCB *", closure: "void *") -> "void":
    r"""SoVRMLAnchor_setFetchURLCallBack(SoVRMLAnchorCB * arg1, void * closure)"""
    return _coin.SoVRMLAnchor_setFetchURLCallBack(arg1, closure)

class SoVRMLAppearance(SoNode):
    r"""Proxy of C++ SoVRMLAppearance class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLAppearance_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLAppearance self) -> SoType"""
        return _coin.SoVRMLAppearance_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLAppearance_initClass()

    def __init__(self):
        r"""__init__(SoVRMLAppearance self) -> SoVRMLAppearance"""
        _coin.SoVRMLAppearance_swiginit(self, _coin.new_SoVRMLAppearance())
    material = property(_coin.SoVRMLAppearance_material_get, _coin.SoVRMLAppearance_material_set, doc=r"""material : SoSFNode""")
    texture = property(_coin.SoVRMLAppearance_texture_get, _coin.SoVRMLAppearance_texture_set, doc=r"""texture : SoSFNode""")
    textureTransform = property(_coin.SoVRMLAppearance_textureTransform_get, _coin.SoVRMLAppearance_textureTransform_set, doc=r"""textureTransform : SoSFNode""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLAppearance self, SoAction action)"""
        return _coin.SoVRMLAppearance_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLAppearance self, SoCallbackAction action)"""
        return _coin.SoVRMLAppearance_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLAppearance self, SoGLRenderAction action)"""
        return _coin.SoVRMLAppearance_GLRender(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLAppearance self, SoSearchAction action)"""
        return _coin.SoVRMLAppearance_search(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoVRMLAppearance self) -> SoChildList"""
        return _coin.SoVRMLAppearance_getChildren(self)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLAppearance self, SoNotList list)"""
        return _coin.SoVRMLAppearance_notify(self, list)

    def copyContents(self, srcFrom: "SoFieldContainer", copyConn: "SbBool") -> "void":
        r"""copyContents(SoVRMLAppearance self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLAppearance_copyContents(self, srcFrom, copyConn)

# Register SoVRMLAppearance in _coin:
_coin.SoVRMLAppearance_swigregister(SoVRMLAppearance)

def SoVRMLAppearance_getClassTypeId() -> "SoType":
    r"""SoVRMLAppearance_getClassTypeId() -> SoType"""
    return _coin.SoVRMLAppearance_getClassTypeId()

def SoVRMLAppearance_initClass() -> "void":
    r"""SoVRMLAppearance_initClass()"""
    return _coin.SoVRMLAppearance_initClass()

class SoVRMLAudioClip(SoNode):
    r"""Proxy of C++ SoVRMLAudioClip class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLAudioClip_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLAudioClip self) -> SoType"""
        return _coin.SoVRMLAudioClip_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLAudioClip_initClass()

    def __init__(self):
        r"""__init__(SoVRMLAudioClip self) -> SoVRMLAudioClip"""
        _coin.SoVRMLAudioClip_swiginit(self, _coin.new_SoVRMLAudioClip())
    description = property(_coin.SoVRMLAudioClip_description_get, _coin.SoVRMLAudioClip_description_set, doc=r"""description : SoSFString""")
    loop = property(_coin.SoVRMLAudioClip_loop_get, _coin.SoVRMLAudioClip_loop_set, doc=r"""loop : SoSFBool""")
    pitch = property(_coin.SoVRMLAudioClip_pitch_get, _coin.SoVRMLAudioClip_pitch_set, doc=r"""pitch : SoSFFloat""")
    startTime = property(_coin.SoVRMLAudioClip_startTime_get, _coin.SoVRMLAudioClip_startTime_set, doc=r"""startTime : SoSFTime""")
    stopTime = property(_coin.SoVRMLAudioClip_stopTime_get, _coin.SoVRMLAudioClip_stopTime_set, doc=r"""stopTime : SoSFTime""")
    url = property(_coin.SoVRMLAudioClip_url_get, _coin.SoVRMLAudioClip_url_set, doc=r"""url : SoMFString""")

    @staticmethod
    def setSubdirectories(subdirectories: "SbList< SbString > const &") -> "void":
        r"""setSubdirectories(SbList< SbString > const & subdirectories)"""
        return _coin.SoVRMLAudioClip_setSubdirectories(subdirectories)

    @staticmethod
    def getSubdirectories() -> "SbStringList const &":
        r"""getSubdirectories() -> SbStringList"""
        return _coin.SoVRMLAudioClip_getSubdirectories()

    @staticmethod
    def setDefaultPauseBetweenTracks(pause: "SbTime") -> "void":
        r"""setDefaultPauseBetweenTracks(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultPauseBetweenTracks(pause)

    @staticmethod
    def getDefaultPauseBetweenTracks() -> "SbTime":
        r"""getDefaultPauseBetweenTracks() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultPauseBetweenTracks()

    @staticmethod
    def setDefaultIntroPause(pause: "SbTime") -> "void":
        r"""setDefaultIntroPause(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultIntroPause(pause)

    @staticmethod
    def getDefaultIntroPause() -> "SbTime":
        r"""getDefaultIntroPause() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultIntroPause()

    @staticmethod
    def setDefaultSampleRate(samplerate: "int") -> "void":
        r"""setDefaultSampleRate(int samplerate)"""
        return _coin.SoVRMLAudioClip_setDefaultSampleRate(samplerate)

    @staticmethod
    def getDefaultSampleRate() -> "int":
        r"""getDefaultSampleRate() -> int"""
        return _coin.SoVRMLAudioClip_getDefaultSampleRate()

    @staticmethod
    def setDefaultTimerInterval(interval: "SbTime") -> "void":
        r"""setDefaultTimerInterval(SbTime interval)"""
        return _coin.SoVRMLAudioClip_setDefaultTimerInterval(interval)

    @staticmethod
    def getDefaultTimerInterval() -> "SbTime":
        r"""getDefaultTimerInterval() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultTimerInterval()

    def getSampleRate(self) -> "int":
        r"""getSampleRate(SoVRMLAudioClip self) -> int"""
        return _coin.SoVRMLAudioClip_getSampleRate(self)

    def open(self, url: "SbStringList") -> "void *":
        r"""open(SoVRMLAudioClip self, SbStringList url) -> void *"""
        return _coin.SoVRMLAudioClip_open(self, url)

    def read(self, datasource: "void *", buffer: "void *", numframes: "int", channels: "int &") -> "size_t":
        r"""read(SoVRMLAudioClip self, void * datasource, void * buffer, int numframes, int & channels) -> size_t"""
        return _coin.SoVRMLAudioClip_read(self, datasource, buffer, numframes, channels)

    def seek(self, datasource: "void *", offset: "long", whence: "int") -> "int":
        r"""seek(SoVRMLAudioClip self, void * datasource, long offset, int whence) -> int"""
        return _coin.SoVRMLAudioClip_seek(self, datasource, offset, whence)

    def tell(self, datasource: "void *") -> "long":
        r"""tell(SoVRMLAudioClip self, void * datasource) -> long"""
        return _coin.SoVRMLAudioClip_tell(self, datasource)

    def close(self, datasource: "void *") -> "int":
        r"""close(SoVRMLAudioClip self, void * datasource) -> int"""
        return _coin.SoVRMLAudioClip_close(self, datasource)

    def setCallbacks(self, opencb: "SoVRMLAudioClip::open_func *", readcb: "SoVRMLAudioClip::read_func *", seekcb: "SoVRMLAudioClip::seek_func *", tellcb: "SoVRMLAudioClip::tell_func *", closecb: "SoVRMLAudioClip::close_func *", userdataptr: "void *") -> "void":
        r"""setCallbacks(SoVRMLAudioClip self, SoVRMLAudioClip::open_func * opencb, SoVRMLAudioClip::read_func * readcb, SoVRMLAudioClip::seek_func * seekcb, SoVRMLAudioClip::tell_func * tellcb, SoVRMLAudioClip::close_func * closecb, void * userdataptr)"""
        return _coin.SoVRMLAudioClip_setCallbacks(self, opencb, readcb, seekcb, tellcb, closecb, userdataptr)

# Register SoVRMLAudioClip in _coin:
_coin.SoVRMLAudioClip_swigregister(SoVRMLAudioClip)

def SoVRMLAudioClip_getClassTypeId() -> "SoType":
    r"""SoVRMLAudioClip_getClassTypeId() -> SoType"""
    return _coin.SoVRMLAudioClip_getClassTypeId()

def SoVRMLAudioClip_initClass() -> "void":
    r"""SoVRMLAudioClip_initClass()"""
    return _coin.SoVRMLAudioClip_initClass()

def SoVRMLAudioClip_setSubdirectories(subdirectories: "SbList< SbString > const &") -> "void":
    r"""SoVRMLAudioClip_setSubdirectories(SbList< SbString > const & subdirectories)"""
    return _coin.SoVRMLAudioClip_setSubdirectories(subdirectories)

def SoVRMLAudioClip_getSubdirectories() -> "SbStringList const &":
    r"""SoVRMLAudioClip_getSubdirectories() -> SbStringList"""
    return _coin.SoVRMLAudioClip_getSubdirectories()

def SoVRMLAudioClip_setDefaultPauseBetweenTracks(pause: "SbTime") -> "void":
    r"""SoVRMLAudioClip_setDefaultPauseBetweenTracks(SbTime pause)"""
    return _coin.SoVRMLAudioClip_setDefaultPauseBetweenTracks(pause)

def SoVRMLAudioClip_getDefaultPauseBetweenTracks() -> "SbTime":
    r"""SoVRMLAudioClip_getDefaultPauseBetweenTracks() -> SbTime"""
    return _coin.SoVRMLAudioClip_getDefaultPauseBetweenTracks()

def SoVRMLAudioClip_setDefaultIntroPause(pause: "SbTime") -> "void":
    r"""SoVRMLAudioClip_setDefaultIntroPause(SbTime pause)"""
    return _coin.SoVRMLAudioClip_setDefaultIntroPause(pause)

def SoVRMLAudioClip_getDefaultIntroPause() -> "SbTime":
    r"""SoVRMLAudioClip_getDefaultIntroPause() -> SbTime"""
    return _coin.SoVRMLAudioClip_getDefaultIntroPause()

def SoVRMLAudioClip_setDefaultSampleRate(samplerate: "int") -> "void":
    r"""SoVRMLAudioClip_setDefaultSampleRate(int samplerate)"""
    return _coin.SoVRMLAudioClip_setDefaultSampleRate(samplerate)

def SoVRMLAudioClip_getDefaultSampleRate() -> "int":
    r"""SoVRMLAudioClip_getDefaultSampleRate() -> int"""
    return _coin.SoVRMLAudioClip_getDefaultSampleRate()

def SoVRMLAudioClip_setDefaultTimerInterval(interval: "SbTime") -> "void":
    r"""SoVRMLAudioClip_setDefaultTimerInterval(SbTime interval)"""
    return _coin.SoVRMLAudioClip_setDefaultTimerInterval(interval)

def SoVRMLAudioClip_getDefaultTimerInterval() -> "SbTime":
    r"""SoVRMLAudioClip_getDefaultTimerInterval() -> SbTime"""
    return _coin.SoVRMLAudioClip_getDefaultTimerInterval()

class SoVRMLBackground(SoNode):
    r"""Proxy of C++ SoVRMLBackground class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLBackground_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLBackground self) -> SoType"""
        return _coin.SoVRMLBackground_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLBackground_initClass()

    def __init__(self):
        r"""__init__(SoVRMLBackground self) -> SoVRMLBackground"""
        _coin.SoVRMLBackground_swiginit(self, _coin.new_SoVRMLBackground())
    groundColor = property(_coin.SoVRMLBackground_groundColor_get, _coin.SoVRMLBackground_groundColor_set, doc=r"""groundColor : SoMFColor""")
    groundAngle = property(_coin.SoVRMLBackground_groundAngle_get, _coin.SoVRMLBackground_groundAngle_set, doc=r"""groundAngle : SoMFFloat""")
    skyColor = property(_coin.SoVRMLBackground_skyColor_get, _coin.SoVRMLBackground_skyColor_set, doc=r"""skyColor : SoMFColor""")
    skyAngle = property(_coin.SoVRMLBackground_skyAngle_get, _coin.SoVRMLBackground_skyAngle_set, doc=r"""skyAngle : SoMFFloat""")
    backUrl = property(_coin.SoVRMLBackground_backUrl_get, _coin.SoVRMLBackground_backUrl_set, doc=r"""backUrl : SoMFString""")
    bottomUrl = property(_coin.SoVRMLBackground_bottomUrl_get, _coin.SoVRMLBackground_bottomUrl_set, doc=r"""bottomUrl : SoMFString""")
    frontUrl = property(_coin.SoVRMLBackground_frontUrl_get, _coin.SoVRMLBackground_frontUrl_set, doc=r"""frontUrl : SoMFString""")
    leftUrl = property(_coin.SoVRMLBackground_leftUrl_get, _coin.SoVRMLBackground_leftUrl_set, doc=r"""leftUrl : SoMFString""")
    rightUrl = property(_coin.SoVRMLBackground_rightUrl_get, _coin.SoVRMLBackground_rightUrl_set, doc=r"""rightUrl : SoMFString""")
    topUrl = property(_coin.SoVRMLBackground_topUrl_get, _coin.SoVRMLBackground_topUrl_set, doc=r"""topUrl : SoMFString""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLBackground self, SoGLRenderAction action)"""
        return _coin.SoVRMLBackground_GLRender(self, action)

# Register SoVRMLBackground in _coin:
_coin.SoVRMLBackground_swigregister(SoVRMLBackground)

def SoVRMLBackground_getClassTypeId() -> "SoType":
    r"""SoVRMLBackground_getClassTypeId() -> SoType"""
    return _coin.SoVRMLBackground_getClassTypeId()

def SoVRMLBackground_initClass() -> "void":
    r"""SoVRMLBackground_initClass()"""
    return _coin.SoVRMLBackground_initClass()

class SoVRMLBillboard(SoVRMLParent):
    r"""Proxy of C++ SoVRMLBillboard class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLBillboard_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLBillboard self) -> SoType"""
        return _coin.SoVRMLBillboard_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLBillboard_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLBillboard self) -> SoVRMLBillboard
        __init__(SoVRMLBillboard self, int numchildren) -> SoVRMLBillboard
        """
        _coin.SoVRMLBillboard_swiginit(self, _coin.new_SoVRMLBillboard(*args))
    axisOfRotation = property(_coin.SoVRMLBillboard_axisOfRotation_get, _coin.SoVRMLBillboard_axisOfRotation_set, doc=r"""axisOfRotation : SoSFVec3f""")
    bboxCenter = property(_coin.SoVRMLBillboard_bboxCenter_get, _coin.SoVRMLBillboard_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLBillboard_bboxSize_get, _coin.SoVRMLBillboard_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLBillboard self, SoAction action)"""
        return _coin.SoVRMLBillboard_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLBillboard self, SoCallbackAction action)"""
        return _coin.SoVRMLBillboard_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLBillboard self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLBillboard_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoVRMLBillboard self, SoGetMatrixAction action)"""
        return _coin.SoVRMLBillboard_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLBillboard self, SoPickAction action)"""
        return _coin.SoVRMLBillboard_pick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLBillboard self, SoSearchAction action)"""
        return _coin.SoVRMLBillboard_search(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderOffPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderOffPath(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLBillboard self, SoNotList list)"""
        return _coin.SoVRMLBillboard_notify(self, list)

# Register SoVRMLBillboard in _coin:
_coin.SoVRMLBillboard_swigregister(SoVRMLBillboard)

def SoVRMLBillboard_getClassTypeId() -> "SoType":
    r"""SoVRMLBillboard_getClassTypeId() -> SoType"""
    return _coin.SoVRMLBillboard_getClassTypeId()

def SoVRMLBillboard_initClass() -> "void":
    r"""SoVRMLBillboard_initClass()"""
    return _coin.SoVRMLBillboard_initClass()

class SoVRMLGeometry(SoShape):
    r"""Proxy of C++ SoVRMLGeometry class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLGeometry_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLGeometry self) -> SoType"""
        return _coin.SoVRMLGeometry_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLGeometry_initClass()

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLGeometry self, SoSearchAction action)"""
        return _coin.SoVRMLGeometry_search(self, action)

    def copyContents(self, srcFrom: "SoFieldContainer", copyConn: "SbBool") -> "void":
        r"""copyContents(SoVRMLGeometry self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLGeometry_copyContents(self, srcFrom, copyConn)

# Register SoVRMLGeometry in _coin:
_coin.SoVRMLGeometry_swigregister(SoVRMLGeometry)

def SoVRMLGeometry_getClassTypeId() -> "SoType":
    r"""SoVRMLGeometry_getClassTypeId() -> SoType"""
    return _coin.SoVRMLGeometry_getClassTypeId()

def SoVRMLGeometry_initClass() -> "void":
    r"""SoVRMLGeometry_initClass()"""
    return _coin.SoVRMLGeometry_initClass()

class SoVRMLBox(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLBox class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLBox_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLBox self) -> SoType"""
        return _coin.SoVRMLBox_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLBox_initClass()

    def __init__(self):
        r"""__init__(SoVRMLBox self) -> SoVRMLBox"""
        _coin.SoVRMLBox_swiginit(self, _coin.new_SoVRMLBox())
    size = property(_coin.SoVRMLBox_size_get, _coin.SoVRMLBox_size_set, doc=r"""size : SoSFVec3f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLBox self, SoGLRenderAction action)"""
        return _coin.SoVRMLBox_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLBox self, SoRayPickAction action)"""
        return _coin.SoVRMLBox_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLBox self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLBox_getPrimitiveCount(self, action)

# Register SoVRMLBox in _coin:
_coin.SoVRMLBox_swigregister(SoVRMLBox)

def SoVRMLBox_getClassTypeId() -> "SoType":
    r"""SoVRMLBox_getClassTypeId() -> SoType"""
    return _coin.SoVRMLBox_getClassTypeId()

def SoVRMLBox_initClass() -> "void":
    r"""SoVRMLBox_initClass()"""
    return _coin.SoVRMLBox_initClass()

class SoVRMLGroup(SoVRMLParent):
    r"""Proxy of C++ SoVRMLGroup class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLGroup_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLGroup self) -> SoType"""
        return _coin.SoVRMLGroup_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLGroup_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLGroup self) -> SoVRMLGroup
        __init__(SoVRMLGroup self, int numChildren) -> SoVRMLGroup
        """
        _coin.SoVRMLGroup_swiginit(self, _coin.new_SoVRMLGroup(*args))
    OFF = _coin.SoVRMLGroup_OFF
    
    ON = _coin.SoVRMLGroup_ON
    
    AUTO = _coin.SoVRMLGroup_AUTO
    
    renderCaching = property(_coin.SoVRMLGroup_renderCaching_get, _coin.SoVRMLGroup_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoVRMLGroup_boundingBoxCaching_get, _coin.SoVRMLGroup_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoVRMLGroup_renderCulling_get, _coin.SoVRMLGroup_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoVRMLGroup_pickCulling_get, _coin.SoVRMLGroup_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")
    bboxCenter = property(_coin.SoVRMLGroup_bboxCenter_get, _coin.SoVRMLGroup_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLGroup_bboxSize_get, _coin.SoVRMLGroup_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")

    @staticmethod
    def setNumRenderCaches(num: "int") -> "void":
        r"""setNumRenderCaches(int num)"""
        return _coin.SoVRMLGroup_setNumRenderCaches(num)

    @staticmethod
    def getNumRenderCaches() -> "int":
        r"""getNumRenderCaches() -> int"""
        return _coin.SoVRMLGroup_getNumRenderCaches()

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLGroup self, SoAction action)"""
        return _coin.SoVRMLGroup_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLGroup self, SoCallbackAction action)"""
        return _coin.SoVRMLGroup_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLGroup self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLGroup_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoVRMLGroup self, SoGetMatrixAction action)"""
        return _coin.SoVRMLGroup_getMatrix(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLGroup self, SoRayPickAction action)"""
        return _coin.SoVRMLGroup_rayPick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLGroup self, SoSearchAction action)"""
        return _coin.SoVRMLGroup_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVRMLGroup self, SoWriteAction action)"""
        return _coin.SoVRMLGroup_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLGroup self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLGroup_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoVRMLGroup self, SoAudioRenderAction action)"""
        return _coin.SoVRMLGroup_audioRender(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderOffPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderOffPath(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLGroup self, SoNotList list)"""
        return _coin.SoVRMLGroup_notify(self, list)

# Register SoVRMLGroup in _coin:
_coin.SoVRMLGroup_swigregister(SoVRMLGroup)

def SoVRMLGroup_getClassTypeId() -> "SoType":
    r"""SoVRMLGroup_getClassTypeId() -> SoType"""
    return _coin.SoVRMLGroup_getClassTypeId()

def SoVRMLGroup_initClass() -> "void":
    r"""SoVRMLGroup_initClass()"""
    return _coin.SoVRMLGroup_initClass()

def SoVRMLGroup_setNumRenderCaches(num: "int") -> "void":
    r"""SoVRMLGroup_setNumRenderCaches(int num)"""
    return _coin.SoVRMLGroup_setNumRenderCaches(num)

def SoVRMLGroup_getNumRenderCaches() -> "int":
    r"""SoVRMLGroup_getNumRenderCaches() -> int"""
    return _coin.SoVRMLGroup_getNumRenderCaches()

class SoVRMLCollision(SoVRMLGroup):
    r"""Proxy of C++ SoVRMLCollision class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCollision_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLCollision self) -> SoType"""
        return _coin.SoVRMLCollision_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLCollision_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLCollision self) -> SoVRMLCollision
        __init__(SoVRMLCollision self, int numchildren) -> SoVRMLCollision
        """
        _coin.SoVRMLCollision_swiginit(self, _coin.new_SoVRMLCollision(*args))
    collide = property(_coin.SoVRMLCollision_collide_get, _coin.SoVRMLCollision_collide_set, doc=r"""collide : SoSFBool""")
    proxy = property(_coin.SoVRMLCollision_proxy_get, _coin.SoVRMLCollision_proxy_set, doc=r"""proxy : SoSFNode""")
    collideTime = property(_coin.SoVRMLCollision_collideTime_get, _coin.SoVRMLCollision_collideTime_set, doc=r"""collideTime : SoSFTime""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLCollision self, SoGLRenderAction action)"""
        return _coin.SoVRMLCollision_GLRender(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLCollision self, SoNotList list)"""
        return _coin.SoVRMLCollision_notify(self, list)

# Register SoVRMLCollision in _coin:
_coin.SoVRMLCollision_swigregister(SoVRMLCollision)

def SoVRMLCollision_getClassTypeId() -> "SoType":
    r"""SoVRMLCollision_getClassTypeId() -> SoType"""
    return _coin.SoVRMLCollision_getClassTypeId()

def SoVRMLCollision_initClass() -> "void":
    r"""SoVRMLCollision_initClass()"""
    return _coin.SoVRMLCollision_initClass()

class SoVRMLColor(SoNode):
    r"""Proxy of C++ SoVRMLColor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLColor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLColor self) -> SoType"""
        return _coin.SoVRMLColor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLColor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLColor self) -> SoVRMLColor"""
        _coin.SoVRMLColor_swiginit(self, _coin.new_SoVRMLColor())
    color = property(_coin.SoVRMLColor_color_get, _coin.SoVRMLColor_color_set, doc=r"""color : SoMFColor""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLColor self, SoAction action)"""
        return _coin.SoVRMLColor_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLColor self, SoGLRenderAction action)"""
        return _coin.SoVRMLColor_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLColor self, SoCallbackAction action)"""
        return _coin.SoVRMLColor_callback(self, action)

# Register SoVRMLColor in _coin:
_coin.SoVRMLColor_swigregister(SoVRMLColor)

def SoVRMLColor_getClassTypeId() -> "SoType":
    r"""SoVRMLColor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLColor_getClassTypeId()

def SoVRMLColor_initClass() -> "void":
    r"""SoVRMLColor_initClass()"""
    return _coin.SoVRMLColor_initClass()

class SoVRMLInterpolator(SoNodeEngine):
    r"""Proxy of C++ SoVRMLInterpolator class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLInterpolator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLInterpolator self) -> SoType"""
        return _coin.SoVRMLInterpolator_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLInterpolator_getOutputData(self)
    key = property(_coin.SoVRMLInterpolator_key_get, _coin.SoVRMLInterpolator_key_set, doc=r"""key : SoMFFloat""")
    set_fraction = property(_coin.SoVRMLInterpolator_set_fraction_get, _coin.SoVRMLInterpolator_set_fraction_set, doc=r"""set_fraction : SoSFFloat""")

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLInterpolator_initClass()

# Register SoVRMLInterpolator in _coin:
_coin.SoVRMLInterpolator_swigregister(SoVRMLInterpolator)

def SoVRMLInterpolator_getClassTypeId() -> "SoType":
    r"""SoVRMLInterpolator_getClassTypeId() -> SoType"""
    return _coin.SoVRMLInterpolator_getClassTypeId()

def SoVRMLInterpolator_initClass() -> "void":
    r"""SoVRMLInterpolator_initClass()"""
    return _coin.SoVRMLInterpolator_initClass()

class SoVRMLColorInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLColorInterpolator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLColorInterpolator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLColorInterpolator self) -> SoType"""
        return _coin.SoVRMLColorInterpolator_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLColorInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLColorInterpolator_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVRMLColorInterpolator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLColorInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLColorInterpolator self) -> SoVRMLColorInterpolator"""
        _coin.SoVRMLColorInterpolator_swiginit(self, _coin.new_SoVRMLColorInterpolator())
    keyValue = property(_coin.SoVRMLColorInterpolator_keyValue_get, _coin.SoVRMLColorInterpolator_keyValue_set, doc=r"""keyValue : SoMFColor""")
    value_changed = property(_coin.SoVRMLColorInterpolator_value_changed_get, _coin.SoVRMLColorInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLColorInterpolator in _coin:
_coin.SoVRMLColorInterpolator_swigregister(SoVRMLColorInterpolator)

def SoVRMLColorInterpolator_getClassTypeId() -> "SoType":
    r"""SoVRMLColorInterpolator_getClassTypeId() -> SoType"""
    return _coin.SoVRMLColorInterpolator_getClassTypeId()

def SoVRMLColorInterpolator_createInstance() -> "void *":
    r"""SoVRMLColorInterpolator_createInstance() -> void *"""
    return _coin.SoVRMLColorInterpolator_createInstance()

def SoVRMLColorInterpolator_initClass() -> "void":
    r"""SoVRMLColorInterpolator_initClass()"""
    return _coin.SoVRMLColorInterpolator_initClass()

class SoVRMLCone(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLCone class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCone_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLCone self) -> SoType"""
        return _coin.SoVRMLCone_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLCone_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCone self) -> SoVRMLCone"""
        _coin.SoVRMLCone_swiginit(self, _coin.new_SoVRMLCone())
    bottomRadius = property(_coin.SoVRMLCone_bottomRadius_get, _coin.SoVRMLCone_bottomRadius_set, doc=r"""bottomRadius : SoSFFloat""")
    height = property(_coin.SoVRMLCone_height_get, _coin.SoVRMLCone_height_set, doc=r"""height : SoSFFloat""")
    side = property(_coin.SoVRMLCone_side_get, _coin.SoVRMLCone_side_set, doc=r"""side : SoSFBool""")
    bottom = property(_coin.SoVRMLCone_bottom_get, _coin.SoVRMLCone_bottom_set, doc=r"""bottom : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLCone self, SoGLRenderAction action)"""
        return _coin.SoVRMLCone_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLCone self, SoRayPickAction action)"""
        return _coin.SoVRMLCone_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLCone self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCone_getPrimitiveCount(self, action)

# Register SoVRMLCone in _coin:
_coin.SoVRMLCone_swigregister(SoVRMLCone)

def SoVRMLCone_getClassTypeId() -> "SoType":
    r"""SoVRMLCone_getClassTypeId() -> SoType"""
    return _coin.SoVRMLCone_getClassTypeId()

def SoVRMLCone_initClass() -> "void":
    r"""SoVRMLCone_initClass()"""
    return _coin.SoVRMLCone_initClass()

class SoVRMLCoordinate(SoNode):
    r"""Proxy of C++ SoVRMLCoordinate class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCoordinate_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLCoordinate self) -> SoType"""
        return _coin.SoVRMLCoordinate_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLCoordinate_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCoordinate self) -> SoVRMLCoordinate"""
        _coin.SoVRMLCoordinate_swiginit(self, _coin.new_SoVRMLCoordinate())
    point = property(_coin.SoVRMLCoordinate_point_get, _coin.SoVRMLCoordinate_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLCoordinate self, SoAction action)"""
        return _coin.SoVRMLCoordinate_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLCoordinate self, SoGLRenderAction action)"""
        return _coin.SoVRMLCoordinate_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLCoordinate self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLCoordinate_getBoundingBox(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLCoordinate self, SoCallbackAction action)"""
        return _coin.SoVRMLCoordinate_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLCoordinate self, SoPickAction action)"""
        return _coin.SoVRMLCoordinate_pick(self, action)

# Register SoVRMLCoordinate in _coin:
_coin.SoVRMLCoordinate_swigregister(SoVRMLCoordinate)

def SoVRMLCoordinate_getClassTypeId() -> "SoType":
    r"""SoVRMLCoordinate_getClassTypeId() -> SoType"""
    return _coin.SoVRMLCoordinate_getClassTypeId()

def SoVRMLCoordinate_initClass() -> "void":
    r"""SoVRMLCoordinate_initClass()"""
    return _coin.SoVRMLCoordinate_initClass()

class SoVRMLCoordinateInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLCoordinateInterpolator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCoordinateInterpolator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLCoordinateInterpolator self) -> SoType"""
        return _coin.SoVRMLCoordinateInterpolator_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLCoordinateInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLCoordinateInterpolator_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVRMLCoordinateInterpolator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLCoordinateInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCoordinateInterpolator self) -> SoVRMLCoordinateInterpolator"""
        _coin.SoVRMLCoordinateInterpolator_swiginit(self, _coin.new_SoVRMLCoordinateInterpolator())
    keyValue = property(_coin.SoVRMLCoordinateInterpolator_keyValue_get, _coin.SoVRMLCoordinateInterpolator_keyValue_set, doc=r"""keyValue : SoMFVec3f""")
    value_changed = property(_coin.SoVRMLCoordinateInterpolator_value_changed_get, _coin.SoVRMLCoordinateInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLCoordinateInterpolator in _coin:
_coin.SoVRMLCoordinateInterpolator_swigregister(SoVRMLCoordinateInterpolator)

def SoVRMLCoordinateInterpolator_getClassTypeId() -> "SoType":
    r"""SoVRMLCoordinateInterpolator_getClassTypeId() -> SoType"""
    return _coin.SoVRMLCoordinateInterpolator_getClassTypeId()

def SoVRMLCoordinateInterpolator_createInstance() -> "void *":
    r"""SoVRMLCoordinateInterpolator_createInstance() -> void *"""
    return _coin.SoVRMLCoordinateInterpolator_createInstance()

def SoVRMLCoordinateInterpolator_initClass() -> "void":
    r"""SoVRMLCoordinateInterpolator_initClass()"""
    return _coin.SoVRMLCoordinateInterpolator_initClass()

class SoVRMLCylinder(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLCylinder class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCylinder_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLCylinder self) -> SoType"""
        return _coin.SoVRMLCylinder_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLCylinder_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCylinder self) -> SoVRMLCylinder"""
        _coin.SoVRMLCylinder_swiginit(self, _coin.new_SoVRMLCylinder())
    radius = property(_coin.SoVRMLCylinder_radius_get, _coin.SoVRMLCylinder_radius_set, doc=r"""radius : SoSFFloat""")
    height = property(_coin.SoVRMLCylinder_height_get, _coin.SoVRMLCylinder_height_set, doc=r"""height : SoSFFloat""")
    side = property(_coin.SoVRMLCylinder_side_get, _coin.SoVRMLCylinder_side_set, doc=r"""side : SoSFBool""")
    top = property(_coin.SoVRMLCylinder_top_get, _coin.SoVRMLCylinder_top_set, doc=r"""top : SoSFBool""")
    bottom = property(_coin.SoVRMLCylinder_bottom_get, _coin.SoVRMLCylinder_bottom_set, doc=r"""bottom : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLCylinder self, SoGLRenderAction action)"""
        return _coin.SoVRMLCylinder_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLCylinder self, SoRayPickAction action)"""
        return _coin.SoVRMLCylinder_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLCylinder self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCylinder_getPrimitiveCount(self, action)

# Register SoVRMLCylinder in _coin:
_coin.SoVRMLCylinder_swigregister(SoVRMLCylinder)

def SoVRMLCylinder_getClassTypeId() -> "SoType":
    r"""SoVRMLCylinder_getClassTypeId() -> SoType"""
    return _coin.SoVRMLCylinder_getClassTypeId()

def SoVRMLCylinder_initClass() -> "void":
    r"""SoVRMLCylinder_initClass()"""
    return _coin.SoVRMLCylinder_initClass()

class SoVRMLSensor(SoNode):
    r"""Proxy of C++ SoVRMLSensor class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLSensor self) -> SoType"""
        return _coin.SoVRMLSensor_getTypeId(self)
    isActive = property(_coin.SoVRMLSensor_isActive_get, _coin.SoVRMLSensor_isActive_set, doc=r"""isActive : SoSFBool""")
    enabled = property(_coin.SoVRMLSensor_enabled_get, _coin.SoVRMLSensor_enabled_set, doc=r"""enabled : SoSFBool""")

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLSensor_initClass()

# Register SoVRMLSensor in _coin:
_coin.SoVRMLSensor_swigregister(SoVRMLSensor)

def SoVRMLSensor_getClassTypeId() -> "SoType":
    r"""SoVRMLSensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLSensor_getClassTypeId()

def SoVRMLSensor_initClass() -> "void":
    r"""SoVRMLSensor_initClass()"""
    return _coin.SoVRMLSensor_initClass()

class SoVRMLDragSensor(SoVRMLSensor):
    r"""Proxy of C++ SoVRMLDragSensor class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLDragSensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLDragSensor self) -> SoType"""
        return _coin.SoVRMLDragSensor_getTypeId(self)
    trackPoint_changed = property(_coin.SoVRMLDragSensor_trackPoint_changed_get, _coin.SoVRMLDragSensor_trackPoint_changed_set, doc=r"""trackPoint_changed : SoSFVec3f""")
    autoOffset = property(_coin.SoVRMLDragSensor_autoOffset_get, _coin.SoVRMLDragSensor_autoOffset_set, doc=r"""autoOffset : SoSFBool""")

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoVRMLDragSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLDragSensor_handleEvent(self, action)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLDragSensor_initClass()

# Register SoVRMLDragSensor in _coin:
_coin.SoVRMLDragSensor_swigregister(SoVRMLDragSensor)

def SoVRMLDragSensor_getClassTypeId() -> "SoType":
    r"""SoVRMLDragSensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLDragSensor_getClassTypeId()

def SoVRMLDragSensor_initClass() -> "void":
    r"""SoVRMLDragSensor_initClass()"""
    return _coin.SoVRMLDragSensor_initClass()

class SoVRMLCylinderSensor(SoVRMLDragSensor):
    r"""Proxy of C++ SoVRMLCylinderSensor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCylinderSensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLCylinderSensor self) -> SoType"""
        return _coin.SoVRMLCylinderSensor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLCylinderSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCylinderSensor self) -> SoVRMLCylinderSensor"""
        _coin.SoVRMLCylinderSensor_swiginit(self, _coin.new_SoVRMLCylinderSensor())
    diskAngle = property(_coin.SoVRMLCylinderSensor_diskAngle_get, _coin.SoVRMLCylinderSensor_diskAngle_set, doc=r"""diskAngle : SoSFFloat""")
    maxAngle = property(_coin.SoVRMLCylinderSensor_maxAngle_get, _coin.SoVRMLCylinderSensor_maxAngle_set, doc=r"""maxAngle : SoSFFloat""")
    minAngle = property(_coin.SoVRMLCylinderSensor_minAngle_get, _coin.SoVRMLCylinderSensor_minAngle_set, doc=r"""minAngle : SoSFFloat""")
    offset = property(_coin.SoVRMLCylinderSensor_offset_get, _coin.SoVRMLCylinderSensor_offset_set, doc=r"""offset : SoSFFloat""")
    rotation_changed = property(_coin.SoVRMLCylinderSensor_rotation_changed_get, _coin.SoVRMLCylinderSensor_rotation_changed_set, doc=r"""rotation_changed : SoSFRotation""")

# Register SoVRMLCylinderSensor in _coin:
_coin.SoVRMLCylinderSensor_swigregister(SoVRMLCylinderSensor)

def SoVRMLCylinderSensor_getClassTypeId() -> "SoType":
    r"""SoVRMLCylinderSensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLCylinderSensor_getClassTypeId()

def SoVRMLCylinderSensor_initClass() -> "void":
    r"""SoVRMLCylinderSensor_initClass()"""
    return _coin.SoVRMLCylinderSensor_initClass()

class SoVRMLLight(SoNode):
    r"""Proxy of C++ SoVRMLLight class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLLight self) -> SoType"""
        return _coin.SoVRMLLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLLight_initClass()
    on = property(_coin.SoVRMLLight_on_get, _coin.SoVRMLLight_on_set, doc=r"""on : SoSFBool""")
    intensity = property(_coin.SoVRMLLight_intensity_get, _coin.SoVRMLLight_intensity_set, doc=r"""intensity : SoSFFloat""")
    color = property(_coin.SoVRMLLight_color_get, _coin.SoVRMLLight_color_set, doc=r"""color : SoSFColor""")
    ambientIntensity = property(_coin.SoVRMLLight_ambientIntensity_get, _coin.SoVRMLLight_ambientIntensity_set, doc=r"""ambientIntensity : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLLight_GLRender(self, action)

# Register SoVRMLLight in _coin:
_coin.SoVRMLLight_swigregister(SoVRMLLight)

def SoVRMLLight_getClassTypeId() -> "SoType":
    r"""SoVRMLLight_getClassTypeId() -> SoType"""
    return _coin.SoVRMLLight_getClassTypeId()

def SoVRMLLight_initClass() -> "void":
    r"""SoVRMLLight_initClass()"""
    return _coin.SoVRMLLight_initClass()

class SoVRMLDirectionalLight(SoVRMLLight):
    r"""Proxy of C++ SoVRMLDirectionalLight class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLDirectionalLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLDirectionalLight self) -> SoType"""
        return _coin.SoVRMLDirectionalLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLDirectionalLight_initClass()

    def __init__(self):
        r"""__init__(SoVRMLDirectionalLight self) -> SoVRMLDirectionalLight"""
        _coin.SoVRMLDirectionalLight_swiginit(self, _coin.new_SoVRMLDirectionalLight())
    direction = property(_coin.SoVRMLDirectionalLight_direction_get, _coin.SoVRMLDirectionalLight_direction_set, doc=r"""direction : SoSFVec3f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLDirectionalLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLDirectionalLight_GLRender(self, action)

# Register SoVRMLDirectionalLight in _coin:
_coin.SoVRMLDirectionalLight_swigregister(SoVRMLDirectionalLight)

def SoVRMLDirectionalLight_getClassTypeId() -> "SoType":
    r"""SoVRMLDirectionalLight_getClassTypeId() -> SoType"""
    return _coin.SoVRMLDirectionalLight_getClassTypeId()

def SoVRMLDirectionalLight_initClass() -> "void":
    r"""SoVRMLDirectionalLight_initClass()"""
    return _coin.SoVRMLDirectionalLight_initClass()

class SoVRMLElevationGrid(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLElevationGrid class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLElevationGrid_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLElevationGrid self) -> SoType"""
        return _coin.SoVRMLElevationGrid_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLElevationGrid_initClass()

    def __init__(self):
        r"""__init__(SoVRMLElevationGrid self) -> SoVRMLElevationGrid"""
        _coin.SoVRMLElevationGrid_swiginit(self, _coin.new_SoVRMLElevationGrid())
    ccw = property(_coin.SoVRMLElevationGrid_ccw_get, _coin.SoVRMLElevationGrid_ccw_set, doc=r"""ccw : SoSFBool""")
    solid = property(_coin.SoVRMLElevationGrid_solid_get, _coin.SoVRMLElevationGrid_solid_set, doc=r"""solid : SoSFBool""")
    creaseAngle = property(_coin.SoVRMLElevationGrid_creaseAngle_get, _coin.SoVRMLElevationGrid_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")
    zDimension = property(_coin.SoVRMLElevationGrid_zDimension_get, _coin.SoVRMLElevationGrid_zDimension_set, doc=r"""zDimension : SoSFInt32""")
    xDimension = property(_coin.SoVRMLElevationGrid_xDimension_get, _coin.SoVRMLElevationGrid_xDimension_set, doc=r"""xDimension : SoSFInt32""")
    zSpacing = property(_coin.SoVRMLElevationGrid_zSpacing_get, _coin.SoVRMLElevationGrid_zSpacing_set, doc=r"""zSpacing : SoSFFloat""")
    xSpacing = property(_coin.SoVRMLElevationGrid_xSpacing_get, _coin.SoVRMLElevationGrid_xSpacing_set, doc=r"""xSpacing : SoSFFloat""")
    height = property(_coin.SoVRMLElevationGrid_height_get, _coin.SoVRMLElevationGrid_height_set, doc=r"""height : SoMFFloat""")
    texCoord = property(_coin.SoVRMLElevationGrid_texCoord_get, _coin.SoVRMLElevationGrid_texCoord_set, doc=r"""texCoord : SoSFNode""")
    normal = property(_coin.SoVRMLElevationGrid_normal_get, _coin.SoVRMLElevationGrid_normal_set, doc=r"""normal : SoSFNode""")
    color = property(_coin.SoVRMLElevationGrid_color_get, _coin.SoVRMLElevationGrid_color_set, doc=r"""color : SoSFNode""")
    colorPerVertex = property(_coin.SoVRMLElevationGrid_colorPerVertex_get, _coin.SoVRMLElevationGrid_colorPerVertex_set, doc=r"""colorPerVertex : SoSFBool""")
    normalPerVertex = property(_coin.SoVRMLElevationGrid_normalPerVertex_get, _coin.SoVRMLElevationGrid_normalPerVertex_set, doc=r"""normalPerVertex : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLElevationGrid self, SoGLRenderAction action)"""
        return _coin.SoVRMLElevationGrid_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLElevationGrid self, SoRayPickAction action)"""
        return _coin.SoVRMLElevationGrid_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLElevationGrid self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLElevationGrid_getPrimitiveCount(self, action)

# Register SoVRMLElevationGrid in _coin:
_coin.SoVRMLElevationGrid_swigregister(SoVRMLElevationGrid)

def SoVRMLElevationGrid_getClassTypeId() -> "SoType":
    r"""SoVRMLElevationGrid_getClassTypeId() -> SoType"""
    return _coin.SoVRMLElevationGrid_getClassTypeId()

def SoVRMLElevationGrid_initClass() -> "void":
    r"""SoVRMLElevationGrid_initClass()"""
    return _coin.SoVRMLElevationGrid_initClass()

class SoVRMLExtrusion(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLExtrusion class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLExtrusion_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLExtrusion self) -> SoType"""
        return _coin.SoVRMLExtrusion_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLExtrusion_initClass()

    def __init__(self):
        r"""__init__(SoVRMLExtrusion self) -> SoVRMLExtrusion"""
        _coin.SoVRMLExtrusion_swiginit(self, _coin.new_SoVRMLExtrusion())
    beginCap = property(_coin.SoVRMLExtrusion_beginCap_get, _coin.SoVRMLExtrusion_beginCap_set, doc=r"""beginCap : SoSFBool""")
    ccw = property(_coin.SoVRMLExtrusion_ccw_get, _coin.SoVRMLExtrusion_ccw_set, doc=r"""ccw : SoSFBool""")
    convex = property(_coin.SoVRMLExtrusion_convex_get, _coin.SoVRMLExtrusion_convex_set, doc=r"""convex : SoSFBool""")
    creaseAngle = property(_coin.SoVRMLExtrusion_creaseAngle_get, _coin.SoVRMLExtrusion_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")
    crossSection = property(_coin.SoVRMLExtrusion_crossSection_get, _coin.SoVRMLExtrusion_crossSection_set, doc=r"""crossSection : SoMFVec2f""")
    endCap = property(_coin.SoVRMLExtrusion_endCap_get, _coin.SoVRMLExtrusion_endCap_set, doc=r"""endCap : SoSFBool""")
    orientation = property(_coin.SoVRMLExtrusion_orientation_get, _coin.SoVRMLExtrusion_orientation_set, doc=r"""orientation : SoMFRotation""")
    scale = property(_coin.SoVRMLExtrusion_scale_get, _coin.SoVRMLExtrusion_scale_set, doc=r"""scale : SoMFVec2f""")
    solid = property(_coin.SoVRMLExtrusion_solid_get, _coin.SoVRMLExtrusion_solid_set, doc=r"""solid : SoSFBool""")
    spine = property(_coin.SoVRMLExtrusion_spine_get, _coin.SoVRMLExtrusion_spine_set, doc=r"""spine : SoMFVec3f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLExtrusion self, SoGLRenderAction action)"""
        return _coin.SoVRMLExtrusion_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLExtrusion self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLExtrusion_getPrimitiveCount(self, action)

    def computeBBox(self, action: "SoAction", bbox: "SbBox3f", center: "SbVec3f") -> "void":
        r"""computeBBox(SoVRMLExtrusion self, SoAction action, SbBox3f bbox, SbVec3f center)"""
        return _coin.SoVRMLExtrusion_computeBBox(self, action, bbox, center)

# Register SoVRMLExtrusion in _coin:
_coin.SoVRMLExtrusion_swigregister(SoVRMLExtrusion)

def SoVRMLExtrusion_getClassTypeId() -> "SoType":
    r"""SoVRMLExtrusion_getClassTypeId() -> SoType"""
    return _coin.SoVRMLExtrusion_getClassTypeId()

def SoVRMLExtrusion_initClass() -> "void":
    r"""SoVRMLExtrusion_initClass()"""
    return _coin.SoVRMLExtrusion_initClass()

class SoVRMLFog(SoNode):
    r"""Proxy of C++ SoVRMLFog class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLFog_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLFog self) -> SoType"""
        return _coin.SoVRMLFog_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLFog_initClass()

    def __init__(self):
        r"""__init__(SoVRMLFog self) -> SoVRMLFog"""
        _coin.SoVRMLFog_swiginit(self, _coin.new_SoVRMLFog())
    fogType = property(_coin.SoVRMLFog_fogType_get, _coin.SoVRMLFog_fogType_set, doc=r"""fogType : SoSFString""")
    visibilityRange = property(_coin.SoVRMLFog_visibilityRange_get, _coin.SoVRMLFog_visibilityRange_set, doc=r"""visibilityRange : SoSFFloat""")
    color = property(_coin.SoVRMLFog_color_get, _coin.SoVRMLFog_color_set, doc=r"""color : SoSFColor""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLFog self, SoGLRenderAction action)"""
        return _coin.SoVRMLFog_GLRender(self, action)

# Register SoVRMLFog in _coin:
_coin.SoVRMLFog_swigregister(SoVRMLFog)

def SoVRMLFog_getClassTypeId() -> "SoType":
    r"""SoVRMLFog_getClassTypeId() -> SoType"""
    return _coin.SoVRMLFog_getClassTypeId()

def SoVRMLFog_initClass() -> "void":
    r"""SoVRMLFog_initClass()"""
    return _coin.SoVRMLFog_initClass()

class SoVRMLFontStyle(SoNode):
    r"""Proxy of C++ SoVRMLFontStyle class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLFontStyle_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLFontStyle self) -> SoType"""
        return _coin.SoVRMLFontStyle_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLFontStyle_initClass()

    def __init__(self):
        r"""__init__(SoVRMLFontStyle self) -> SoVRMLFontStyle"""
        _coin.SoVRMLFontStyle_swiginit(self, _coin.new_SoVRMLFontStyle())
    SERIF = _coin.SoVRMLFontStyle_SERIF
    
    SANS = _coin.SoVRMLFontStyle_SANS
    
    TYPEWRITER = _coin.SoVRMLFontStyle_TYPEWRITER
    
    PLAIN = _coin.SoVRMLFontStyle_PLAIN
    
    BOLD = _coin.SoVRMLFontStyle_BOLD
    
    ITALIC = _coin.SoVRMLFontStyle_ITALIC
    
    BOLDITALIC = _coin.SoVRMLFontStyle_BOLDITALIC
    
    size = property(_coin.SoVRMLFontStyle_size_get, _coin.SoVRMLFontStyle_size_set, doc=r"""size : SoSFFloat""")
    family = property(_coin.SoVRMLFontStyle_family_get, _coin.SoVRMLFontStyle_family_set, doc=r"""family : SoMFString""")
    style = property(_coin.SoVRMLFontStyle_style_get, _coin.SoVRMLFontStyle_style_set, doc=r"""style : SoMFString""")
    horizontal = property(_coin.SoVRMLFontStyle_horizontal_get, _coin.SoVRMLFontStyle_horizontal_set, doc=r"""horizontal : SoSFBool""")
    leftToRight = property(_coin.SoVRMLFontStyle_leftToRight_get, _coin.SoVRMLFontStyle_leftToRight_set, doc=r"""leftToRight : SoSFBool""")
    topToBottom = property(_coin.SoVRMLFontStyle_topToBottom_get, _coin.SoVRMLFontStyle_topToBottom_set, doc=r"""topToBottom : SoSFBool""")
    language = property(_coin.SoVRMLFontStyle_language_get, _coin.SoVRMLFontStyle_language_set, doc=r"""language : SoSFString""")
    justify = property(_coin.SoVRMLFontStyle_justify_get, _coin.SoVRMLFontStyle_justify_set, doc=r"""justify : SoMFString""")
    spacing = property(_coin.SoVRMLFontStyle_spacing_get, _coin.SoVRMLFontStyle_spacing_set, doc=r"""spacing : SoSFFloat""")

    def getFontName(self) -> "SbString":
        r"""getFontName(SoVRMLFontStyle self) -> SbString"""
        return _coin.SoVRMLFontStyle_getFontName(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLFontStyle self, SoAction action)"""
        return _coin.SoVRMLFontStyle_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLFontStyle self, SoCallbackAction action)"""
        return _coin.SoVRMLFontStyle_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLFontStyle self, SoGLRenderAction action)"""
        return _coin.SoVRMLFontStyle_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLFontStyle self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLFontStyle_getBoundingBox(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLFontStyle self, SoPickAction action)"""
        return _coin.SoVRMLFontStyle_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLFontStyle self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLFontStyle_getPrimitiveCount(self, action)

# Register SoVRMLFontStyle in _coin:
_coin.SoVRMLFontStyle_swigregister(SoVRMLFontStyle)

def SoVRMLFontStyle_getClassTypeId() -> "SoType":
    r"""SoVRMLFontStyle_getClassTypeId() -> SoType"""
    return _coin.SoVRMLFontStyle_getClassTypeId()

def SoVRMLFontStyle_initClass() -> "void":
    r"""SoVRMLFontStyle_initClass()"""
    return _coin.SoVRMLFontStyle_initClass()


def so_vrml_init() -> "void":
    r"""so_vrml_init()"""
    return _coin.so_vrml_init()
class SoVRMLTexture(SoNode):
    r"""Proxy of C++ SoVRMLTexture class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTexture_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLTexture self) -> SoType"""
        return _coin.SoVRMLTexture_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLTexture_initClass()
    repeatS = property(_coin.SoVRMLTexture_repeatS_get, _coin.SoVRMLTexture_repeatS_set, doc=r"""repeatS : SoSFBool""")
    repeatT = property(_coin.SoVRMLTexture_repeatT_get, _coin.SoVRMLTexture_repeatT_set, doc=r"""repeatT : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLTexture_GLRender(self, action)

# Register SoVRMLTexture in _coin:
_coin.SoVRMLTexture_swigregister(SoVRMLTexture)

def SoVRMLTexture_getClassTypeId() -> "SoType":
    r"""SoVRMLTexture_getClassTypeId() -> SoType"""
    return _coin.SoVRMLTexture_getClassTypeId()

def SoVRMLTexture_initClass() -> "void":
    r"""SoVRMLTexture_initClass()"""
    return _coin.SoVRMLTexture_initClass()

class SoVRMLImageTexture(SoVRMLTexture):
    r"""Proxy of C++ SoVRMLImageTexture class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLImageTexture_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLImageTexture self) -> SoType"""
        return _coin.SoVRMLImageTexture_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLImageTexture_initClass()

    def __init__(self):
        r"""__init__(SoVRMLImageTexture self) -> SoVRMLImageTexture"""
        _coin.SoVRMLImageTexture_swiginit(self, _coin.new_SoVRMLImageTexture())
    url = property(_coin.SoVRMLImageTexture_url_get, _coin.SoVRMLImageTexture_url_set, doc=r"""url : SoMFString""")

    @staticmethod
    def setDelayFetchURL(onoff: "SbBool const") -> "void":
        r"""setDelayFetchURL(SbBool const onoff)"""
        return _coin.SoVRMLImageTexture_setDelayFetchURL(onoff)

    @staticmethod
    def setPrequalifyFileCallBack(cb: "VRMLPrequalifyFileCallback *", closure: "void *") -> "void":
        r"""setPrequalifyFileCallBack(VRMLPrequalifyFileCallback * cb, void * closure)"""
        return _coin.SoVRMLImageTexture_setPrequalifyFileCallBack(cb, closure)

    def allowPrequalifyFile(self, enable: "SbBool") -> "void":
        r"""allowPrequalifyFile(SoVRMLImageTexture self, SbBool enable)"""
        return _coin.SoVRMLImageTexture_allowPrequalifyFile(self, enable)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLImageTexture self, SoAction action)"""
        return _coin.SoVRMLImageTexture_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLImageTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLImageTexture_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLImageTexture self, SoCallbackAction action)"""
        return _coin.SoVRMLImageTexture_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLImageTexture self, SoRayPickAction action)"""
        return _coin.SoVRMLImageTexture_rayPick(self, action)

    def setImage(self, image: "SbImage") -> "void":
        r"""setImage(SoVRMLImageTexture self, SbImage image)"""
        return _coin.SoVRMLImageTexture_setImage(self, image)

    def getImage(self) -> "SbImage const *":
        r"""getImage(SoVRMLImageTexture self) -> SbImage"""
        return _coin.SoVRMLImageTexture_getImage(self)

    @staticmethod
    def setImageDataMaxAge(maxage: "uint32_t const") -> "void":
        r"""setImageDataMaxAge(uint32_t const maxage)"""
        return _coin.SoVRMLImageTexture_setImageDataMaxAge(maxage)

# Register SoVRMLImageTexture in _coin:
_coin.SoVRMLImageTexture_swigregister(SoVRMLImageTexture)

def SoVRMLImageTexture_getClassTypeId() -> "SoType":
    r"""SoVRMLImageTexture_getClassTypeId() -> SoType"""
    return _coin.SoVRMLImageTexture_getClassTypeId()

def SoVRMLImageTexture_initClass() -> "void":
    r"""SoVRMLImageTexture_initClass()"""
    return _coin.SoVRMLImageTexture_initClass()

def SoVRMLImageTexture_setDelayFetchURL(onoff: "SbBool const") -> "void":
    r"""SoVRMLImageTexture_setDelayFetchURL(SbBool const onoff)"""
    return _coin.SoVRMLImageTexture_setDelayFetchURL(onoff)

def SoVRMLImageTexture_setPrequalifyFileCallBack(cb: "VRMLPrequalifyFileCallback *", closure: "void *") -> "void":
    r"""SoVRMLImageTexture_setPrequalifyFileCallBack(VRMLPrequalifyFileCallback * cb, void * closure)"""
    return _coin.SoVRMLImageTexture_setPrequalifyFileCallBack(cb, closure)

def SoVRMLImageTexture_setImageDataMaxAge(maxage: "uint32_t const") -> "void":
    r"""SoVRMLImageTexture_setImageDataMaxAge(uint32_t const maxage)"""
    return _coin.SoVRMLImageTexture_setImageDataMaxAge(maxage)

class SoVRMLVertexShape(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLVertexShape class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexShape_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLVertexShape self) -> SoType"""
        return _coin.SoVRMLVertexShape_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLVertexShape_initClass()
    coord = property(_coin.SoVRMLVertexShape_coord_get, _coin.SoVRMLVertexShape_coord_set, doc=r"""coord : SoSFNode""")
    texCoord = property(_coin.SoVRMLVertexShape_texCoord_get, _coin.SoVRMLVertexShape_texCoord_set, doc=r"""texCoord : SoSFNode""")
    normal = property(_coin.SoVRMLVertexShape_normal_get, _coin.SoVRMLVertexShape_normal_set, doc=r"""normal : SoSFNode""")
    color = property(_coin.SoVRMLVertexShape_color_get, _coin.SoVRMLVertexShape_color_set, doc=r"""color : SoSFNode""")
    colorPerVertex = property(_coin.SoVRMLVertexShape_colorPerVertex_get, _coin.SoVRMLVertexShape_colorPerVertex_set, doc=r"""colorPerVertex : SoSFBool""")
    normalPerVertex = property(_coin.SoVRMLVertexShape_normalPerVertex_get, _coin.SoVRMLVertexShape_normalPerVertex_set, doc=r"""normalPerVertex : SoSFBool""")
    OVERALL = _coin.SoVRMLVertexShape_OVERALL
    
    PER_PART = _coin.SoVRMLVertexShape_PER_PART
    
    PER_PART_INDEXED = _coin.SoVRMLVertexShape_PER_PART_INDEXED
    
    PER_FACE = _coin.SoVRMLVertexShape_PER_FACE
    
    PER_FACE_INDEXED = _coin.SoVRMLVertexShape_PER_FACE_INDEXED
    
    PER_VERTEX = _coin.SoVRMLVertexShape_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoVRMLVertexShape_PER_VERTEX_INDEXED
    

    def generateDefaultNormals(self, *args) -> "SbBool":
        r"""
        generateDefaultNormals(SoVRMLVertexShape self, SoState s, SoNormalBundle nb) -> SbBool
        generateDefaultNormals(SoVRMLVertexShape self, SoState s, SoNormalCache nc) -> SbBool
        """
        return _coin.SoVRMLVertexShape_generateDefaultNormals(self, *args)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLVertexShape self, SoAction action)"""
        return _coin.SoVRMLVertexShape_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLVertexShape self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexShape_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLVertexShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexShape_getBoundingBox(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLVertexShape self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexShape_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLVertexShape self, SoPickAction action)"""
        return _coin.SoVRMLVertexShape_pick(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLVertexShape self, SoNotList list)"""
        return _coin.SoVRMLVertexShape_notify(self, list)

# Register SoVRMLVertexShape in _coin:
_coin.SoVRMLVertexShape_swigregister(SoVRMLVertexShape)

def SoVRMLVertexShape_getClassTypeId() -> "SoType":
    r"""SoVRMLVertexShape_getClassTypeId() -> SoType"""
    return _coin.SoVRMLVertexShape_getClassTypeId()

def SoVRMLVertexShape_initClass() -> "void":
    r"""SoVRMLVertexShape_initClass()"""
    return _coin.SoVRMLVertexShape_initClass()

class SoVRMLIndexedShape(SoVRMLVertexShape):
    r"""Proxy of C++ SoVRMLIndexedShape class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedShape_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLIndexedShape self) -> SoType"""
        return _coin.SoVRMLIndexedShape_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLIndexedShape_initClass()
    coordIndex = property(_coin.SoVRMLIndexedShape_coordIndex_get, _coin.SoVRMLIndexedShape_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    colorIndex = property(_coin.SoVRMLIndexedShape_colorIndex_get, _coin.SoVRMLIndexedShape_colorIndex_set, doc=r"""colorIndex : SoMFInt32""")
    normalIndex = property(_coin.SoVRMLIndexedShape_normalIndex_get, _coin.SoVRMLIndexedShape_normalIndex_set, doc=r"""normalIndex : SoMFInt32""")
    texCoordIndex = property(_coin.SoVRMLIndexedShape_texCoordIndex_get, _coin.SoVRMLIndexedShape_texCoordIndex_set, doc=r"""texCoordIndex : SoMFInt32""")

# Register SoVRMLIndexedShape in _coin:
_coin.SoVRMLIndexedShape_swigregister(SoVRMLIndexedShape)

def SoVRMLIndexedShape_getClassTypeId() -> "SoType":
    r"""SoVRMLIndexedShape_getClassTypeId() -> SoType"""
    return _coin.SoVRMLIndexedShape_getClassTypeId()

def SoVRMLIndexedShape_initClass() -> "void":
    r"""SoVRMLIndexedShape_initClass()"""
    return _coin.SoVRMLIndexedShape_initClass()

class SoVRMLIndexedFaceSet(SoVRMLIndexedShape):
    r"""Proxy of C++ SoVRMLIndexedFaceSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedFaceSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLIndexedFaceSet self) -> SoType"""
        return _coin.SoVRMLIndexedFaceSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLIndexedFaceSet_initClass()

    def __init__(self):
        r"""__init__(SoVRMLIndexedFaceSet self) -> SoVRMLIndexedFaceSet"""
        _coin.SoVRMLIndexedFaceSet_swiginit(self, _coin.new_SoVRMLIndexedFaceSet())
    ccw = property(_coin.SoVRMLIndexedFaceSet_ccw_get, _coin.SoVRMLIndexedFaceSet_ccw_set, doc=r"""ccw : SoSFBool""")
    solid = property(_coin.SoVRMLIndexedFaceSet_solid_get, _coin.SoVRMLIndexedFaceSet_solid_set, doc=r"""solid : SoSFBool""")
    convex = property(_coin.SoVRMLIndexedFaceSet_convex_get, _coin.SoVRMLIndexedFaceSet_convex_set, doc=r"""convex : SoSFBool""")
    creaseAngle = property(_coin.SoVRMLIndexedFaceSet_creaseAngle_get, _coin.SoVRMLIndexedFaceSet_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLIndexedFaceSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedFaceSet_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLIndexedFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedFaceSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, *args) -> "SbBool":
        r"""
        generateDefaultNormals(SoVRMLIndexedFaceSet self, SoState s, SoNormalBundle nb) -> SbBool
        generateDefaultNormals(SoVRMLIndexedFaceSet self, SoState state, SoNormalCache nc) -> SbBool
        """
        return _coin.SoVRMLIndexedFaceSet_generateDefaultNormals(self, *args)

# Register SoVRMLIndexedFaceSet in _coin:
_coin.SoVRMLIndexedFaceSet_swigregister(SoVRMLIndexedFaceSet)

def SoVRMLIndexedFaceSet_getClassTypeId() -> "SoType":
    r"""SoVRMLIndexedFaceSet_getClassTypeId() -> SoType"""
    return _coin.SoVRMLIndexedFaceSet_getClassTypeId()

def SoVRMLIndexedFaceSet_initClass() -> "void":
    r"""SoVRMLIndexedFaceSet_initClass()"""
    return _coin.SoVRMLIndexedFaceSet_initClass()

class SoVRMLVertexLine(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLVertexLine class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexLine_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLVertexLine self) -> SoType"""
        return _coin.SoVRMLVertexLine_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLVertexLine_initClass()
    coord = property(_coin.SoVRMLVertexLine_coord_get, _coin.SoVRMLVertexLine_coord_set, doc=r"""coord : SoSFNode""")
    color = property(_coin.SoVRMLVertexLine_color_get, _coin.SoVRMLVertexLine_color_set, doc=r"""color : SoSFNode""")
    colorPerVertex = property(_coin.SoVRMLVertexLine_colorPerVertex_get, _coin.SoVRMLVertexLine_colorPerVertex_set, doc=r"""colorPerVertex : SoSFBool""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLVertexLine self, SoAction action)"""
        return _coin.SoVRMLVertexLine_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLVertexLine self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexLine_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLVertexLine self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexLine_getBoundingBox(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLVertexLine self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexLine_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLVertexLine self, SoPickAction action)"""
        return _coin.SoVRMLVertexLine_pick(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLVertexLine self, SoNotList list)"""
        return _coin.SoVRMLVertexLine_notify(self, list)

# Register SoVRMLVertexLine in _coin:
_coin.SoVRMLVertexLine_swigregister(SoVRMLVertexLine)

def SoVRMLVertexLine_getClassTypeId() -> "SoType":
    r"""SoVRMLVertexLine_getClassTypeId() -> SoType"""
    return _coin.SoVRMLVertexLine_getClassTypeId()

def SoVRMLVertexLine_initClass() -> "void":
    r"""SoVRMLVertexLine_initClass()"""
    return _coin.SoVRMLVertexLine_initClass()

class SoVRMLIndexedLine(SoVRMLVertexLine):
    r"""Proxy of C++ SoVRMLIndexedLine class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedLine_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLIndexedLine self) -> SoType"""
        return _coin.SoVRMLIndexedLine_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLIndexedLine_initClass()
    coordIndex = property(_coin.SoVRMLIndexedLine_coordIndex_get, _coin.SoVRMLIndexedLine_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    colorIndex = property(_coin.SoVRMLIndexedLine_colorIndex_get, _coin.SoVRMLIndexedLine_colorIndex_set, doc=r"""colorIndex : SoMFInt32""")

# Register SoVRMLIndexedLine in _coin:
_coin.SoVRMLIndexedLine_swigregister(SoVRMLIndexedLine)

def SoVRMLIndexedLine_getClassTypeId() -> "SoType":
    r"""SoVRMLIndexedLine_getClassTypeId() -> SoType"""
    return _coin.SoVRMLIndexedLine_getClassTypeId()

def SoVRMLIndexedLine_initClass() -> "void":
    r"""SoVRMLIndexedLine_initClass()"""
    return _coin.SoVRMLIndexedLine_initClass()

class SoVRMLIndexedLineSet(SoVRMLIndexedLine):
    r"""Proxy of C++ SoVRMLIndexedLineSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedLineSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLIndexedLineSet self) -> SoType"""
        return _coin.SoVRMLIndexedLineSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLIndexedLineSet_initClass()

    def __init__(self):
        r"""__init__(SoVRMLIndexedLineSet self) -> SoVRMLIndexedLineSet"""
        _coin.SoVRMLIndexedLineSet_swiginit(self, _coin.new_SoVRMLIndexedLineSet())

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLIndexedLineSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedLineSet_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLIndexedLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedLineSet_getPrimitiveCount(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLIndexedLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLIndexedLineSet_getBoundingBox(self, action)

# Register SoVRMLIndexedLineSet in _coin:
_coin.SoVRMLIndexedLineSet_swigregister(SoVRMLIndexedLineSet)

def SoVRMLIndexedLineSet_getClassTypeId() -> "SoType":
    r"""SoVRMLIndexedLineSet_getClassTypeId() -> SoType"""
    return _coin.SoVRMLIndexedLineSet_getClassTypeId()

def SoVRMLIndexedLineSet_initClass() -> "void":
    r"""SoVRMLIndexedLineSet_initClass()"""
    return _coin.SoVRMLIndexedLineSet_initClass()

class SoVRMLInline(SoNode):
    r"""Proxy of C++ SoVRMLInline class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLInline_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLInline self) -> SoType"""
        return _coin.SoVRMLInline_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLInline_initClass()

    def __init__(self):
        r"""__init__(SoVRMLInline self) -> SoVRMLInline"""
        _coin.SoVRMLInline_swiginit(self, _coin.new_SoVRMLInline())
    NEVER = _coin.SoVRMLInline_NEVER
    
    UNTIL_LOADED = _coin.SoVRMLInline_UNTIL_LOADED
    
    ALWAYS = _coin.SoVRMLInline_ALWAYS
    
    bboxCenter = property(_coin.SoVRMLInline_bboxCenter_get, _coin.SoVRMLInline_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLInline_bboxSize_get, _coin.SoVRMLInline_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")
    url = property(_coin.SoVRMLInline_url_get, _coin.SoVRMLInline_url_set, doc=r"""url : SoMFString""")

    def setFullURLName(self, url: "SbString") -> "void":
        r"""setFullURLName(SoVRMLInline self, SbString url)"""
        return _coin.SoVRMLInline_setFullURLName(self, url)

    def getFullURLName(self) -> "SbString const &":
        r"""getFullURLName(SoVRMLInline self) -> SbString"""
        return _coin.SoVRMLInline_getFullURLName(self)

    def copyChildren(self) -> "SoGroup *":
        r"""copyChildren(SoVRMLInline self) -> SoGroup"""
        return _coin.SoVRMLInline_copyChildren(self)

    def requestURLData(self) -> "void":
        r"""requestURLData(SoVRMLInline self)"""
        return _coin.SoVRMLInline_requestURLData(self)

    def isURLDataRequested(self) -> "SbBool":
        r"""isURLDataRequested(SoVRMLInline self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataRequested(self)

    def isURLDataHere(self) -> "SbBool":
        r"""isURLDataHere(SoVRMLInline self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataHere(self)

    def cancelURLDataRequest(self) -> "void":
        r"""cancelURLDataRequest(SoVRMLInline self)"""
        return _coin.SoVRMLInline_cancelURLDataRequest(self)

    def setChildData(self, urlData: "SoNode") -> "void":
        r"""setChildData(SoVRMLInline self, SoNode urlData)"""
        return _coin.SoVRMLInline_setChildData(self, urlData)

    def getChildData(self) -> "SoNode *":
        r"""getChildData(SoVRMLInline self) -> SoNode"""
        return _coin.SoVRMLInline_getChildData(self)

    @staticmethod
    def setFetchURLCallBack(f: "SoVRMLInlineFetchURLCB *", closure: "void *") -> "void":
        r"""setFetchURLCallBack(SoVRMLInlineFetchURLCB * f, void * closure)"""
        return _coin.SoVRMLInline_setFetchURLCallBack(f, closure)

    @staticmethod
    def setBoundingBoxVisibility(b: "SoVRMLInline::BboxVisibility") -> "void":
        r"""setBoundingBoxVisibility(SoVRMLInline::BboxVisibility b)"""
        return _coin.SoVRMLInline_setBoundingBoxVisibility(b)

    @staticmethod
    def getBoundingBoxVisibility() -> "SoVRMLInline::BboxVisibility":
        r"""getBoundingBoxVisibility() -> SoVRMLInline::BboxVisibility"""
        return _coin.SoVRMLInline_getBoundingBoxVisibility()

    @staticmethod
    def setBoundingBoxColor(color: "SbColor") -> "void":
        r"""setBoundingBoxColor(SbColor color)"""
        return _coin.SoVRMLInline_setBoundingBoxColor(color)

    @staticmethod
    def getBoundingBoxColor() -> "SbColor &":
        r"""getBoundingBoxColor() -> SbColor"""
        return _coin.SoVRMLInline_getBoundingBoxColor()

    @staticmethod
    def setReadAsSoFile(enable: "SbBool") -> "void":
        r"""setReadAsSoFile(SbBool enable)"""
        return _coin.SoVRMLInline_setReadAsSoFile(enable)

    @staticmethod
    def getReadAsSoFile() -> "SbBool":
        r"""getReadAsSoFile() -> SbBool"""
        return _coin.SoVRMLInline_getReadAsSoFile()

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLInline self, SoAction action)"""
        return _coin.SoVRMLInline_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLInline self, SoCallbackAction action)"""
        return _coin.SoVRMLInline_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLInline self, SoGLRenderAction action)"""
        return _coin.SoVRMLInline_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLInline self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLInline_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoVRMLInline self, SoGetMatrixAction action)"""
        return _coin.SoVRMLInline_getMatrix(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoVRMLInline self, SoHandleEventAction action)"""
        return _coin.SoVRMLInline_handleEvent(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLInline self, SoSearchAction action)"""
        return _coin.SoVRMLInline_search(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLInline self, SoPickAction action)"""
        return _coin.SoVRMLInline_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLInline self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLInline_getPrimitiveCount(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoVRMLInline self) -> SoChildList"""
        return _coin.SoVRMLInline_getChildren(self)

# Register SoVRMLInline in _coin:
_coin.SoVRMLInline_swigregister(SoVRMLInline)

def SoVRMLInline_getClassTypeId() -> "SoType":
    r"""SoVRMLInline_getClassTypeId() -> SoType"""
    return _coin.SoVRMLInline_getClassTypeId()

def SoVRMLInline_initClass() -> "void":
    r"""SoVRMLInline_initClass()"""
    return _coin.SoVRMLInline_initClass()

def SoVRMLInline_setFetchURLCallBack(f: "SoVRMLInlineFetchURLCB *", closure: "void *") -> "void":
    r"""SoVRMLInline_setFetchURLCallBack(SoVRMLInlineFetchURLCB * f, void * closure)"""
    return _coin.SoVRMLInline_setFetchURLCallBack(f, closure)

def SoVRMLInline_setBoundingBoxVisibility(b: "SoVRMLInline::BboxVisibility") -> "void":
    r"""SoVRMLInline_setBoundingBoxVisibility(SoVRMLInline::BboxVisibility b)"""
    return _coin.SoVRMLInline_setBoundingBoxVisibility(b)

def SoVRMLInline_getBoundingBoxVisibility() -> "SoVRMLInline::BboxVisibility":
    r"""SoVRMLInline_getBoundingBoxVisibility() -> SoVRMLInline::BboxVisibility"""
    return _coin.SoVRMLInline_getBoundingBoxVisibility()

def SoVRMLInline_setBoundingBoxColor(color: "SbColor") -> "void":
    r"""SoVRMLInline_setBoundingBoxColor(SbColor color)"""
    return _coin.SoVRMLInline_setBoundingBoxColor(color)

def SoVRMLInline_getBoundingBoxColor() -> "SbColor &":
    r"""SoVRMLInline_getBoundingBoxColor() -> SbColor"""
    return _coin.SoVRMLInline_getBoundingBoxColor()

def SoVRMLInline_setReadAsSoFile(enable: "SbBool") -> "void":
    r"""SoVRMLInline_setReadAsSoFile(SbBool enable)"""
    return _coin.SoVRMLInline_setReadAsSoFile(enable)

def SoVRMLInline_getReadAsSoFile() -> "SbBool":
    r"""SoVRMLInline_getReadAsSoFile() -> SbBool"""
    return _coin.SoVRMLInline_getReadAsSoFile()

class SoVRMLLOD(SoGroup):
    r"""Proxy of C++ SoVRMLLOD class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLLOD_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLLOD self) -> SoType"""
        return _coin.SoVRMLLOD_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLLOD_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLLOD self) -> SoVRMLLOD
        __init__(SoVRMLLOD self, int levels) -> SoVRMLLOD
        """
        _coin.SoVRMLLOD_swiginit(self, _coin.new_SoVRMLLOD(*args))
    range = property(_coin.SoVRMLLOD_range_get, _coin.SoVRMLLOD_range_set, doc=r"""range : SoMFFloat""")
    center = property(_coin.SoVRMLLOD_center_get, _coin.SoVRMLLOD_center_set, doc=r"""center : SoSFVec3f""")
    level = property(_coin.SoVRMLLOD_level_get, _coin.SoVRMLLOD_level_set, doc=r"""level : SoMFNode""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoVRMLLOD self) -> SbBool"""
        return _coin.SoVRMLLOD_affectsState(self)

    def addLevel(self, level: "SoNode") -> "void":
        r"""addLevel(SoVRMLLOD self, SoNode level)"""
        return _coin.SoVRMLLOD_addLevel(self, level)

    def insertLevel(self, level: "SoNode", idx: "int") -> "void":
        r"""insertLevel(SoVRMLLOD self, SoNode level, int idx)"""
        return _coin.SoVRMLLOD_insertLevel(self, level, idx)

    def getLevel(self, idx: "int") -> "SoNode *":
        r"""getLevel(SoVRMLLOD self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getLevel(self, idx)

    def findLevel(self, level: "SoNode") -> "int":
        r"""findLevel(SoVRMLLOD self, SoNode level) -> int"""
        return _coin.SoVRMLLOD_findLevel(self, level)

    def getNumLevels(self) -> "int":
        r"""getNumLevels(SoVRMLLOD self) -> int"""
        return _coin.SoVRMLLOD_getNumLevels(self)

    def removeLevel(self, *args) -> "void":
        r"""
        removeLevel(SoVRMLLOD self, int idx)
        removeLevel(SoVRMLLOD self, SoNode level)
        """
        return _coin.SoVRMLLOD_removeLevel(self, *args)

    def removeAllLevels(self) -> "void":
        r"""removeAllLevels(SoVRMLLOD self)"""
        return _coin.SoVRMLLOD_removeAllLevels(self)

    def replaceLevel(self, *args) -> "void":
        r"""
        replaceLevel(SoVRMLLOD self, int idx, SoNode level)
        replaceLevel(SoVRMLLOD self, SoNode old, SoNode level)
        """
        return _coin.SoVRMLLOD_replaceLevel(self, *args)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLLOD self, SoAction action)"""
        return _coin.SoVRMLLOD_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLLOD self, SoCallbackAction action)"""
        return _coin.SoVRMLLOD_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLLOD self, SoRayPickAction action)"""
        return _coin.SoVRMLLOD_rayPick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLLOD self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLLOD_getBoundingBox(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLLOD self, SoSearchAction action)"""
        return _coin.SoVRMLLOD_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVRMLLOD self, SoWriteAction action)"""
        return _coin.SoVRMLLOD_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLLOD self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLLOD_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoVRMLLOD self, SoAudioRenderAction action)"""
        return _coin.SoVRMLLOD_audioRender(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderOffPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderOffPath(self, action)

    def addChild(self, child: "SoNode") -> "void":
        r"""addChild(SoVRMLLOD self, SoNode child)"""
        return _coin.SoVRMLLOD_addChild(self, child)

    def insertChild(self, child: "SoNode", idx: "int") -> "void":
        r"""insertChild(SoVRMLLOD self, SoNode child, int idx)"""
        return _coin.SoVRMLLOD_insertChild(self, child, idx)

    def getChild(self, idx: "int") -> "SoNode *":
        r"""getChild(SoVRMLLOD self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getChild(self, idx)

    def findChild(self, child: "SoNode") -> "int":
        r"""findChild(SoVRMLLOD self, SoNode child) -> int"""
        return _coin.SoVRMLLOD_findChild(self, child)

    def getNumChildren(self) -> "int":
        r"""getNumChildren(SoVRMLLOD self) -> int"""
        return _coin.SoVRMLLOD_getNumChildren(self)

    def removeChild(self, *args) -> "void":
        r"""
        removeChild(SoVRMLLOD self, int idx)
        removeChild(SoVRMLLOD self, SoNode child)
        """
        return _coin.SoVRMLLOD_removeChild(self, *args)

    def removeAllChildren(self) -> "void":
        r"""removeAllChildren(SoVRMLLOD self)"""
        return _coin.SoVRMLLOD_removeAllChildren(self)

    def replaceChild(self, *args) -> "void":
        r"""
        replaceChild(SoVRMLLOD self, int idx, SoNode child)
        replaceChild(SoVRMLLOD self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLLOD_replaceChild(self, *args)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoVRMLLOD self) -> SoChildList"""
        return _coin.SoVRMLLOD_getChildren(self)

# Register SoVRMLLOD in _coin:
_coin.SoVRMLLOD_swigregister(SoVRMLLOD)

def SoVRMLLOD_getClassTypeId() -> "SoType":
    r"""SoVRMLLOD_getClassTypeId() -> SoType"""
    return _coin.SoVRMLLOD_getClassTypeId()

def SoVRMLLOD_initClass() -> "void":
    r"""SoVRMLLOD_initClass()"""
    return _coin.SoVRMLLOD_initClass()

class SoVRMLMaterial(SoNode):
    r"""Proxy of C++ SoVRMLMaterial class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLMaterial_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLMaterial self) -> SoType"""
        return _coin.SoVRMLMaterial_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLMaterial_initClass()

    def __init__(self):
        r"""__init__(SoVRMLMaterial self) -> SoVRMLMaterial"""
        _coin.SoVRMLMaterial_swiginit(self, _coin.new_SoVRMLMaterial())
    diffuseColor = property(_coin.SoVRMLMaterial_diffuseColor_get, _coin.SoVRMLMaterial_diffuseColor_set, doc=r"""diffuseColor : SoSFColor""")
    ambientIntensity = property(_coin.SoVRMLMaterial_ambientIntensity_get, _coin.SoVRMLMaterial_ambientIntensity_set, doc=r"""ambientIntensity : SoSFFloat""")
    specularColor = property(_coin.SoVRMLMaterial_specularColor_get, _coin.SoVRMLMaterial_specularColor_set, doc=r"""specularColor : SoSFColor""")
    emissiveColor = property(_coin.SoVRMLMaterial_emissiveColor_get, _coin.SoVRMLMaterial_emissiveColor_set, doc=r"""emissiveColor : SoSFColor""")
    shininess = property(_coin.SoVRMLMaterial_shininess_get, _coin.SoVRMLMaterial_shininess_set, doc=r"""shininess : SoSFFloat""")
    transparency = property(_coin.SoVRMLMaterial_transparency_get, _coin.SoVRMLMaterial_transparency_set, doc=r"""transparency : SoSFFloat""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLMaterial self, SoAction action)"""
        return _coin.SoVRMLMaterial_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLMaterial self, SoGLRenderAction action)"""
        return _coin.SoVRMLMaterial_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLMaterial self, SoCallbackAction action)"""
        return _coin.SoVRMLMaterial_callback(self, action)

# Register SoVRMLMaterial in _coin:
_coin.SoVRMLMaterial_swigregister(SoVRMLMaterial)

def SoVRMLMaterial_getClassTypeId() -> "SoType":
    r"""SoVRMLMaterial_getClassTypeId() -> SoType"""
    return _coin.SoVRMLMaterial_getClassTypeId()

def SoVRMLMaterial_initClass() -> "void":
    r"""SoVRMLMaterial_initClass()"""
    return _coin.SoVRMLMaterial_initClass()

class SoVRMLMovieTexture(SoVRMLTexture):
    r"""Proxy of C++ SoVRMLMovieTexture class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLMovieTexture_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLMovieTexture self) -> SoType"""
        return _coin.SoVRMLMovieTexture_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLMovieTexture_initClass()

    def __init__(self):
        r"""__init__(SoVRMLMovieTexture self) -> SoVRMLMovieTexture"""
        _coin.SoVRMLMovieTexture_swiginit(self, _coin.new_SoVRMLMovieTexture())
    loop = property(_coin.SoVRMLMovieTexture_loop_get, _coin.SoVRMLMovieTexture_loop_set, doc=r"""loop : SoSFBool""")
    speed = property(_coin.SoVRMLMovieTexture_speed_get, _coin.SoVRMLMovieTexture_speed_set, doc=r"""speed : SoSFFloat""")
    startTime = property(_coin.SoVRMLMovieTexture_startTime_get, _coin.SoVRMLMovieTexture_startTime_set, doc=r"""startTime : SoSFTime""")
    stopTime = property(_coin.SoVRMLMovieTexture_stopTime_get, _coin.SoVRMLMovieTexture_stopTime_set, doc=r"""stopTime : SoSFTime""")
    pauseTime = property(_coin.SoVRMLMovieTexture_pauseTime_get, _coin.SoVRMLMovieTexture_pauseTime_set, doc=r"""pauseTime : SoSFTime""")
    resumeTime = property(_coin.SoVRMLMovieTexture_resumeTime_get, _coin.SoVRMLMovieTexture_resumeTime_set, doc=r"""resumeTime : SoSFTime""")
    url = property(_coin.SoVRMLMovieTexture_url_get, _coin.SoVRMLMovieTexture_url_set, doc=r"""url : SoMFString""")
    duration_changed = property(_coin.SoVRMLMovieTexture_duration_changed_get, _coin.SoVRMLMovieTexture_duration_changed_set, doc=r"""duration_changed : SoSFTime""")
    isActive = property(_coin.SoVRMLMovieTexture_isActive_get, _coin.SoVRMLMovieTexture_isActive_set, doc=r"""isActive : SoSFBool""")
    alpha = property(_coin.SoVRMLMovieTexture_alpha_get, _coin.SoVRMLMovieTexture_alpha_set, doc=r"""alpha : SoSFFloat""")
    model = property(_coin.SoVRMLMovieTexture_model_get, _coin.SoVRMLMovieTexture_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoVRMLMovieTexture_blendColor_get, _coin.SoVRMLMovieTexture_blendColor_set, doc=r"""blendColor : SoSFColor""")
    scaleTexCoord = property(_coin.SoVRMLMovieTexture_scaleTexCoord_get, _coin.SoVRMLMovieTexture_scaleTexCoord_set, doc=r"""scaleTexCoord : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLMovieTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLMovieTexture_GLRender(self, action)

# Register SoVRMLMovieTexture in _coin:
_coin.SoVRMLMovieTexture_swigregister(SoVRMLMovieTexture)

def SoVRMLMovieTexture_getClassTypeId() -> "SoType":
    r"""SoVRMLMovieTexture_getClassTypeId() -> SoType"""
    return _coin.SoVRMLMovieTexture_getClassTypeId()

def SoVRMLMovieTexture_initClass() -> "void":
    r"""SoVRMLMovieTexture_initClass()"""
    return _coin.SoVRMLMovieTexture_initClass()

class SoVRMLNavigationInfo(SoNode):
    r"""Proxy of C++ SoVRMLNavigationInfo class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLNavigationInfo_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLNavigationInfo self) -> SoType"""
        return _coin.SoVRMLNavigationInfo_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLNavigationInfo_initClass()

    def __init__(self):
        r"""__init__(SoVRMLNavigationInfo self) -> SoVRMLNavigationInfo"""
        _coin.SoVRMLNavigationInfo_swiginit(self, _coin.new_SoVRMLNavigationInfo())
    type = property(_coin.SoVRMLNavigationInfo_type_get, _coin.SoVRMLNavigationInfo_type_set, doc=r"""type : SoMFString""")
    speed = property(_coin.SoVRMLNavigationInfo_speed_get, _coin.SoVRMLNavigationInfo_speed_set, doc=r"""speed : SoSFFloat""")
    avatarSize = property(_coin.SoVRMLNavigationInfo_avatarSize_get, _coin.SoVRMLNavigationInfo_avatarSize_set, doc=r"""avatarSize : SoMFFloat""")
    visibilityLimit = property(_coin.SoVRMLNavigationInfo_visibilityLimit_get, _coin.SoVRMLNavigationInfo_visibilityLimit_set, doc=r"""visibilityLimit : SoSFFloat""")
    headlight = property(_coin.SoVRMLNavigationInfo_headlight_get, _coin.SoVRMLNavigationInfo_headlight_set, doc=r"""headlight : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLNavigationInfo self, SoGLRenderAction action)"""
        return _coin.SoVRMLNavigationInfo_GLRender(self, action)

# Register SoVRMLNavigationInfo in _coin:
_coin.SoVRMLNavigationInfo_swigregister(SoVRMLNavigationInfo)

def SoVRMLNavigationInfo_getClassTypeId() -> "SoType":
    r"""SoVRMLNavigationInfo_getClassTypeId() -> SoType"""
    return _coin.SoVRMLNavigationInfo_getClassTypeId()

def SoVRMLNavigationInfo_initClass() -> "void":
    r"""SoVRMLNavigationInfo_initClass()"""
    return _coin.SoVRMLNavigationInfo_initClass()

class SoVRMLNormal(SoNode):
    r"""Proxy of C++ SoVRMLNormal class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLNormal_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLNormal self) -> SoType"""
        return _coin.SoVRMLNormal_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLNormal_initClass()

    def __init__(self):
        r"""__init__(SoVRMLNormal self) -> SoVRMLNormal"""
        _coin.SoVRMLNormal_swiginit(self, _coin.new_SoVRMLNormal())
    vector = property(_coin.SoVRMLNormal_vector_get, _coin.SoVRMLNormal_vector_set, doc=r"""vector : SoMFVec3f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLNormal self, SoAction action)"""
        return _coin.SoVRMLNormal_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLNormal self, SoGLRenderAction action)"""
        return _coin.SoVRMLNormal_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLNormal self, SoCallbackAction action)"""
        return _coin.SoVRMLNormal_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLNormal self, SoPickAction action)"""
        return _coin.SoVRMLNormal_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLNormal self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLNormal_getPrimitiveCount(self, action)

# Register SoVRMLNormal in _coin:
_coin.SoVRMLNormal_swigregister(SoVRMLNormal)

def SoVRMLNormal_getClassTypeId() -> "SoType":
    r"""SoVRMLNormal_getClassTypeId() -> SoType"""
    return _coin.SoVRMLNormal_getClassTypeId()

def SoVRMLNormal_initClass() -> "void":
    r"""SoVRMLNormal_initClass()"""
    return _coin.SoVRMLNormal_initClass()

class SoVRMLNormalInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLNormalInterpolator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLNormalInterpolator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLNormalInterpolator self) -> SoType"""
        return _coin.SoVRMLNormalInterpolator_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLNormalInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLNormalInterpolator_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVRMLNormalInterpolator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLNormalInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLNormalInterpolator self) -> SoVRMLNormalInterpolator"""
        _coin.SoVRMLNormalInterpolator_swiginit(self, _coin.new_SoVRMLNormalInterpolator())
    keyValue = property(_coin.SoVRMLNormalInterpolator_keyValue_get, _coin.SoVRMLNormalInterpolator_keyValue_set, doc=r"""keyValue : SoMFVec3f""")
    value_changed = property(_coin.SoVRMLNormalInterpolator_value_changed_get, _coin.SoVRMLNormalInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLNormalInterpolator in _coin:
_coin.SoVRMLNormalInterpolator_swigregister(SoVRMLNormalInterpolator)

def SoVRMLNormalInterpolator_getClassTypeId() -> "SoType":
    r"""SoVRMLNormalInterpolator_getClassTypeId() -> SoType"""
    return _coin.SoVRMLNormalInterpolator_getClassTypeId()

def SoVRMLNormalInterpolator_createInstance() -> "void *":
    r"""SoVRMLNormalInterpolator_createInstance() -> void *"""
    return _coin.SoVRMLNormalInterpolator_createInstance()

def SoVRMLNormalInterpolator_initClass() -> "void":
    r"""SoVRMLNormalInterpolator_initClass()"""
    return _coin.SoVRMLNormalInterpolator_initClass()

class SoVRMLOrientationInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLOrientationInterpolator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLOrientationInterpolator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLOrientationInterpolator self) -> SoType"""
        return _coin.SoVRMLOrientationInterpolator_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLOrientationInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLOrientationInterpolator_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVRMLOrientationInterpolator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLOrientationInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLOrientationInterpolator self) -> SoVRMLOrientationInterpolator"""
        _coin.SoVRMLOrientationInterpolator_swiginit(self, _coin.new_SoVRMLOrientationInterpolator())
    keyValue = property(_coin.SoVRMLOrientationInterpolator_keyValue_get, _coin.SoVRMLOrientationInterpolator_keyValue_set, doc=r"""keyValue : SoMFRotation""")
    value_changed = property(_coin.SoVRMLOrientationInterpolator_value_changed_get, _coin.SoVRMLOrientationInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLOrientationInterpolator in _coin:
_coin.SoVRMLOrientationInterpolator_swigregister(SoVRMLOrientationInterpolator)

def SoVRMLOrientationInterpolator_getClassTypeId() -> "SoType":
    r"""SoVRMLOrientationInterpolator_getClassTypeId() -> SoType"""
    return _coin.SoVRMLOrientationInterpolator_getClassTypeId()

def SoVRMLOrientationInterpolator_createInstance() -> "void *":
    r"""SoVRMLOrientationInterpolator_createInstance() -> void *"""
    return _coin.SoVRMLOrientationInterpolator_createInstance()

def SoVRMLOrientationInterpolator_initClass() -> "void":
    r"""SoVRMLOrientationInterpolator_initClass()"""
    return _coin.SoVRMLOrientationInterpolator_initClass()

class SoVRMLPixelTexture(SoVRMLTexture):
    r"""Proxy of C++ SoVRMLPixelTexture class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPixelTexture_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLPixelTexture self) -> SoType"""
        return _coin.SoVRMLPixelTexture_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLPixelTexture_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPixelTexture self) -> SoVRMLPixelTexture"""
        _coin.SoVRMLPixelTexture_swiginit(self, _coin.new_SoVRMLPixelTexture())
    image = property(_coin.SoVRMLPixelTexture_image_get, _coin.SoVRMLPixelTexture_image_set, doc=r"""image : SoSFImage""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLPixelTexture self, SoAction action)"""
        return _coin.SoVRMLPixelTexture_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLPixelTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLPixelTexture_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLPixelTexture self, SoCallbackAction action)"""
        return _coin.SoVRMLPixelTexture_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLPixelTexture self, SoRayPickAction action)"""
        return _coin.SoVRMLPixelTexture_rayPick(self, action)

# Register SoVRMLPixelTexture in _coin:
_coin.SoVRMLPixelTexture_swigregister(SoVRMLPixelTexture)

def SoVRMLPixelTexture_getClassTypeId() -> "SoType":
    r"""SoVRMLPixelTexture_getClassTypeId() -> SoType"""
    return _coin.SoVRMLPixelTexture_getClassTypeId()

def SoVRMLPixelTexture_initClass() -> "void":
    r"""SoVRMLPixelTexture_initClass()"""
    return _coin.SoVRMLPixelTexture_initClass()

class SoVRMLPlaneSensor(SoVRMLDragSensor):
    r"""Proxy of C++ SoVRMLPlaneSensor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPlaneSensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLPlaneSensor self) -> SoType"""
        return _coin.SoVRMLPlaneSensor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLPlaneSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPlaneSensor self) -> SoVRMLPlaneSensor"""
        _coin.SoVRMLPlaneSensor_swiginit(self, _coin.new_SoVRMLPlaneSensor())
    minPosition = property(_coin.SoVRMLPlaneSensor_minPosition_get, _coin.SoVRMLPlaneSensor_minPosition_set, doc=r"""minPosition : SoSFVec2f""")
    maxPosition = property(_coin.SoVRMLPlaneSensor_maxPosition_get, _coin.SoVRMLPlaneSensor_maxPosition_set, doc=r"""maxPosition : SoSFVec2f""")
    offset = property(_coin.SoVRMLPlaneSensor_offset_get, _coin.SoVRMLPlaneSensor_offset_set, doc=r"""offset : SoSFVec3f""")
    translation_changed = property(_coin.SoVRMLPlaneSensor_translation_changed_get, _coin.SoVRMLPlaneSensor_translation_changed_set, doc=r"""translation_changed : SoSFVec3f""")

# Register SoVRMLPlaneSensor in _coin:
_coin.SoVRMLPlaneSensor_swigregister(SoVRMLPlaneSensor)

def SoVRMLPlaneSensor_getClassTypeId() -> "SoType":
    r"""SoVRMLPlaneSensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLPlaneSensor_getClassTypeId()

def SoVRMLPlaneSensor_initClass() -> "void":
    r"""SoVRMLPlaneSensor_initClass()"""
    return _coin.SoVRMLPlaneSensor_initClass()

class SoVRMLPointLight(SoVRMLLight):
    r"""Proxy of C++ SoVRMLPointLight class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPointLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLPointLight self) -> SoType"""
        return _coin.SoVRMLPointLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLPointLight_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPointLight self) -> SoVRMLPointLight"""
        _coin.SoVRMLPointLight_swiginit(self, _coin.new_SoVRMLPointLight())
    location = property(_coin.SoVRMLPointLight_location_get, _coin.SoVRMLPointLight_location_set, doc=r"""location : SoSFVec3f""")
    radius = property(_coin.SoVRMLPointLight_radius_get, _coin.SoVRMLPointLight_radius_set, doc=r"""radius : SoSFFloat""")
    attenuation = property(_coin.SoVRMLPointLight_attenuation_get, _coin.SoVRMLPointLight_attenuation_set, doc=r"""attenuation : SoSFVec3f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLPointLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointLight_GLRender(self, action)

# Register SoVRMLPointLight in _coin:
_coin.SoVRMLPointLight_swigregister(SoVRMLPointLight)

def SoVRMLPointLight_getClassTypeId() -> "SoType":
    r"""SoVRMLPointLight_getClassTypeId() -> SoType"""
    return _coin.SoVRMLPointLight_getClassTypeId()

def SoVRMLPointLight_initClass() -> "void":
    r"""SoVRMLPointLight_initClass()"""
    return _coin.SoVRMLPointLight_initClass()

class SoVRMLVertexPoint(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLVertexPoint class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexPoint_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLVertexPoint self) -> SoType"""
        return _coin.SoVRMLVertexPoint_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLVertexPoint_initClass()
    coord = property(_coin.SoVRMLVertexPoint_coord_get, _coin.SoVRMLVertexPoint_coord_set, doc=r"""coord : SoSFNode""")
    color = property(_coin.SoVRMLVertexPoint_color_get, _coin.SoVRMLVertexPoint_color_set, doc=r"""color : SoSFNode""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLVertexPoint self, SoAction action)"""
        return _coin.SoVRMLVertexPoint_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLVertexPoint self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexPoint_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLVertexPoint self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexPoint_getBoundingBox(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLVertexPoint self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexPoint_callback(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLVertexPoint self, SoPickAction action)"""
        return _coin.SoVRMLVertexPoint_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLVertexPoint self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLVertexPoint_getPrimitiveCount(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLVertexPoint self, SoNotList list)"""
        return _coin.SoVRMLVertexPoint_notify(self, list)

# Register SoVRMLVertexPoint in _coin:
_coin.SoVRMLVertexPoint_swigregister(SoVRMLVertexPoint)

def SoVRMLVertexPoint_getClassTypeId() -> "SoType":
    r"""SoVRMLVertexPoint_getClassTypeId() -> SoType"""
    return _coin.SoVRMLVertexPoint_getClassTypeId()

def SoVRMLVertexPoint_initClass() -> "void":
    r"""SoVRMLVertexPoint_initClass()"""
    return _coin.SoVRMLVertexPoint_initClass()

class SoVRMLPointSet(SoVRMLVertexPoint):
    r"""Proxy of C++ SoVRMLPointSet class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPointSet_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLPointSet self) -> SoType"""
        return _coin.SoVRMLPointSet_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLPointSet_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPointSet self) -> SoVRMLPointSet"""
        _coin.SoVRMLPointSet_swiginit(self, _coin.new_SoVRMLPointSet())

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLPointSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointSet_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLPointSet_getBoundingBox(self, action)

# Register SoVRMLPointSet in _coin:
_coin.SoVRMLPointSet_swigregister(SoVRMLPointSet)

def SoVRMLPointSet_getClassTypeId() -> "SoType":
    r"""SoVRMLPointSet_getClassTypeId() -> SoType"""
    return _coin.SoVRMLPointSet_getClassTypeId()

def SoVRMLPointSet_initClass() -> "void":
    r"""SoVRMLPointSet_initClass()"""
    return _coin.SoVRMLPointSet_initClass()

class SoVRMLPositionInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLPositionInterpolator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPositionInterpolator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLPositionInterpolator self) -> SoType"""
        return _coin.SoVRMLPositionInterpolator_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLPositionInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLPositionInterpolator_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVRMLPositionInterpolator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLPositionInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPositionInterpolator self) -> SoVRMLPositionInterpolator"""
        _coin.SoVRMLPositionInterpolator_swiginit(self, _coin.new_SoVRMLPositionInterpolator())
    keyValue = property(_coin.SoVRMLPositionInterpolator_keyValue_get, _coin.SoVRMLPositionInterpolator_keyValue_set, doc=r"""keyValue : SoMFVec3f""")
    value_changed = property(_coin.SoVRMLPositionInterpolator_value_changed_get, _coin.SoVRMLPositionInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLPositionInterpolator in _coin:
_coin.SoVRMLPositionInterpolator_swigregister(SoVRMLPositionInterpolator)

def SoVRMLPositionInterpolator_getClassTypeId() -> "SoType":
    r"""SoVRMLPositionInterpolator_getClassTypeId() -> SoType"""
    return _coin.SoVRMLPositionInterpolator_getClassTypeId()

def SoVRMLPositionInterpolator_createInstance() -> "void *":
    r"""SoVRMLPositionInterpolator_createInstance() -> void *"""
    return _coin.SoVRMLPositionInterpolator_createInstance()

def SoVRMLPositionInterpolator_initClass() -> "void":
    r"""SoVRMLPositionInterpolator_initClass()"""
    return _coin.SoVRMLPositionInterpolator_initClass()

class SoVRMLProximitySensor(SoNode):
    r"""Proxy of C++ SoVRMLProximitySensor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLProximitySensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLProximitySensor self) -> SoType"""
        return _coin.SoVRMLProximitySensor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLProximitySensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLProximitySensor self) -> SoVRMLProximitySensor"""
        _coin.SoVRMLProximitySensor_swiginit(self, _coin.new_SoVRMLProximitySensor())
    center = property(_coin.SoVRMLProximitySensor_center_get, _coin.SoVRMLProximitySensor_center_set, doc=r"""center : SoSFVec3f""")
    size = property(_coin.SoVRMLProximitySensor_size_get, _coin.SoVRMLProximitySensor_size_set, doc=r"""size : SoSFVec3f""")
    enabled = property(_coin.SoVRMLProximitySensor_enabled_get, _coin.SoVRMLProximitySensor_enabled_set, doc=r"""enabled : SoSFBool""")
    isActive = property(_coin.SoVRMLProximitySensor_isActive_get, _coin.SoVRMLProximitySensor_isActive_set, doc=r"""isActive : SoSFBool""")
    position_changed = property(_coin.SoVRMLProximitySensor_position_changed_get, _coin.SoVRMLProximitySensor_position_changed_set, doc=r"""position_changed : SoSFVec3f""")
    orientation_changed = property(_coin.SoVRMLProximitySensor_orientation_changed_get, _coin.SoVRMLProximitySensor_orientation_changed_set, doc=r"""orientation_changed : SoSFRotation""")
    enterTime = property(_coin.SoVRMLProximitySensor_enterTime_get, _coin.SoVRMLProximitySensor_enterTime_set, doc=r"""enterTime : SoSFTime""")
    exitTime = property(_coin.SoVRMLProximitySensor_exitTime_get, _coin.SoVRMLProximitySensor_exitTime_set, doc=r"""exitTime : SoSFTime""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoVRMLProximitySensor self) -> SbBool"""
        return _coin.SoVRMLProximitySensor_affectsState(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLProximitySensor self, SoAction action)"""
        return _coin.SoVRMLProximitySensor_doAction(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLProximitySensor self, SoGLRenderAction action)"""
        return _coin.SoVRMLProximitySensor_GLRender(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLProximitySensor self, SoCallbackAction action)"""
        return _coin.SoVRMLProximitySensor_callback(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLProximitySensor self, SoRayPickAction action)"""
        return _coin.SoVRMLProximitySensor_rayPick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLProximitySensor self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLProximitySensor_getBoundingBox(self, action)

# Register SoVRMLProximitySensor in _coin:
_coin.SoVRMLProximitySensor_swigregister(SoVRMLProximitySensor)

def SoVRMLProximitySensor_getClassTypeId() -> "SoType":
    r"""SoVRMLProximitySensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLProximitySensor_getClassTypeId()

def SoVRMLProximitySensor_initClass() -> "void":
    r"""SoVRMLProximitySensor_initClass()"""
    return _coin.SoVRMLProximitySensor_initClass()

class SoVRMLScalarInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLScalarInterpolator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLScalarInterpolator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLScalarInterpolator self) -> SoType"""
        return _coin.SoVRMLScalarInterpolator_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLScalarInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLScalarInterpolator_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVRMLScalarInterpolator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLScalarInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLScalarInterpolator self) -> SoVRMLScalarInterpolator"""
        _coin.SoVRMLScalarInterpolator_swiginit(self, _coin.new_SoVRMLScalarInterpolator())
    keyValue = property(_coin.SoVRMLScalarInterpolator_keyValue_get, _coin.SoVRMLScalarInterpolator_keyValue_set, doc=r"""keyValue : SoMFFloat""")
    value_changed = property(_coin.SoVRMLScalarInterpolator_value_changed_get, _coin.SoVRMLScalarInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLScalarInterpolator in _coin:
_coin.SoVRMLScalarInterpolator_swigregister(SoVRMLScalarInterpolator)

def SoVRMLScalarInterpolator_getClassTypeId() -> "SoType":
    r"""SoVRMLScalarInterpolator_getClassTypeId() -> SoType"""
    return _coin.SoVRMLScalarInterpolator_getClassTypeId()

def SoVRMLScalarInterpolator_createInstance() -> "void *":
    r"""SoVRMLScalarInterpolator_createInstance() -> void *"""
    return _coin.SoVRMLScalarInterpolator_createInstance()

def SoVRMLScalarInterpolator_initClass() -> "void":
    r"""SoVRMLScalarInterpolator_initClass()"""
    return _coin.SoVRMLScalarInterpolator_initClass()

class SoVRMLScript(SoNode):
    r"""Proxy of C++ SoVRMLScript class."""

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

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLScript_initClass()

    def __init__(self):
        r"""__init__(SoVRMLScript self) -> SoVRMLScript"""
        _coin.SoVRMLScript_swiginit(self, _coin.new_SoVRMLScript())

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLScript_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLScript self) -> SoType"""
        return _coin.SoVRMLScript_getTypeId(self)
    url = property(_coin.SoVRMLScript_url_get, _coin.SoVRMLScript_url_set, doc=r"""url : SoMFString""")
    directOutput = property(_coin.SoVRMLScript_directOutput_get, _coin.SoVRMLScript_directOutput_set, doc=r"""directOutput : SoSFBool""")
    mustEvaluate = property(_coin.SoVRMLScript_mustEvaluate_get, _coin.SoVRMLScript_mustEvaluate_set, doc=r"""mustEvaluate : SoSFBool""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLScript self, SoAction action)"""
        return _coin.SoVRMLScript_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLScript self, SoCallbackAction action)"""
        return _coin.SoVRMLScript_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLScript self, SoGLRenderAction action)"""
        return _coin.SoVRMLScript_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLScript self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLScript_getBoundingBox(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLScript self, SoPickAction action)"""
        return _coin.SoVRMLScript_pick(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoVRMLScript self, SoHandleEventAction action)"""
        return _coin.SoVRMLScript_handleEvent(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVRMLScript self, SoWriteAction action)"""
        return _coin.SoVRMLScript_write(self, action)

    @staticmethod
    def setScriptEvaluateCB(cb: "SoVRMLScriptEvaluateCB *", closure: "void *") -> "void":
        r"""setScriptEvaluateCB(SoVRMLScriptEvaluateCB * cb, void * closure)"""
        return _coin.SoVRMLScript_setScriptEvaluateCB(cb, closure)

# Register SoVRMLScript in _coin:
_coin.SoVRMLScript_swigregister(SoVRMLScript)

def SoVRMLScript_initClass() -> "void":
    r"""SoVRMLScript_initClass()"""
    return _coin.SoVRMLScript_initClass()

def SoVRMLScript_getClassTypeId() -> "SoType":
    r"""SoVRMLScript_getClassTypeId() -> SoType"""
    return _coin.SoVRMLScript_getClassTypeId()

def SoVRMLScript_setScriptEvaluateCB(cb: "SoVRMLScriptEvaluateCB *", closure: "void *") -> "void":
    r"""SoVRMLScript_setScriptEvaluateCB(SoVRMLScriptEvaluateCB * cb, void * closure)"""
    return _coin.SoVRMLScript_setScriptEvaluateCB(cb, closure)

class SoVRMLShape(SoNode):
    r"""Proxy of C++ SoVRMLShape class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLShape_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLShape self) -> SoType"""
        return _coin.SoVRMLShape_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLShape_initClass()

    def __init__(self):
        r"""__init__(SoVRMLShape self) -> SoVRMLShape"""
        _coin.SoVRMLShape_swiginit(self, _coin.new_SoVRMLShape())
    OFF = _coin.SoVRMLShape_OFF
    
    ON = _coin.SoVRMLShape_ON
    
    AUTO = _coin.SoVRMLShape_AUTO
    
    appearance = property(_coin.SoVRMLShape_appearance_get, _coin.SoVRMLShape_appearance_set, doc=r"""appearance : SoSFNode""")
    geometry = property(_coin.SoVRMLShape_geometry_get, _coin.SoVRMLShape_geometry_set, doc=r"""geometry : SoSFNode""")
    renderCaching = property(_coin.SoVRMLShape_renderCaching_get, _coin.SoVRMLShape_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoVRMLShape_boundingBoxCaching_get, _coin.SoVRMLShape_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")

    @staticmethod
    def setNumRenderCaches(num: "int") -> "void":
        r"""setNumRenderCaches(int num)"""
        return _coin.SoVRMLShape_setNumRenderCaches(num)

    @staticmethod
    def getNumRenderCaches() -> "int":
        r"""getNumRenderCaches() -> int"""
        return _coin.SoVRMLShape_getNumRenderCaches()

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoVRMLShape self) -> SbBool"""
        return _coin.SoVRMLShape_affectsState(self)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLShape self, SoAction action)"""
        return _coin.SoVRMLShape_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLShape self, SoCallbackAction action)"""
        return _coin.SoVRMLShape_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLShape self, SoGLRenderAction action)"""
        return _coin.SoVRMLShape_GLRender(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLShape_getBoundingBox(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLShape self, SoRayPickAction action)"""
        return _coin.SoVRMLShape_rayPick(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLShape self, SoSearchAction action)"""
        return _coin.SoVRMLShape_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVRMLShape self, SoWriteAction action)"""
        return _coin.SoVRMLShape_write(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLShape self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLShape_getPrimitiveCount(self, action)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoVRMLShape self) -> SoChildList"""
        return _coin.SoVRMLShape_getChildren(self)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLShape self, SoNotList list)"""
        return _coin.SoVRMLShape_notify(self, list)

    def copyContents(self, srcFrom: "SoFieldContainer", copyConn: "SbBool") -> "void":
        r"""copyContents(SoVRMLShape self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLShape_copyContents(self, srcFrom, copyConn)

# Register SoVRMLShape in _coin:
_coin.SoVRMLShape_swigregister(SoVRMLShape)

def SoVRMLShape_getClassTypeId() -> "SoType":
    r"""SoVRMLShape_getClassTypeId() -> SoType"""
    return _coin.SoVRMLShape_getClassTypeId()

def SoVRMLShape_initClass() -> "void":
    r"""SoVRMLShape_initClass()"""
    return _coin.SoVRMLShape_initClass()

def SoVRMLShape_setNumRenderCaches(num: "int") -> "void":
    r"""SoVRMLShape_setNumRenderCaches(int num)"""
    return _coin.SoVRMLShape_setNumRenderCaches(num)

def SoVRMLShape_getNumRenderCaches() -> "int":
    r"""SoVRMLShape_getNumRenderCaches() -> int"""
    return _coin.SoVRMLShape_getNumRenderCaches()

class SoVRMLSound(SoNode):
    r"""Proxy of C++ SoVRMLSound class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSound_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLSound self) -> SoType"""
        return _coin.SoVRMLSound_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLSound_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSound self) -> SoVRMLSound"""
        _coin.SoVRMLSound_swiginit(self, _coin.new_SoVRMLSound())
    source = property(_coin.SoVRMLSound_source_get, _coin.SoVRMLSound_source_set, doc=r"""source : SoSFNode""")
    intensity = property(_coin.SoVRMLSound_intensity_get, _coin.SoVRMLSound_intensity_set, doc=r"""intensity : SoSFFloat""")
    priority = property(_coin.SoVRMLSound_priority_get, _coin.SoVRMLSound_priority_set, doc=r"""priority : SoSFFloat""")
    location = property(_coin.SoVRMLSound_location_get, _coin.SoVRMLSound_location_set, doc=r"""location : SoSFVec3f""")
    direction = property(_coin.SoVRMLSound_direction_get, _coin.SoVRMLSound_direction_set, doc=r"""direction : SoSFVec3f""")
    minFront = property(_coin.SoVRMLSound_minFront_get, _coin.SoVRMLSound_minFront_set, doc=r"""minFront : SoSFFloat""")
    maxFront = property(_coin.SoVRMLSound_maxFront_get, _coin.SoVRMLSound_maxFront_set, doc=r"""maxFront : SoSFFloat""")
    minBack = property(_coin.SoVRMLSound_minBack_get, _coin.SoVRMLSound_minBack_set, doc=r"""minBack : SoSFFloat""")
    maxBack = property(_coin.SoVRMLSound_maxBack_get, _coin.SoVRMLSound_maxBack_set, doc=r"""maxBack : SoSFFloat""")
    spatialize = property(_coin.SoVRMLSound_spatialize_get, _coin.SoVRMLSound_spatialize_set, doc=r"""spatialize : SoSFBool""")
    dopplerFactor = property(_coin.SoVRMLSound_dopplerFactor_get, _coin.SoVRMLSound_dopplerFactor_set, doc=r"""dopplerFactor : SoSFFloat""")
    dopplerVelocity = property(_coin.SoVRMLSound_dopplerVelocity_get, _coin.SoVRMLSound_dopplerVelocity_set, doc=r"""dopplerVelocity : SoSFFloat""")

    def setDopplerVelocity(self, velocity: "float") -> "void":
        r"""setDopplerVelocity(SoVRMLSound self, float velocity)"""
        return _coin.SoVRMLSound_setDopplerVelocity(self, velocity)

    def getDopplerVelocity(self) -> "float":
        r"""getDopplerVelocity(SoVRMLSound self) -> float"""
        return _coin.SoVRMLSound_getDopplerVelocity(self)

    def setDopplerFactor(self, factor: "float") -> "void":
        r"""setDopplerFactor(SoVRMLSound self, float factor)"""
        return _coin.SoVRMLSound_setDopplerFactor(self, factor)

    def getDopplerFactor(self) -> "float":
        r"""getDopplerFactor(SoVRMLSound self) -> float"""
        return _coin.SoVRMLSound_getDopplerFactor(self)

    def startPlaying(self, path: "SoPath", userdataptr: "void *") -> "void":
        r"""startPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"""
        return _coin.SoVRMLSound_startPlaying(self, path, userdataptr)

    def stopPlaying(self, path: "SoPath", userdataptr: "void *") -> "void":
        r"""stopPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"""
        return _coin.SoVRMLSound_stopPlaying(self, path, userdataptr)

    @staticmethod
    def setDefaultBufferingProperties(bufferLength: "int", numBuffers: "int", sleepTime: "SbTime") -> "void":
        r"""setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setDefaultBufferingProperties(bufferLength, numBuffers, sleepTime)

    def setBufferingProperties(self, bufferLength: "int", numBuffers: "int", sleepTime: "SbTime") -> "void":
        r"""setBufferingProperties(SoVRMLSound self, int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setBufferingProperties(self, bufferLength, numBuffers, sleepTime)

    def getBufferingProperties(self, bufferLength: "int &", numBuffers: "int &", sleepTime: "SbTime") -> "void":
        r"""getBufferingProperties(SoVRMLSound self, int & bufferLength, int & numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_getBufferingProperties(self, bufferLength, numBuffers, sleepTime)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoVRMLSound self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSound_audioRender(self, action)

# Register SoVRMLSound in _coin:
_coin.SoVRMLSound_swigregister(SoVRMLSound)

def SoVRMLSound_getClassTypeId() -> "SoType":
    r"""SoVRMLSound_getClassTypeId() -> SoType"""
    return _coin.SoVRMLSound_getClassTypeId()

def SoVRMLSound_initClass() -> "void":
    r"""SoVRMLSound_initClass()"""
    return _coin.SoVRMLSound_initClass()

def SoVRMLSound_setDefaultBufferingProperties(bufferLength: "int", numBuffers: "int", sleepTime: "SbTime") -> "void":
    r"""SoVRMLSound_setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"""
    return _coin.SoVRMLSound_setDefaultBufferingProperties(bufferLength, numBuffers, sleepTime)

class SoVRMLSphere(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLSphere class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSphere_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLSphere self) -> SoType"""
        return _coin.SoVRMLSphere_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLSphere_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSphere self) -> SoVRMLSphere"""
        _coin.SoVRMLSphere_swiginit(self, _coin.new_SoVRMLSphere())
    radius = property(_coin.SoVRMLSphere_radius_get, _coin.SoVRMLSphere_radius_set, doc=r"""radius : SoSFFloat""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLSphere self, SoGLRenderAction action)"""
        return _coin.SoVRMLSphere_GLRender(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLSphere self, SoRayPickAction action)"""
        return _coin.SoVRMLSphere_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLSphere self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLSphere_getPrimitiveCount(self, action)

# Register SoVRMLSphere in _coin:
_coin.SoVRMLSphere_swigregister(SoVRMLSphere)

def SoVRMLSphere_getClassTypeId() -> "SoType":
    r"""SoVRMLSphere_getClassTypeId() -> SoType"""
    return _coin.SoVRMLSphere_getClassTypeId()

def SoVRMLSphere_initClass() -> "void":
    r"""SoVRMLSphere_initClass()"""
    return _coin.SoVRMLSphere_initClass()

class SoVRMLSphereSensor(SoVRMLDragSensor):
    r"""Proxy of C++ SoVRMLSphereSensor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSphereSensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLSphereSensor self) -> SoType"""
        return _coin.SoVRMLSphereSensor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLSphereSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSphereSensor self) -> SoVRMLSphereSensor"""
        _coin.SoVRMLSphereSensor_swiginit(self, _coin.new_SoVRMLSphereSensor())
    offset = property(_coin.SoVRMLSphereSensor_offset_get, _coin.SoVRMLSphereSensor_offset_set, doc=r"""offset : SoSFRotation""")
    rotation_changed = property(_coin.SoVRMLSphereSensor_rotation_changed_get, _coin.SoVRMLSphereSensor_rotation_changed_set, doc=r"""rotation_changed : SoSFRotation""")

# Register SoVRMLSphereSensor in _coin:
_coin.SoVRMLSphereSensor_swigregister(SoVRMLSphereSensor)

def SoVRMLSphereSensor_getClassTypeId() -> "SoType":
    r"""SoVRMLSphereSensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLSphereSensor_getClassTypeId()

def SoVRMLSphereSensor_initClass() -> "void":
    r"""SoVRMLSphereSensor_initClass()"""
    return _coin.SoVRMLSphereSensor_initClass()

class SoVRMLSpotLight(SoVRMLLight):
    r"""Proxy of C++ SoVRMLSpotLight class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSpotLight_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLSpotLight self) -> SoType"""
        return _coin.SoVRMLSpotLight_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLSpotLight_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSpotLight self) -> SoVRMLSpotLight"""
        _coin.SoVRMLSpotLight_swiginit(self, _coin.new_SoVRMLSpotLight())
    location = property(_coin.SoVRMLSpotLight_location_get, _coin.SoVRMLSpotLight_location_set, doc=r"""location : SoSFVec3f""")
    direction = property(_coin.SoVRMLSpotLight_direction_get, _coin.SoVRMLSpotLight_direction_set, doc=r"""direction : SoSFVec3f""")
    beamWidth = property(_coin.SoVRMLSpotLight_beamWidth_get, _coin.SoVRMLSpotLight_beamWidth_set, doc=r"""beamWidth : SoSFFloat""")
    cutOffAngle = property(_coin.SoVRMLSpotLight_cutOffAngle_get, _coin.SoVRMLSpotLight_cutOffAngle_set, doc=r"""cutOffAngle : SoSFFloat""")
    radius = property(_coin.SoVRMLSpotLight_radius_get, _coin.SoVRMLSpotLight_radius_set, doc=r"""radius : SoSFFloat""")
    attenuation = property(_coin.SoVRMLSpotLight_attenuation_get, _coin.SoVRMLSpotLight_attenuation_set, doc=r"""attenuation : SoSFVec3f""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLSpotLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLSpotLight_GLRender(self, action)

# Register SoVRMLSpotLight in _coin:
_coin.SoVRMLSpotLight_swigregister(SoVRMLSpotLight)

def SoVRMLSpotLight_getClassTypeId() -> "SoType":
    r"""SoVRMLSpotLight_getClassTypeId() -> SoType"""
    return _coin.SoVRMLSpotLight_getClassTypeId()

def SoVRMLSpotLight_initClass() -> "void":
    r"""SoVRMLSpotLight_initClass()"""
    return _coin.SoVRMLSpotLight_initClass()

class SoVRMLSwitch(SoGroup):
    r"""Proxy of C++ SoVRMLSwitch class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSwitch_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLSwitch self) -> SoType"""
        return _coin.SoVRMLSwitch_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLSwitch_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLSwitch self) -> SoVRMLSwitch
        __init__(SoVRMLSwitch self, int choices) -> SoVRMLSwitch
        """
        _coin.SoVRMLSwitch_swiginit(self, _coin.new_SoVRMLSwitch(*args))
    choice = property(_coin.SoVRMLSwitch_choice_get, _coin.SoVRMLSwitch_choice_set, doc=r"""choice : SoMFNode""")
    whichChoice = property(_coin.SoVRMLSwitch_whichChoice_get, _coin.SoVRMLSwitch_whichChoice_set, doc=r"""whichChoice : SoSFInt32""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoVRMLSwitch self) -> SbBool"""
        return _coin.SoVRMLSwitch_affectsState(self)

    def addChoice(self, choice: "SoNode") -> "void":
        r"""addChoice(SoVRMLSwitch self, SoNode choice)"""
        return _coin.SoVRMLSwitch_addChoice(self, choice)

    def insertChoice(self, choice: "SoNode", idx: "int") -> "void":
        r"""insertChoice(SoVRMLSwitch self, SoNode choice, int idx)"""
        return _coin.SoVRMLSwitch_insertChoice(self, choice, idx)

    def getChoice(self, idx: "int") -> "SoNode *":
        r"""getChoice(SoVRMLSwitch self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChoice(self, idx)

    def findChoice(self, choice: "SoNode") -> "int":
        r"""findChoice(SoVRMLSwitch self, SoNode choice) -> int"""
        return _coin.SoVRMLSwitch_findChoice(self, choice)

    def getNumChoices(self) -> "int":
        r"""getNumChoices(SoVRMLSwitch self) -> int"""
        return _coin.SoVRMLSwitch_getNumChoices(self)

    def removeChoice(self, *args) -> "void":
        r"""
        removeChoice(SoVRMLSwitch self, int idx)
        removeChoice(SoVRMLSwitch self, SoNode node)
        """
        return _coin.SoVRMLSwitch_removeChoice(self, *args)

    def removeAllChoices(self) -> "void":
        r"""removeAllChoices(SoVRMLSwitch self)"""
        return _coin.SoVRMLSwitch_removeAllChoices(self)

    def replaceChoice(self, *args) -> "void":
        r"""
        replaceChoice(SoVRMLSwitch self, int idx, SoNode choice)
        replaceChoice(SoVRMLSwitch self, SoNode old, SoNode choice)
        """
        return _coin.SoVRMLSwitch_replaceChoice(self, *args)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLSwitch self, SoAction action)"""
        return _coin.SoVRMLSwitch_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLSwitch self, SoCallbackAction action)"""
        return _coin.SoVRMLSwitch_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLSwitch self, SoGLRenderAction action)"""
        return _coin.SoVRMLSwitch_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLSwitch self, SoPickAction action)"""
        return _coin.SoVRMLSwitch_pick(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLSwitch_getBoundingBox(self, action)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoVRMLSwitch self, SoHandleEventAction action)"""
        return _coin.SoVRMLSwitch_handleEvent(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoVRMLSwitch self, SoGetMatrixAction action)"""
        return _coin.SoVRMLSwitch_getMatrix(self, action)

    def search(self, action: "SoSearchAction") -> "void":
        r"""search(SoVRMLSwitch self, SoSearchAction action)"""
        return _coin.SoVRMLSwitch_search(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVRMLSwitch self, SoWriteAction action)"""
        return _coin.SoVRMLSwitch_write(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoVRMLSwitch self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSwitch_audioRender(self, action)

    def addChild(self, child: "SoNode") -> "void":
        r"""addChild(SoVRMLSwitch self, SoNode child)"""
        return _coin.SoVRMLSwitch_addChild(self, child)

    def insertChild(self, child: "SoNode", idx: "int") -> "void":
        r"""insertChild(SoVRMLSwitch self, SoNode child, int idx)"""
        return _coin.SoVRMLSwitch_insertChild(self, child, idx)

    def getChild(self, idx: "int") -> "SoNode *":
        r"""getChild(SoVRMLSwitch self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChild(self, idx)

    def findChild(self, child: "SoNode") -> "int":
        r"""findChild(SoVRMLSwitch self, SoNode child) -> int"""
        return _coin.SoVRMLSwitch_findChild(self, child)

    def getNumChildren(self) -> "int":
        r"""getNumChildren(SoVRMLSwitch self) -> int"""
        return _coin.SoVRMLSwitch_getNumChildren(self)

    def removeChild(self, *args) -> "void":
        r"""
        removeChild(SoVRMLSwitch self, int idx)
        removeChild(SoVRMLSwitch self, SoNode child)
        """
        return _coin.SoVRMLSwitch_removeChild(self, *args)

    def removeAllChildren(self) -> "void":
        r"""removeAllChildren(SoVRMLSwitch self)"""
        return _coin.SoVRMLSwitch_removeAllChildren(self)

    def replaceChild(self, *args) -> "void":
        r"""
        replaceChild(SoVRMLSwitch self, int idx, SoNode node)
        replaceChild(SoVRMLSwitch self, SoNode old, SoNode node)
        """
        return _coin.SoVRMLSwitch_replaceChild(self, *args)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoVRMLSwitch self) -> SoChildList"""
        return _coin.SoVRMLSwitch_getChildren(self)

# Register SoVRMLSwitch in _coin:
_coin.SoVRMLSwitch_swigregister(SoVRMLSwitch)

def SoVRMLSwitch_getClassTypeId() -> "SoType":
    r"""SoVRMLSwitch_getClassTypeId() -> SoType"""
    return _coin.SoVRMLSwitch_getClassTypeId()

def SoVRMLSwitch_initClass() -> "void":
    r"""SoVRMLSwitch_initClass()"""
    return _coin.SoVRMLSwitch_initClass()

class SoVRMLText(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLText class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLText_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLText self) -> SoType"""
        return _coin.SoVRMLText_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLText_initClass()

    def __init__(self):
        r"""__init__(SoVRMLText self) -> SoVRMLText"""
        _coin.SoVRMLText_swiginit(self, _coin.new_SoVRMLText())
    string = property(_coin.SoVRMLText_string_get, _coin.SoVRMLText_string_set, doc=r"""string : SoMFString""")
    fontStyle = property(_coin.SoVRMLText_fontStyle_get, _coin.SoVRMLText_fontStyle_set, doc=r"""fontStyle : SoSFNode""")
    maxExtent = property(_coin.SoVRMLText_maxExtent_get, _coin.SoVRMLText_maxExtent_set, doc=r"""maxExtent : SoSFFloat""")
    length = property(_coin.SoVRMLText_length_get, _coin.SoVRMLText_length_set, doc=r"""length : SoMFFloat""")
    BEGIN = _coin.SoVRMLText_BEGIN
    
    END = _coin.SoVRMLText_END
    
    MIDDLE = _coin.SoVRMLText_MIDDLE
    

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLText self, SoGLRenderAction action)"""
        return _coin.SoVRMLText_GLRender(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLText self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLText_getPrimitiveCount(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLText self, SoNotList list)"""
        return _coin.SoVRMLText_notify(self, list)

    def getChildren(self) -> "SoChildList *":
        r"""getChildren(SoVRMLText self) -> SoChildList"""
        return _coin.SoVRMLText_getChildren(self)

# Register SoVRMLText in _coin:
_coin.SoVRMLText_swigregister(SoVRMLText)

def SoVRMLText_getClassTypeId() -> "SoType":
    r"""SoVRMLText_getClassTypeId() -> SoType"""
    return _coin.SoVRMLText_getClassTypeId()

def SoVRMLText_initClass() -> "void":
    r"""SoVRMLText_initClass()"""
    return _coin.SoVRMLText_initClass()

class SoVRMLTextureCoordinate(SoNode):
    r"""Proxy of C++ SoVRMLTextureCoordinate class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTextureCoordinate_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLTextureCoordinate self) -> SoType"""
        return _coin.SoVRMLTextureCoordinate_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLTextureCoordinate_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTextureCoordinate self) -> SoVRMLTextureCoordinate"""
        _coin.SoVRMLTextureCoordinate_swiginit(self, _coin.new_SoVRMLTextureCoordinate())
    point = property(_coin.SoVRMLTextureCoordinate_point_get, _coin.SoVRMLTextureCoordinate_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLTextureCoordinate self, SoAction action)"""
        return _coin.SoVRMLTextureCoordinate_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLTextureCoordinate self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureCoordinate_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLTextureCoordinate self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureCoordinate_GLRender(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLTextureCoordinate self, SoPickAction action)"""
        return _coin.SoVRMLTextureCoordinate_pick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLTextureCoordinate self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTextureCoordinate_getPrimitiveCount(self, action)

# Register SoVRMLTextureCoordinate in _coin:
_coin.SoVRMLTextureCoordinate_swigregister(SoVRMLTextureCoordinate)

def SoVRMLTextureCoordinate_getClassTypeId() -> "SoType":
    r"""SoVRMLTextureCoordinate_getClassTypeId() -> SoType"""
    return _coin.SoVRMLTextureCoordinate_getClassTypeId()

def SoVRMLTextureCoordinate_initClass() -> "void":
    r"""SoVRMLTextureCoordinate_initClass()"""
    return _coin.SoVRMLTextureCoordinate_initClass()

class SoVRMLTextureTransform(SoNode):
    r"""Proxy of C++ SoVRMLTextureTransform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTextureTransform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLTextureTransform self) -> SoType"""
        return _coin.SoVRMLTextureTransform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLTextureTransform_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTextureTransform self) -> SoVRMLTextureTransform"""
        _coin.SoVRMLTextureTransform_swiginit(self, _coin.new_SoVRMLTextureTransform())
    translation = property(_coin.SoVRMLTextureTransform_translation_get, _coin.SoVRMLTextureTransform_translation_set, doc=r"""translation : SoSFVec2f""")
    rotation = property(_coin.SoVRMLTextureTransform_rotation_get, _coin.SoVRMLTextureTransform_rotation_set, doc=r"""rotation : SoSFFloat""")
    scale = property(_coin.SoVRMLTextureTransform_scale_get, _coin.SoVRMLTextureTransform_scale_set, doc=r"""scale : SoSFVec2f""")
    center = property(_coin.SoVRMLTextureTransform_center_get, _coin.SoVRMLTextureTransform_center_set, doc=r"""center : SoSFVec2f""")

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLTextureTransform self, SoAction action)"""
        return _coin.SoVRMLTextureTransform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLTextureTransform self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureTransform_callback(self, action)

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLTextureTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureTransform_GLRender(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoVRMLTextureTransform self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTextureTransform_getMatrix(self, action)

    def pick(self, action: "SoPickAction") -> "void":
        r"""pick(SoVRMLTextureTransform self, SoPickAction action)"""
        return _coin.SoVRMLTextureTransform_pick(self, action)

# Register SoVRMLTextureTransform in _coin:
_coin.SoVRMLTextureTransform_swigregister(SoVRMLTextureTransform)

def SoVRMLTextureTransform_getClassTypeId() -> "SoType":
    r"""SoVRMLTextureTransform_getClassTypeId() -> SoType"""
    return _coin.SoVRMLTextureTransform_getClassTypeId()

def SoVRMLTextureTransform_initClass() -> "void":
    r"""SoVRMLTextureTransform_initClass()"""
    return _coin.SoVRMLTextureTransform_initClass()

class SoVRMLTimeSensor(SoNodeEngine):
    r"""Proxy of C++ SoVRMLTimeSensor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTimeSensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLTimeSensor self) -> SoType"""
        return _coin.SoVRMLTimeSensor_getTypeId(self)

    def getOutputData(self) -> "SoEngineOutputData const *":
        r"""getOutputData(SoVRMLTimeSensor self) -> SoEngineOutputData"""
        return _coin.SoVRMLTimeSensor_getOutputData(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoVRMLTimeSensor_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLTimeSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTimeSensor self) -> SoVRMLTimeSensor"""
        _coin.SoVRMLTimeSensor_swiginit(self, _coin.new_SoVRMLTimeSensor())
    cycleInterval = property(_coin.SoVRMLTimeSensor_cycleInterval_get, _coin.SoVRMLTimeSensor_cycleInterval_set, doc=r"""cycleInterval : SoSFTime""")
    enabled = property(_coin.SoVRMLTimeSensor_enabled_get, _coin.SoVRMLTimeSensor_enabled_set, doc=r"""enabled : SoSFBool""")
    loop = property(_coin.SoVRMLTimeSensor_loop_get, _coin.SoVRMLTimeSensor_loop_set, doc=r"""loop : SoSFBool""")
    startTime = property(_coin.SoVRMLTimeSensor_startTime_get, _coin.SoVRMLTimeSensor_startTime_set, doc=r"""startTime : SoSFTime""")
    stopTime = property(_coin.SoVRMLTimeSensor_stopTime_get, _coin.SoVRMLTimeSensor_stopTime_set, doc=r"""stopTime : SoSFTime""")

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLTimeSensor self, SoNotList list)"""
        return _coin.SoVRMLTimeSensor_notify(self, list)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoVRMLTimeSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLTimeSensor_handleEvent(self, action)

    def write(self, action: "SoWriteAction") -> "void":
        r"""write(SoVRMLTimeSensor self, SoWriteAction action)"""
        return _coin.SoVRMLTimeSensor_write(self, action)
    cycleTime = property(_coin.SoVRMLTimeSensor_cycleTime_get, _coin.SoVRMLTimeSensor_cycleTime_set, doc=r"""cycleTime : SoEngineOutput""")
    fraction_changed = property(_coin.SoVRMLTimeSensor_fraction_changed_get, _coin.SoVRMLTimeSensor_fraction_changed_set, doc=r"""fraction_changed : SoEngineOutput""")
    isActive = property(_coin.SoVRMLTimeSensor_isActive_get, _coin.SoVRMLTimeSensor_isActive_set, doc=r"""isActive : SoEngineOutput""")
    time = property(_coin.SoVRMLTimeSensor_time_get, _coin.SoVRMLTimeSensor_time_set, doc=r"""time : SoEngineOutput""")

# Register SoVRMLTimeSensor in _coin:
_coin.SoVRMLTimeSensor_swigregister(SoVRMLTimeSensor)

def SoVRMLTimeSensor_getClassTypeId() -> "SoType":
    r"""SoVRMLTimeSensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLTimeSensor_getClassTypeId()

def SoVRMLTimeSensor_createInstance() -> "void *":
    r"""SoVRMLTimeSensor_createInstance() -> void *"""
    return _coin.SoVRMLTimeSensor_createInstance()

def SoVRMLTimeSensor_initClass() -> "void":
    r"""SoVRMLTimeSensor_initClass()"""
    return _coin.SoVRMLTimeSensor_initClass()

class SoVRMLTouchSensor(SoNode):
    r"""Proxy of C++ SoVRMLTouchSensor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTouchSensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLTouchSensor self) -> SoType"""
        return _coin.SoVRMLTouchSensor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLTouchSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTouchSensor self) -> SoVRMLTouchSensor"""
        _coin.SoVRMLTouchSensor_swiginit(self, _coin.new_SoVRMLTouchSensor())
    enabled = property(_coin.SoVRMLTouchSensor_enabled_get, _coin.SoVRMLTouchSensor_enabled_set, doc=r"""enabled : SoSFBool""")
    hitNormal_changed = property(_coin.SoVRMLTouchSensor_hitNormal_changed_get, _coin.SoVRMLTouchSensor_hitNormal_changed_set, doc=r"""hitNormal_changed : SoSFVec3f""")
    hitPoint_changed = property(_coin.SoVRMLTouchSensor_hitPoint_changed_get, _coin.SoVRMLTouchSensor_hitPoint_changed_set, doc=r"""hitPoint_changed : SoSFVec3f""")
    hitTexCoord_changed = property(_coin.SoVRMLTouchSensor_hitTexCoord_changed_get, _coin.SoVRMLTouchSensor_hitTexCoord_changed_set, doc=r"""hitTexCoord_changed : SoSFVec2f""")
    isActive = property(_coin.SoVRMLTouchSensor_isActive_get, _coin.SoVRMLTouchSensor_isActive_set, doc=r"""isActive : SoSFBool""")
    isOver = property(_coin.SoVRMLTouchSensor_isOver_get, _coin.SoVRMLTouchSensor_isOver_set, doc=r"""isOver : SoSFBool""")
    touchTime = property(_coin.SoVRMLTouchSensor_touchTime_get, _coin.SoVRMLTouchSensor_touchTime_set, doc=r"""touchTime : SoSFTime""")

    def affectsState(self) -> "SbBool":
        r"""affectsState(SoVRMLTouchSensor self) -> SbBool"""
        return _coin.SoVRMLTouchSensor_affectsState(self)

    def handleEvent(self, action: "SoHandleEventAction") -> "void":
        r"""handleEvent(SoVRMLTouchSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLTouchSensor_handleEvent(self, action)

# Register SoVRMLTouchSensor in _coin:
_coin.SoVRMLTouchSensor_swigregister(SoVRMLTouchSensor)

def SoVRMLTouchSensor_getClassTypeId() -> "SoType":
    r"""SoVRMLTouchSensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLTouchSensor_getClassTypeId()

def SoVRMLTouchSensor_initClass() -> "void":
    r"""SoVRMLTouchSensor_initClass()"""
    return _coin.SoVRMLTouchSensor_initClass()

class SoVRMLTransform(SoVRMLGroup):
    r"""Proxy of C++ SoVRMLTransform class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTransform_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLTransform self) -> SoType"""
        return _coin.SoVRMLTransform_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLTransform_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLTransform self) -> SoVRMLTransform
        __init__(SoVRMLTransform self, int children) -> SoVRMLTransform
        """
        _coin.SoVRMLTransform_swiginit(self, _coin.new_SoVRMLTransform(*args))
    translation = property(_coin.SoVRMLTransform_translation_get, _coin.SoVRMLTransform_translation_set, doc=r"""translation : SoSFVec3f""")
    rotation = property(_coin.SoVRMLTransform_rotation_get, _coin.SoVRMLTransform_rotation_set, doc=r"""rotation : SoSFRotation""")
    scale = property(_coin.SoVRMLTransform_scale_get, _coin.SoVRMLTransform_scale_set, doc=r"""scale : SoSFVec3f""")
    scaleOrientation = property(_coin.SoVRMLTransform_scaleOrientation_get, _coin.SoVRMLTransform_scaleOrientation_set, doc=r"""scaleOrientation : SoSFRotation""")
    center = property(_coin.SoVRMLTransform_center_get, _coin.SoVRMLTransform_center_set, doc=r"""center : SoSFVec3f""")

    def pointAt(self, srcFrom: "SbVec3f", destTo: "SbVec3f") -> "void":
        r"""pointAt(SoVRMLTransform self, SbVec3f srcFrom, SbVec3f destTo)"""
        return _coin.SoVRMLTransform_pointAt(self, srcFrom, destTo)

    def getScaleSpaceMatrix(self, inverse: "SbMatrix") -> "void":
        r"""getScaleSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getScaleSpaceMatrix(self, inverse)

    def getRotationSpaceMatrix(self, inverse: "SbMatrix") -> "void":
        r"""getRotationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getRotationSpaceMatrix(self, inverse)

    def getTranslationSpaceMatrix(self, inverse: "SbMatrix") -> "void":
        r"""getTranslationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getTranslationSpaceMatrix(self, inverse)

    def multLeft(self) -> "void":
        r"""multLeft(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_multLeft(self)

    def multRight(self) -> "void":
        r"""multRight(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_multRight(self)

    def combineLeft(self, leftnode: "SoVRMLTransform") -> "void":
        r"""combineLeft(SoVRMLTransform self, SoVRMLTransform leftnode)"""
        return _coin.SoVRMLTransform_combineLeft(self, leftnode)

    def combineRight(self, rightnode: "SoVRMLTransform") -> "void":
        r"""combineRight(SoVRMLTransform self, SoVRMLTransform rightnode)"""
        return _coin.SoVRMLTransform_combineRight(self, rightnode)

    def setMatrix(self) -> "void":
        r"""setMatrix(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_setMatrix(self)

    def recenter(self, newcenter: "SbVec3f") -> "void":
        r"""recenter(SoVRMLTransform self, SbVec3f newcenter)"""
        return _coin.SoVRMLTransform_recenter(self, newcenter)

    def doAction(self, action: "SoAction") -> "void":
        r"""doAction(SoVRMLTransform self, SoAction action)"""
        return _coin.SoVRMLTransform_doAction(self, action)

    def callback(self, action: "SoCallbackAction") -> "void":
        r"""callback(SoVRMLTransform self, SoCallbackAction action)"""
        return _coin.SoVRMLTransform_callback(self, action)

    def getBoundingBox(self, action: "SoGetBoundingBoxAction") -> "void":
        r"""getBoundingBox(SoVRMLTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLTransform_getBoundingBox(self, action)

    def getMatrix(self, action: "SoGetMatrixAction") -> "void":
        r"""getMatrix(SoVRMLTransform self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTransform_getMatrix(self, action)

    def rayPick(self, action: "SoRayPickAction") -> "void":
        r"""rayPick(SoVRMLTransform self, SoRayPickAction action)"""
        return _coin.SoVRMLTransform_rayPick(self, action)

    def getPrimitiveCount(self, action: "SoGetPrimitiveCountAction") -> "void":
        r"""getPrimitiveCount(SoVRMLTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTransform_getPrimitiveCount(self, action)

    def audioRender(self, action: "SoAudioRenderAction") -> "void":
        r"""audioRender(SoVRMLTransform self, SoAudioRenderAction action)"""
        return _coin.SoVRMLTransform_audioRender(self, action)

    def GLRenderBelowPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderBelowPath(SoVRMLTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action: "SoGLRenderAction") -> "void":
        r"""GLRenderInPath(SoVRMLTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderInPath(self, action)

    def notify(self, list: "SoNotList") -> "void":
        r"""notify(SoVRMLTransform self, SoNotList list)"""
        return _coin.SoVRMLTransform_notify(self, list)

# Register SoVRMLTransform in _coin:
_coin.SoVRMLTransform_swigregister(SoVRMLTransform)

def SoVRMLTransform_getClassTypeId() -> "SoType":
    r"""SoVRMLTransform_getClassTypeId() -> SoType"""
    return _coin.SoVRMLTransform_getClassTypeId()

def SoVRMLTransform_initClass() -> "void":
    r"""SoVRMLTransform_initClass()"""
    return _coin.SoVRMLTransform_initClass()

class SoVRMLViewpoint(SoNode):
    r"""Proxy of C++ SoVRMLViewpoint class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLViewpoint_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLViewpoint self) -> SoType"""
        return _coin.SoVRMLViewpoint_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLViewpoint_initClass()

    def __init__(self):
        r"""__init__(SoVRMLViewpoint self) -> SoVRMLViewpoint"""
        _coin.SoVRMLViewpoint_swiginit(self, _coin.new_SoVRMLViewpoint())
    position = property(_coin.SoVRMLViewpoint_position_get, _coin.SoVRMLViewpoint_position_set, doc=r"""position : SoSFVec3f""")
    orientation = property(_coin.SoVRMLViewpoint_orientation_get, _coin.SoVRMLViewpoint_orientation_set, doc=r"""orientation : SoSFRotation""")
    fieldOfView = property(_coin.SoVRMLViewpoint_fieldOfView_get, _coin.SoVRMLViewpoint_fieldOfView_set, doc=r"""fieldOfView : SoSFFloat""")
    description = property(_coin.SoVRMLViewpoint_description_get, _coin.SoVRMLViewpoint_description_set, doc=r"""description : SoSFString""")
    jump = property(_coin.SoVRMLViewpoint_jump_get, _coin.SoVRMLViewpoint_jump_set, doc=r"""jump : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLViewpoint self, SoGLRenderAction action)"""
        return _coin.SoVRMLViewpoint_GLRender(self, action)

# Register SoVRMLViewpoint in _coin:
_coin.SoVRMLViewpoint_swigregister(SoVRMLViewpoint)

def SoVRMLViewpoint_getClassTypeId() -> "SoType":
    r"""SoVRMLViewpoint_getClassTypeId() -> SoType"""
    return _coin.SoVRMLViewpoint_getClassTypeId()

def SoVRMLViewpoint_initClass() -> "void":
    r"""SoVRMLViewpoint_initClass()"""
    return _coin.SoVRMLViewpoint_initClass()

class SoVRMLVisibilitySensor(SoNode):
    r"""Proxy of C++ SoVRMLVisibilitySensor class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVisibilitySensor_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLVisibilitySensor self) -> SoType"""
        return _coin.SoVRMLVisibilitySensor_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLVisibilitySensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLVisibilitySensor self) -> SoVRMLVisibilitySensor"""
        _coin.SoVRMLVisibilitySensor_swiginit(self, _coin.new_SoVRMLVisibilitySensor())
    center = property(_coin.SoVRMLVisibilitySensor_center_get, _coin.SoVRMLVisibilitySensor_center_set, doc=r"""center : SoSFVec3f""")
    size = property(_coin.SoVRMLVisibilitySensor_size_get, _coin.SoVRMLVisibilitySensor_size_set, doc=r"""size : SoSFVec3f""")
    enabled = property(_coin.SoVRMLVisibilitySensor_enabled_get, _coin.SoVRMLVisibilitySensor_enabled_set, doc=r"""enabled : SoSFBool""")
    enterTime = property(_coin.SoVRMLVisibilitySensor_enterTime_get, _coin.SoVRMLVisibilitySensor_enterTime_set, doc=r"""enterTime : SoSFTime""")
    exitTime = property(_coin.SoVRMLVisibilitySensor_exitTime_get, _coin.SoVRMLVisibilitySensor_exitTime_set, doc=r"""exitTime : SoSFTime""")
    isActive = property(_coin.SoVRMLVisibilitySensor_isActive_get, _coin.SoVRMLVisibilitySensor_isActive_set, doc=r"""isActive : SoSFBool""")

    def GLRender(self, action: "SoGLRenderAction") -> "void":
        r"""GLRender(SoVRMLVisibilitySensor self, SoGLRenderAction action)"""
        return _coin.SoVRMLVisibilitySensor_GLRender(self, action)

# Register SoVRMLVisibilitySensor in _coin:
_coin.SoVRMLVisibilitySensor_swigregister(SoVRMLVisibilitySensor)

def SoVRMLVisibilitySensor_getClassTypeId() -> "SoType":
    r"""SoVRMLVisibilitySensor_getClassTypeId() -> SoType"""
    return _coin.SoVRMLVisibilitySensor_getClassTypeId()

def SoVRMLVisibilitySensor_initClass() -> "void":
    r"""SoVRMLVisibilitySensor_initClass()"""
    return _coin.SoVRMLVisibilitySensor_initClass()

class SoVRMLWorldInfo(SoNode):
    r"""Proxy of C++ SoVRMLWorldInfo class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLWorldInfo_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoVRMLWorldInfo self) -> SoType"""
        return _coin.SoVRMLWorldInfo_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoVRMLWorldInfo_initClass()

    def __init__(self):
        r"""__init__(SoVRMLWorldInfo self) -> SoVRMLWorldInfo"""
        _coin.SoVRMLWorldInfo_swiginit(self, _coin.new_SoVRMLWorldInfo())
    title = property(_coin.SoVRMLWorldInfo_title_get, _coin.SoVRMLWorldInfo_title_set, doc=r"""title : SoSFString""")
    info = property(_coin.SoVRMLWorldInfo_info_get, _coin.SoVRMLWorldInfo_info_set, doc=r"""info : SoMFString""")

# Register SoVRMLWorldInfo in _coin:
_coin.SoVRMLWorldInfo_swigregister(SoVRMLWorldInfo)

def SoVRMLWorldInfo_getClassTypeId() -> "SoType":
    r"""SoVRMLWorldInfo_getClassTypeId() -> SoType"""
    return _coin.SoVRMLWorldInfo_getClassTypeId()

def SoVRMLWorldInfo_initClass() -> "void":
    r"""SoVRMLWorldInfo_initClass()"""
    return _coin.SoVRMLWorldInfo_initClass()

class SoEventManager(object):
    r"""Proxy of C++ SoEventManager class."""

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

    def __init__(self):
        r"""__init__(SoEventManager self) -> SoEventManager"""
        _coin.SoEventManager_swiginit(self, _coin.new_SoEventManager())
    __swig_destroy__ = _coin.delete_SoEventManager
    NO_NAVIGATION = _coin.SoEventManager_NO_NAVIGATION
    
    JUST_NAVIGATION = _coin.SoEventManager_JUST_NAVIGATION
    
    MIXED_NAVIGATION = _coin.SoEventManager_MIXED_NAVIGATION
    

    def setSceneGraph(self, sceneroot: "SoNode") -> "void":
        r"""setSceneGraph(SoEventManager self, SoNode sceneroot)"""
        return _coin.SoEventManager_setSceneGraph(self, sceneroot)

    def getSceneGraph(self) -> "SoNode *":
        r"""getSceneGraph(SoEventManager self) -> SoNode"""
        return _coin.SoEventManager_getSceneGraph(self)

    def setCamera(self, camera: "SoCamera") -> "void":
        r"""setCamera(SoEventManager self, SoCamera camera)"""
        return _coin.SoEventManager_setCamera(self, camera)

    def getCamera(self) -> "SoCamera *":
        r"""getCamera(SoEventManager self) -> SoCamera"""
        return _coin.SoEventManager_getCamera(self)

    def processEvent(self, event: "SoEvent") -> "SbBool":
        r"""processEvent(SoEventManager self, SoEvent event) -> SbBool"""
        return _coin.SoEventManager_processEvent(self, event)

    def setNavigationState(self, state: "SoEventManager::NavigationState") -> "void":
        r"""setNavigationState(SoEventManager self, SoEventManager::NavigationState state)"""
        return _coin.SoEventManager_setNavigationState(self, state)

    def getNavigationState(self) -> "SoEventManager::NavigationState":
        r"""getNavigationState(SoEventManager self) -> SoEventManager::NavigationState"""
        return _coin.SoEventManager_getNavigationState(self)

    def getNumSoScXMLStateMachines(self) -> "int":
        r"""getNumSoScXMLStateMachines(SoEventManager self) -> int"""
        return _coin.SoEventManager_getNumSoScXMLStateMachines(self)

    def getSoScXMLStateMachine(self, idx: "int") -> "SoScXMLStateMachine *":
        r"""getSoScXMLStateMachine(SoEventManager self, int idx) -> SoScXMLStateMachine"""
        return _coin.SoEventManager_getSoScXMLStateMachine(self, idx)

    def addSoScXMLStateMachine(self, sm: "SoScXMLStateMachine") -> "void":
        r"""addSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_addSoScXMLStateMachine(self, sm)

    def removeSoScXMLStateMachine(self, sm: "SoScXMLStateMachine") -> "void":
        r"""removeSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_removeSoScXMLStateMachine(self, sm)

    def setSize(self, newsize: "SbVec2s") -> "void":
        r"""setSize(SoEventManager self, SbVec2s newsize)"""
        return _coin.SoEventManager_setSize(self, newsize)

    def setOrigin(self, newOrigin: "SbVec2s") -> "void":
        r"""setOrigin(SoEventManager self, SbVec2s newOrigin)"""
        return _coin.SoEventManager_setOrigin(self, newOrigin)

    def setViewportRegion(self, newregion: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoEventManager self, SbViewportRegion newregion)"""
        return _coin.SoEventManager_setViewportRegion(self, newregion)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoEventManager self) -> SbViewportRegion"""
        return _coin.SoEventManager_getViewportRegion(self)

    def setHandleEventAction(self, hea: "SoHandleEventAction") -> "void":
        r"""setHandleEventAction(SoEventManager self, SoHandleEventAction hea)"""
        return _coin.SoEventManager_setHandleEventAction(self, hea)

    def getHandleEventAction(self) -> "SoHandleEventAction *":
        r"""getHandleEventAction(SoEventManager self) -> SoHandleEventAction"""
        return _coin.SoEventManager_getHandleEventAction(self)

# Register SoEventManager in _coin:
_coin.SoEventManager_swigregister(SoEventManager)

class SoRenderManager(object):
    r"""Proxy of C++ SoRenderManager class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AS_IS = _coin.SoRenderManager_AS_IS
    
    WIREFRAME = _coin.SoRenderManager_WIREFRAME
    
    POINTS = _coin.SoRenderManager_POINTS
    
    WIREFRAME_OVERLAY = _coin.SoRenderManager_WIREFRAME_OVERLAY
    
    HIDDEN_LINE = _coin.SoRenderManager_HIDDEN_LINE
    
    BOUNDING_BOX = _coin.SoRenderManager_BOUNDING_BOX
    
    MONO = _coin.SoRenderManager_MONO
    
    ANAGLYPH = _coin.SoRenderManager_ANAGLYPH
    
    SEPARATE_OUTPUT = _coin.SoRenderManager_SEPARATE_OUTPUT
    
    QUAD_BUFFER = _coin.SoRenderManager_QUAD_BUFFER
    
    INTERLEAVED_ROWS = _coin.SoRenderManager_INTERLEAVED_ROWS
    
    INTERLEAVED_COLUMNS = _coin.SoRenderManager_INTERLEAVED_COLUMNS
    
    BUFFER_SINGLE = _coin.SoRenderManager_BUFFER_SINGLE
    
    BUFFER_DOUBLE = _coin.SoRenderManager_BUFFER_DOUBLE
    
    NO_AUTO_CLIPPING = _coin.SoRenderManager_NO_AUTO_CLIPPING
    
    FIXED_NEAR_PLANE = _coin.SoRenderManager_FIXED_NEAR_PLANE
    
    VARIABLE_NEAR_PLANE = _coin.SoRenderManager_VARIABLE_NEAR_PLANE
    

    def __init__(self):
        r"""__init__(SoRenderManager self) -> SoRenderManager"""
        _coin.SoRenderManager_swiginit(self, _coin.new_SoRenderManager())
    __swig_destroy__ = _coin.delete_SoRenderManager

    def render(self, *args) -> "void":
        r"""
        render(SoRenderManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoRenderManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        """
        return _coin.SoRenderManager_render(self, *args)

    def addSuperimposition(self, *args) -> "SoRenderManager::Superimposition *":
        r"""addSuperimposition(SoRenderManager self, SoNode scene, uint32_t flags=SoRenderManager::Superimposition::AUTOREDRAW|SoRenderManager::Superimposition::ZBUFFERON|SoRenderManager::Superimposition::CLEARZBUFFER) -> SoRenderManager::Superimposition"""
        return _coin.SoRenderManager_addSuperimposition(self, *args)

    def removeSuperimposition(self, s: "SoRenderManager::Superimposition *") -> "void":
        r"""removeSuperimposition(SoRenderManager self, SoRenderManager::Superimposition * s)"""
        return _coin.SoRenderManager_removeSuperimposition(self, s)

    def setSceneGraph(self, sceneroot: "SoNode") -> "void":
        r"""setSceneGraph(SoRenderManager self, SoNode sceneroot)"""
        return _coin.SoRenderManager_setSceneGraph(self, sceneroot)

    def getSceneGraph(self) -> "SoNode *":
        r"""getSceneGraph(SoRenderManager self) -> SoNode"""
        return _coin.SoRenderManager_getSceneGraph(self)

    def setCamera(self, camera: "SoCamera") -> "void":
        r"""setCamera(SoRenderManager self, SoCamera camera)"""
        return _coin.SoRenderManager_setCamera(self, camera)

    def getCamera(self) -> "SoCamera *":
        r"""getCamera(SoRenderManager self) -> SoCamera"""
        return _coin.SoRenderManager_getCamera(self)

    def setAutoClipping(self, autoclipping: "SoRenderManager::AutoClippingStrategy") -> "void":
        r"""setAutoClipping(SoRenderManager self, SoRenderManager::AutoClippingStrategy autoclipping)"""
        return _coin.SoRenderManager_setAutoClipping(self, autoclipping)

    def getAutoClipping(self) -> "SoRenderManager::AutoClippingStrategy":
        r"""getAutoClipping(SoRenderManager self) -> SoRenderManager::AutoClippingStrategy"""
        return _coin.SoRenderManager_getAutoClipping(self)

    def setNearPlaneValue(self, value: "float") -> "void":
        r"""setNearPlaneValue(SoRenderManager self, float value)"""
        return _coin.SoRenderManager_setNearPlaneValue(self, value)

    def getNearPlaneValue(self) -> "float":
        r"""getNearPlaneValue(SoRenderManager self) -> float"""
        return _coin.SoRenderManager_getNearPlaneValue(self)

    def setTexturesEnabled(self, onoff: "SbBool const") -> "void":
        r"""setTexturesEnabled(SoRenderManager self, SbBool const onoff)"""
        return _coin.SoRenderManager_setTexturesEnabled(self, onoff)

    def isTexturesEnabled(self) -> "SbBool":
        r"""isTexturesEnabled(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isTexturesEnabled(self)

    def setDoubleBuffer(self, enable: "SbBool const") -> "void":
        r"""setDoubleBuffer(SoRenderManager self, SbBool const enable)"""
        return _coin.SoRenderManager_setDoubleBuffer(self, enable)

    def isDoubleBuffer(self) -> "SbBool":
        r"""isDoubleBuffer(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isDoubleBuffer(self)

    def setRenderMode(self, mode: "SoRenderManager::RenderMode const") -> "void":
        r"""setRenderMode(SoRenderManager self, SoRenderManager::RenderMode const mode)"""
        return _coin.SoRenderManager_setRenderMode(self, mode)

    def getRenderMode(self) -> "SoRenderManager::RenderMode":
        r"""getRenderMode(SoRenderManager self) -> SoRenderManager::RenderMode"""
        return _coin.SoRenderManager_getRenderMode(self)

    def setStereoMode(self, mode: "SoRenderManager::StereoMode const") -> "void":
        r"""setStereoMode(SoRenderManager self, SoRenderManager::StereoMode const mode)"""
        return _coin.SoRenderManager_setStereoMode(self, mode)

    def getStereoMode(self) -> "SoRenderManager::StereoMode":
        r"""getStereoMode(SoRenderManager self) -> SoRenderManager::StereoMode"""
        return _coin.SoRenderManager_getStereoMode(self)

    def setStereoOffset(self, offset: "float const") -> "void":
        r"""setStereoOffset(SoRenderManager self, float const offset)"""
        return _coin.SoRenderManager_setStereoOffset(self, offset)

    def getStereoOffset(self) -> "float":
        r"""getStereoOffset(SoRenderManager self) -> float"""
        return _coin.SoRenderManager_getStereoOffset(self)

    def isAutoRedraw(self) -> "SbBool":
        r"""isAutoRedraw(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isAutoRedraw(self)

    def setRedrawPriority(self, priority: "uint32_t const") -> "void":
        r"""setRedrawPriority(SoRenderManager self, uint32_t const priority)"""
        return _coin.SoRenderManager_setRedrawPriority(self, priority)

    def getRedrawPriority(self) -> "uint32_t":
        r"""getRedrawPriority(SoRenderManager self) -> uint32_t"""
        return _coin.SoRenderManager_getRedrawPriority(self)

    def scheduleRedraw(self) -> "void":
        r"""scheduleRedraw(SoRenderManager self)"""
        return _coin.SoRenderManager_scheduleRedraw(self)

    def setWindowSize(self, newsize: "SbVec2s") -> "void":
        r"""setWindowSize(SoRenderManager self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setWindowSize(self, newsize)

    def getWindowSize(self) -> "SbVec2s const &":
        r"""getWindowSize(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getWindowSize(self)

    def setSize(self, newsize: "SbVec2s") -> "void":
        r"""setSize(SoRenderManager self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setSize(self, newsize)

    def getSize(self) -> "SbVec2s const &":
        r"""getSize(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getSize(self)

    def setOrigin(self, newOrigin: "SbVec2s") -> "void":
        r"""setOrigin(SoRenderManager self, SbVec2s newOrigin)"""
        return _coin.SoRenderManager_setOrigin(self, newOrigin)

    def getOrigin(self) -> "SbVec2s const &":
        r"""getOrigin(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getOrigin(self)

    def setViewportRegion(self, newRegion: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoRenderManager self, SbViewportRegion newRegion)"""
        return _coin.SoRenderManager_setViewportRegion(self, newRegion)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoRenderManager self) -> SbViewportRegion"""
        return _coin.SoRenderManager_getViewportRegion(self)

    def setBackgroundColor(self, color: "SbColor4f") -> "void":
        r"""setBackgroundColor(SoRenderManager self, SbColor4f color)"""
        return _coin.SoRenderManager_setBackgroundColor(self, color)

    def getBackgroundColor(self) -> "SbColor4f const &":
        r"""getBackgroundColor(SoRenderManager self) -> SbColor4f"""
        return _coin.SoRenderManager_getBackgroundColor(self)

    def setOverlayColor(self, color: "SbColor4f") -> "void":
        r"""setOverlayColor(SoRenderManager self, SbColor4f color)"""
        return _coin.SoRenderManager_setOverlayColor(self, color)

    def getOverlayColor(self) -> "SbColor4f":
        r"""getOverlayColor(SoRenderManager self) -> SbColor4f"""
        return _coin.SoRenderManager_getOverlayColor(self)

    def setBackgroundIndex(self, index: "int const") -> "void":
        r"""setBackgroundIndex(SoRenderManager self, int const index)"""
        return _coin.SoRenderManager_setBackgroundIndex(self, index)

    def getBackgroundIndex(self) -> "int":
        r"""getBackgroundIndex(SoRenderManager self) -> int"""
        return _coin.SoRenderManager_getBackgroundIndex(self)

    def setRGBMode(self, onOrOff: "SbBool const") -> "void":
        r"""setRGBMode(SoRenderManager self, SbBool const onOrOff)"""
        return _coin.SoRenderManager_setRGBMode(self, onOrOff)

    def isRGBMode(self) -> "SbBool":
        r"""isRGBMode(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isRGBMode(self)

    def activate(self) -> "void":
        r"""activate(SoRenderManager self)"""
        return _coin.SoRenderManager_activate(self)

    def deactivate(self) -> "void":
        r"""deactivate(SoRenderManager self)"""
        return _coin.SoRenderManager_deactivate(self)

    def setAntialiasing(self, smoothing: "SbBool const", numPasses: "int const") -> "void":
        r"""setAntialiasing(SoRenderManager self, SbBool const smoothing, int const numPasses)"""
        return _coin.SoRenderManager_setAntialiasing(self, smoothing, numPasses)

    def getAntialiasing(self, smoothing: "SbBool &", numPasses: "int &") -> "void":
        r"""getAntialiasing(SoRenderManager self, SbBool & smoothing, int & numPasses)"""
        return _coin.SoRenderManager_getAntialiasing(self, smoothing, numPasses)

    def setGLRenderAction(self, action: "SoGLRenderAction") -> "void":
        r"""setGLRenderAction(SoRenderManager self, SoGLRenderAction action)"""
        return _coin.SoRenderManager_setGLRenderAction(self, action)

    def getGLRenderAction(self) -> "SoGLRenderAction *":
        r"""getGLRenderAction(SoRenderManager self) -> SoGLRenderAction"""
        return _coin.SoRenderManager_getGLRenderAction(self)

    def setAudioRenderAction(self, action: "SoAudioRenderAction") -> "void":
        r"""setAudioRenderAction(SoRenderManager self, SoAudioRenderAction action)"""
        return _coin.SoRenderManager_setAudioRenderAction(self, action)

    def getAudioRenderAction(self) -> "SoAudioRenderAction *":
        r"""getAudioRenderAction(SoRenderManager self) -> SoAudioRenderAction"""
        return _coin.SoRenderManager_getAudioRenderAction(self)

    @staticmethod
    def enableRealTimeUpdate(flag: "SbBool const") -> "void":
        r"""enableRealTimeUpdate(SbBool const flag)"""
        return _coin.SoRenderManager_enableRealTimeUpdate(flag)

    @staticmethod
    def isRealTimeUpdateEnabled() -> "SbBool":
        r"""isRealTimeUpdateEnabled() -> SbBool"""
        return _coin.SoRenderManager_isRealTimeUpdateEnabled()

    @staticmethod
    def getDefaultRedrawPriority() -> "uint32_t":
        r"""getDefaultRedrawPriority() -> uint32_t"""
        return _coin.SoRenderManager_getDefaultRedrawPriority()

    def reinitialize(self) -> "void":
        r"""reinitialize(SoRenderManager self)"""
        return _coin.SoRenderManager_reinitialize(self)

    def setRenderCallback(self, *args) -> "void":
        r"""
        setRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * f, void *const userData=None)
        setRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * userData=None)
        """
        return _coin.SoRenderManager_setRenderCallback(self, *args)

    def addPreRenderCallback(self, *args) -> "void":
        r"""
        addPreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        addPreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_addPreRenderCallback(self, *args)

    def removePreRenderCallback(self, *args) -> "void":
        r"""
        removePreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        removePreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_removePreRenderCallback(self, *args)

    def addPostRenderCallback(self, *args) -> "void":
        r"""
        addPostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        addPostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_addPostRenderCallback(self, *args)

    def removePostRenderCallback(self, *args) -> "void":
        r"""
        removePostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        removePostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_removePostRenderCallback(self, *args)

# Register SoRenderManager in _coin:
_coin.SoRenderManager_swigregister(SoRenderManager)

def SoRenderManager_enableRealTimeUpdate(flag: "SbBool const") -> "void":
    r"""SoRenderManager_enableRealTimeUpdate(SbBool const flag)"""
    return _coin.SoRenderManager_enableRealTimeUpdate(flag)

def SoRenderManager_isRealTimeUpdateEnabled() -> "SbBool":
    r"""SoRenderManager_isRealTimeUpdateEnabled() -> SbBool"""
    return _coin.SoRenderManager_isRealTimeUpdateEnabled()

def SoRenderManager_getDefaultRedrawPriority() -> "uint32_t":
    r"""SoRenderManager_getDefaultRedrawPriority() -> uint32_t"""
    return _coin.SoRenderManager_getDefaultRedrawPriority()

class ScXMLObject(object):
    r"""Proxy of C++ ScXMLObject class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLObject_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLObject self) -> SoType"""
        return _coin.ScXMLObject_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLObject_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLObject_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLObject

    def isOfType(self, type: "SoType") -> "SbBool":
        r"""isOfType(ScXMLObject self, SoType type) -> SbBool"""
        return _coin.ScXMLObject_isOfType(self, type)

# Register ScXMLObject in _coin:
_coin.ScXMLObject_swigregister(ScXMLObject)

def ScXMLObject_getClassTypeId() -> "SoType":
    r"""ScXMLObject_getClassTypeId() -> SoType"""
    return _coin.ScXMLObject_getClassTypeId()

def ScXMLObject_initClass() -> "void":
    r"""ScXMLObject_initClass()"""
    return _coin.ScXMLObject_initClass()

def ScXMLObject_cleanClass() -> "void":
    r"""ScXMLObject_cleanClass()"""
    return _coin.ScXMLObject_cleanClass()

class ScXMLEventTarget(ScXMLObject):
    r"""Proxy of C++ ScXMLEventTarget class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLEventTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLEventTarget self) -> SoType"""
        return _coin.ScXMLEventTarget_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLEventTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLEventTarget_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLEventTarget

    def setEventTargetType(self, targettype: "char const *") -> "void":
        r"""setEventTargetType(ScXMLEventTarget self, char const * targettype)"""
        return _coin.ScXMLEventTarget_setEventTargetType(self, targettype)

    def getEventTargetType(self) -> "char const *":
        r"""getEventTargetType(ScXMLEventTarget self) -> char const *"""
        return _coin.ScXMLEventTarget_getEventTargetType(self)

    def setEventTargetName(self, targetname: "char const *") -> "void":
        r"""setEventTargetName(ScXMLEventTarget self, char const * targetname)"""
        return _coin.ScXMLEventTarget_setEventTargetName(self, targetname)

    def getEventTargetName(self) -> "char const *":
        r"""getEventTargetName(ScXMLEventTarget self) -> char const *"""
        return _coin.ScXMLEventTarget_getEventTargetName(self)

    def getCurrentEvent(self) -> "ScXMLEvent const *":
        r"""getCurrentEvent(ScXMLEventTarget self) -> ScXMLEvent"""
        return _coin.ScXMLEventTarget_getCurrentEvent(self)

    def queueEvent(self, *args) -> "void":
        r"""
        queueEvent(ScXMLEventTarget self, ScXMLEvent event)
        queueEvent(ScXMLEventTarget self, SbName eventid)
        """
        return _coin.ScXMLEventTarget_queueEvent(self, *args)

    def processEventQueue(self) -> "SbBool":
        r"""processEventQueue(ScXMLEventTarget self) -> SbBool"""
        return _coin.ScXMLEventTarget_processEventQueue(self)

    def sendExternalEvent(self, sendelt: "ScXMLSendElt") -> "SbBool":
        r"""sendExternalEvent(ScXMLEventTarget self, ScXMLSendElt sendelt) -> SbBool"""
        return _coin.ScXMLEventTarget_sendExternalEvent(self, sendelt)

    def sendInternalEvent(self, sendelt: "ScXMLEventElt") -> "SbBool":
        r"""sendInternalEvent(ScXMLEventTarget self, ScXMLEventElt sendelt) -> SbBool"""
        return _coin.ScXMLEventTarget_sendInternalEvent(self, sendelt)

    def queueInternalEvent(self, *args) -> "void":
        r"""
        queueInternalEvent(ScXMLEventTarget self, ScXMLEvent event)
        queueInternalEvent(ScXMLEventTarget self, SbName eventid)
        """
        return _coin.ScXMLEventTarget_queueInternalEvent(self, *args)

# Register ScXMLEventTarget in _coin:
_coin.ScXMLEventTarget_swigregister(ScXMLEventTarget)

def ScXMLEventTarget_getClassTypeId() -> "SoType":
    r"""ScXMLEventTarget_getClassTypeId() -> SoType"""
    return _coin.ScXMLEventTarget_getClassTypeId()

def ScXMLEventTarget_initClass() -> "void":
    r"""ScXMLEventTarget_initClass()"""
    return _coin.ScXMLEventTarget_initClass()

def ScXMLEventTarget_cleanClass() -> "void":
    r"""ScXMLEventTarget_cleanClass()"""
    return _coin.ScXMLEventTarget_cleanClass()

COIN_NAVIGATION_EVENT_PREFIX = _coin.COIN_NAVIGATION_EVENT_PREFIX

class SoScXMLNavigationTarget(ScXMLEventTarget):
    r"""Proxy of C++ SoScXMLNavigationTarget class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLNavigationTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLNavigationTarget self) -> SoType"""
        return _coin.SoScXMLNavigationTarget_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLNavigationTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLNavigationTarget_cleanClass()

# Register SoScXMLNavigationTarget in _coin:
_coin.SoScXMLNavigationTarget_swigregister(SoScXMLNavigationTarget)

def SoScXMLNavigationTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLNavigationTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLNavigationTarget_getClassTypeId()

def SoScXMLNavigationTarget_initClass() -> "void":
    r"""SoScXMLNavigationTarget_initClass()"""
    return _coin.SoScXMLNavigationTarget_initClass()

def SoScXMLNavigationTarget_cleanClass() -> "void":
    r"""SoScXMLNavigationTarget_cleanClass()"""
    return _coin.SoScXMLNavigationTarget_cleanClass()

class SoScXMLDollyTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLDollyTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLDollyTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLDollyTarget self) -> SoType"""
        return _coin.SoScXMLDollyTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLDollyTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLDollyTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLDollyTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLDollyTarget *":
        r"""constructSingleton() -> SoScXMLDollyTarget"""
        return _coin.SoScXMLDollyTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLDollyTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLDollyTarget *":
        r"""singleton() -> SoScXMLDollyTarget"""
        return _coin.SoScXMLDollyTarget_singleton()

    @staticmethod
    def BEGIN() -> "SbName const &":
        r"""BEGIN() -> SbName"""
        return _coin.SoScXMLDollyTarget_BEGIN()

    @staticmethod
    def UPDATE() -> "SbName const &":
        r"""UPDATE() -> SbName"""
        return _coin.SoScXMLDollyTarget_UPDATE()

    @staticmethod
    def END() -> "SbName const &":
        r"""END() -> SbName"""
        return _coin.SoScXMLDollyTarget_END()

    @staticmethod
    def JUMP() -> "SbName const &":
        r"""JUMP() -> SbName"""
        return _coin.SoScXMLDollyTarget_JUMP()

    @staticmethod
    def STEP_IN() -> "SbName const &":
        r"""STEP_IN() -> SbName"""
        return _coin.SoScXMLDollyTarget_STEP_IN()

    @staticmethod
    def STEP_OUT() -> "SbName const &":
        r"""STEP_OUT() -> SbName"""
        return _coin.SoScXMLDollyTarget_STEP_OUT()

    @staticmethod
    def dolly(camera: "SoCamera", diff: "float") -> "void":
        r"""dolly(SoCamera camera, float diff)"""
        return _coin.SoScXMLDollyTarget_dolly(camera, diff)

    @staticmethod
    def jump(camera: "SoCamera", focaldistance: "float") -> "void":
        r"""jump(SoCamera camera, float focaldistance)"""
        return _coin.SoScXMLDollyTarget_jump(camera, focaldistance)

    @staticmethod
    def step(camera: "SoCamera", exponential: "SbBool", diff: "float", min: "float"=0.0, max: "float"=0.0) -> "void":
        r"""step(SoCamera camera, SbBool exponential, float diff, float min=0.0, float max=0.0)"""
        return _coin.SoScXMLDollyTarget_step(camera, exponential, diff, min, max)

# Register SoScXMLDollyTarget in _coin:
_coin.SoScXMLDollyTarget_swigregister(SoScXMLDollyTarget)

def SoScXMLDollyTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLDollyTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLDollyTarget_getClassTypeId()

def SoScXMLDollyTarget_createInstance() -> "void *":
    r"""SoScXMLDollyTarget_createInstance() -> void *"""
    return _coin.SoScXMLDollyTarget_createInstance()

def SoScXMLDollyTarget_initClass() -> "void":
    r"""SoScXMLDollyTarget_initClass()"""
    return _coin.SoScXMLDollyTarget_initClass()

def SoScXMLDollyTarget_cleanClass() -> "void":
    r"""SoScXMLDollyTarget_cleanClass()"""
    return _coin.SoScXMLDollyTarget_cleanClass()

def SoScXMLDollyTarget_constructSingleton() -> "SoScXMLDollyTarget *":
    r"""SoScXMLDollyTarget_constructSingleton() -> SoScXMLDollyTarget"""
    return _coin.SoScXMLDollyTarget_constructSingleton()

def SoScXMLDollyTarget_destructSingleton() -> "void":
    r"""SoScXMLDollyTarget_destructSingleton()"""
    return _coin.SoScXMLDollyTarget_destructSingleton()

def SoScXMLDollyTarget_singleton() -> "SoScXMLDollyTarget *":
    r"""SoScXMLDollyTarget_singleton() -> SoScXMLDollyTarget"""
    return _coin.SoScXMLDollyTarget_singleton()

def SoScXMLDollyTarget_BEGIN() -> "SbName const &":
    r"""SoScXMLDollyTarget_BEGIN() -> SbName"""
    return _coin.SoScXMLDollyTarget_BEGIN()

def SoScXMLDollyTarget_UPDATE() -> "SbName const &":
    r"""SoScXMLDollyTarget_UPDATE() -> SbName"""
    return _coin.SoScXMLDollyTarget_UPDATE()

def SoScXMLDollyTarget_END() -> "SbName const &":
    r"""SoScXMLDollyTarget_END() -> SbName"""
    return _coin.SoScXMLDollyTarget_END()

def SoScXMLDollyTarget_JUMP() -> "SbName const &":
    r"""SoScXMLDollyTarget_JUMP() -> SbName"""
    return _coin.SoScXMLDollyTarget_JUMP()

def SoScXMLDollyTarget_STEP_IN() -> "SbName const &":
    r"""SoScXMLDollyTarget_STEP_IN() -> SbName"""
    return _coin.SoScXMLDollyTarget_STEP_IN()

def SoScXMLDollyTarget_STEP_OUT() -> "SbName const &":
    r"""SoScXMLDollyTarget_STEP_OUT() -> SbName"""
    return _coin.SoScXMLDollyTarget_STEP_OUT()

def SoScXMLDollyTarget_dolly(camera: "SoCamera", diff: "float") -> "void":
    r"""SoScXMLDollyTarget_dolly(SoCamera camera, float diff)"""
    return _coin.SoScXMLDollyTarget_dolly(camera, diff)

def SoScXMLDollyTarget_jump(camera: "SoCamera", focaldistance: "float") -> "void":
    r"""SoScXMLDollyTarget_jump(SoCamera camera, float focaldistance)"""
    return _coin.SoScXMLDollyTarget_jump(camera, focaldistance)

def SoScXMLDollyTarget_step(camera: "SoCamera", exponential: "SbBool", diff: "float", min: "float"=0.0, max: "float"=0.0) -> "void":
    r"""SoScXMLDollyTarget_step(SoCamera camera, SbBool exponential, float diff, float min=0.0, float max=0.0)"""
    return _coin.SoScXMLDollyTarget_step(camera, exponential, diff, min, max)

class SoScXMLFlightControlTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLFlightControlTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLFlightControlTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLFlightControlTarget self) -> SoType"""
        return _coin.SoScXMLFlightControlTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLFlightControlTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLFlightControlTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLFlightControlTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLFlightControlTarget *":
        r"""constructSingleton() -> SoScXMLFlightControlTarget"""
        return _coin.SoScXMLFlightControlTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLFlightControlTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLFlightControlTarget *":
        r"""singleton() -> SoScXMLFlightControlTarget"""
        return _coin.SoScXMLFlightControlTarget_singleton()

    @staticmethod
    def PITCH() -> "SbName const &":
        r"""PITCH() -> SbName"""
        return _coin.SoScXMLFlightControlTarget_PITCH()

    @staticmethod
    def YAW() -> "SbName const &":
        r"""YAW() -> SbName"""
        return _coin.SoScXMLFlightControlTarget_YAW()

    @staticmethod
    def ROLL() -> "SbName const &":
        r"""ROLL() -> SbName"""
        return _coin.SoScXMLFlightControlTarget_ROLL()

    @staticmethod
    def RESET_ROLL() -> "SbName const &":
        r"""RESET_ROLL() -> SbName"""
        return _coin.SoScXMLFlightControlTarget_RESET_ROLL()

    @staticmethod
    def pitch(camera: "SoCamera", radians: "float") -> "void":
        r"""pitch(SoCamera camera, float radians)"""
        return _coin.SoScXMLFlightControlTarget_pitch(camera, radians)

    @staticmethod
    def yaw(camera: "SoCamera", radians: "float") -> "void":
        r"""yaw(SoCamera camera, float radians)"""
        return _coin.SoScXMLFlightControlTarget_yaw(camera, radians)

    @staticmethod
    def roll(camera: "SoCamera", radians: "float") -> "void":
        r"""roll(SoCamera camera, float radians)"""
        return _coin.SoScXMLFlightControlTarget_roll(camera, radians)

    @staticmethod
    def resetRoll(camera: "SoCamera", upvector: "SbVec3f") -> "void":
        r"""resetRoll(SoCamera camera, SbVec3f upvector)"""
        return _coin.SoScXMLFlightControlTarget_resetRoll(camera, upvector)

# Register SoScXMLFlightControlTarget in _coin:
_coin.SoScXMLFlightControlTarget_swigregister(SoScXMLFlightControlTarget)

def SoScXMLFlightControlTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLFlightControlTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLFlightControlTarget_getClassTypeId()

def SoScXMLFlightControlTarget_createInstance() -> "void *":
    r"""SoScXMLFlightControlTarget_createInstance() -> void *"""
    return _coin.SoScXMLFlightControlTarget_createInstance()

def SoScXMLFlightControlTarget_initClass() -> "void":
    r"""SoScXMLFlightControlTarget_initClass()"""
    return _coin.SoScXMLFlightControlTarget_initClass()

def SoScXMLFlightControlTarget_cleanClass() -> "void":
    r"""SoScXMLFlightControlTarget_cleanClass()"""
    return _coin.SoScXMLFlightControlTarget_cleanClass()

def SoScXMLFlightControlTarget_constructSingleton() -> "SoScXMLFlightControlTarget *":
    r"""SoScXMLFlightControlTarget_constructSingleton() -> SoScXMLFlightControlTarget"""
    return _coin.SoScXMLFlightControlTarget_constructSingleton()

def SoScXMLFlightControlTarget_destructSingleton() -> "void":
    r"""SoScXMLFlightControlTarget_destructSingleton()"""
    return _coin.SoScXMLFlightControlTarget_destructSingleton()

def SoScXMLFlightControlTarget_singleton() -> "SoScXMLFlightControlTarget *":
    r"""SoScXMLFlightControlTarget_singleton() -> SoScXMLFlightControlTarget"""
    return _coin.SoScXMLFlightControlTarget_singleton()

def SoScXMLFlightControlTarget_PITCH() -> "SbName const &":
    r"""SoScXMLFlightControlTarget_PITCH() -> SbName"""
    return _coin.SoScXMLFlightControlTarget_PITCH()

def SoScXMLFlightControlTarget_YAW() -> "SbName const &":
    r"""SoScXMLFlightControlTarget_YAW() -> SbName"""
    return _coin.SoScXMLFlightControlTarget_YAW()

def SoScXMLFlightControlTarget_ROLL() -> "SbName const &":
    r"""SoScXMLFlightControlTarget_ROLL() -> SbName"""
    return _coin.SoScXMLFlightControlTarget_ROLL()

def SoScXMLFlightControlTarget_RESET_ROLL() -> "SbName const &":
    r"""SoScXMLFlightControlTarget_RESET_ROLL() -> SbName"""
    return _coin.SoScXMLFlightControlTarget_RESET_ROLL()

def SoScXMLFlightControlTarget_pitch(camera: "SoCamera", radians: "float") -> "void":
    r"""SoScXMLFlightControlTarget_pitch(SoCamera camera, float radians)"""
    return _coin.SoScXMLFlightControlTarget_pitch(camera, radians)

def SoScXMLFlightControlTarget_yaw(camera: "SoCamera", radians: "float") -> "void":
    r"""SoScXMLFlightControlTarget_yaw(SoCamera camera, float radians)"""
    return _coin.SoScXMLFlightControlTarget_yaw(camera, radians)

def SoScXMLFlightControlTarget_roll(camera: "SoCamera", radians: "float") -> "void":
    r"""SoScXMLFlightControlTarget_roll(SoCamera camera, float radians)"""
    return _coin.SoScXMLFlightControlTarget_roll(camera, radians)

def SoScXMLFlightControlTarget_resetRoll(camera: "SoCamera", upvector: "SbVec3f") -> "void":
    r"""SoScXMLFlightControlTarget_resetRoll(SoCamera camera, SbVec3f upvector)"""
    return _coin.SoScXMLFlightControlTarget_resetRoll(camera, upvector)

class SoScXMLMiscTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLMiscTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLMiscTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLMiscTarget self) -> SoType"""
        return _coin.SoScXMLMiscTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLMiscTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLMiscTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLMiscTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLMiscTarget *":
        r"""constructSingleton() -> SoScXMLMiscTarget"""
        return _coin.SoScXMLMiscTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLMiscTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLMiscTarget *":
        r"""singleton() -> SoScXMLMiscTarget"""
        return _coin.SoScXMLMiscTarget_singleton()

    @staticmethod
    def VIEW_ALL() -> "SbName const &":
        r"""VIEW_ALL() -> SbName"""
        return _coin.SoScXMLMiscTarget_VIEW_ALL()

    @staticmethod
    def REDRAW() -> "SbName const &":
        r"""REDRAW() -> SbName"""
        return _coin.SoScXMLMiscTarget_REDRAW()

    @staticmethod
    def POINT_AT() -> "SbName const &":
        r"""POINT_AT() -> SbName"""
        return _coin.SoScXMLMiscTarget_POINT_AT()

    @staticmethod
    def SET_FOCAL_DISTANCE() -> "SbName const &":
        r"""SET_FOCAL_DISTANCE() -> SbName"""
        return _coin.SoScXMLMiscTarget_SET_FOCAL_DISTANCE()

    @staticmethod
    def SET_CAMERA_POSITION() -> "SbName const &":
        r"""SET_CAMERA_POSITION() -> SbName"""
        return _coin.SoScXMLMiscTarget_SET_CAMERA_POSITION()

# Register SoScXMLMiscTarget in _coin:
_coin.SoScXMLMiscTarget_swigregister(SoScXMLMiscTarget)

def SoScXMLMiscTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLMiscTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLMiscTarget_getClassTypeId()

def SoScXMLMiscTarget_createInstance() -> "void *":
    r"""SoScXMLMiscTarget_createInstance() -> void *"""
    return _coin.SoScXMLMiscTarget_createInstance()

def SoScXMLMiscTarget_initClass() -> "void":
    r"""SoScXMLMiscTarget_initClass()"""
    return _coin.SoScXMLMiscTarget_initClass()

def SoScXMLMiscTarget_cleanClass() -> "void":
    r"""SoScXMLMiscTarget_cleanClass()"""
    return _coin.SoScXMLMiscTarget_cleanClass()

def SoScXMLMiscTarget_constructSingleton() -> "SoScXMLMiscTarget *":
    r"""SoScXMLMiscTarget_constructSingleton() -> SoScXMLMiscTarget"""
    return _coin.SoScXMLMiscTarget_constructSingleton()

def SoScXMLMiscTarget_destructSingleton() -> "void":
    r"""SoScXMLMiscTarget_destructSingleton()"""
    return _coin.SoScXMLMiscTarget_destructSingleton()

def SoScXMLMiscTarget_singleton() -> "SoScXMLMiscTarget *":
    r"""SoScXMLMiscTarget_singleton() -> SoScXMLMiscTarget"""
    return _coin.SoScXMLMiscTarget_singleton()

def SoScXMLMiscTarget_VIEW_ALL() -> "SbName const &":
    r"""SoScXMLMiscTarget_VIEW_ALL() -> SbName"""
    return _coin.SoScXMLMiscTarget_VIEW_ALL()

def SoScXMLMiscTarget_REDRAW() -> "SbName const &":
    r"""SoScXMLMiscTarget_REDRAW() -> SbName"""
    return _coin.SoScXMLMiscTarget_REDRAW()

def SoScXMLMiscTarget_POINT_AT() -> "SbName const &":
    r"""SoScXMLMiscTarget_POINT_AT() -> SbName"""
    return _coin.SoScXMLMiscTarget_POINT_AT()

def SoScXMLMiscTarget_SET_FOCAL_DISTANCE() -> "SbName const &":
    r"""SoScXMLMiscTarget_SET_FOCAL_DISTANCE() -> SbName"""
    return _coin.SoScXMLMiscTarget_SET_FOCAL_DISTANCE()

def SoScXMLMiscTarget_SET_CAMERA_POSITION() -> "SbName const &":
    r"""SoScXMLMiscTarget_SET_CAMERA_POSITION() -> SbName"""
    return _coin.SoScXMLMiscTarget_SET_CAMERA_POSITION()

class SoScXMLMotionTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLMotionTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLMotionTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLMotionTarget self) -> SoType"""
        return _coin.SoScXMLMotionTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLMotionTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLMotionTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLMotionTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLMotionTarget *":
        r"""constructSingleton() -> SoScXMLMotionTarget"""
        return _coin.SoScXMLMotionTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLMotionTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLMotionTarget *":
        r"""singleton() -> SoScXMLMotionTarget"""
        return _coin.SoScXMLMotionTarget_singleton()

# Register SoScXMLMotionTarget in _coin:
_coin.SoScXMLMotionTarget_swigregister(SoScXMLMotionTarget)

def SoScXMLMotionTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLMotionTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLMotionTarget_getClassTypeId()

def SoScXMLMotionTarget_createInstance() -> "void *":
    r"""SoScXMLMotionTarget_createInstance() -> void *"""
    return _coin.SoScXMLMotionTarget_createInstance()

def SoScXMLMotionTarget_initClass() -> "void":
    r"""SoScXMLMotionTarget_initClass()"""
    return _coin.SoScXMLMotionTarget_initClass()

def SoScXMLMotionTarget_cleanClass() -> "void":
    r"""SoScXMLMotionTarget_cleanClass()"""
    return _coin.SoScXMLMotionTarget_cleanClass()

def SoScXMLMotionTarget_constructSingleton() -> "SoScXMLMotionTarget *":
    r"""SoScXMLMotionTarget_constructSingleton() -> SoScXMLMotionTarget"""
    return _coin.SoScXMLMotionTarget_constructSingleton()

def SoScXMLMotionTarget_destructSingleton() -> "void":
    r"""SoScXMLMotionTarget_destructSingleton()"""
    return _coin.SoScXMLMotionTarget_destructSingleton()

def SoScXMLMotionTarget_singleton() -> "SoScXMLMotionTarget *":
    r"""SoScXMLMotionTarget_singleton() -> SoScXMLMotionTarget"""
    return _coin.SoScXMLMotionTarget_singleton()

SOSCXML_NAVIGATION_TARGETTYPE = _coin.SOSCXML_NAVIGATION_TARGETTYPE

class SoScXMLNavigation(object):
    r"""Proxy of C++ SoScXMLNavigation class."""

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

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.SoScXMLNavigation_initClasses()

    @staticmethod
    def cleanClasses() -> "void":
        r"""cleanClasses()"""
        return _coin.SoScXMLNavigation_cleanClasses()

    @staticmethod
    def syncLock() -> "void":
        r"""syncLock()"""
        return _coin.SoScXMLNavigation_syncLock()

    @staticmethod
    def syncUnlock() -> "void":
        r"""syncUnlock()"""
        return _coin.SoScXMLNavigation_syncUnlock()

    def __init__(self):
        r"""__init__(SoScXMLNavigation self) -> SoScXMLNavigation"""
        _coin.SoScXMLNavigation_swiginit(self, _coin.new_SoScXMLNavigation())
    __swig_destroy__ = _coin.delete_SoScXMLNavigation

# Register SoScXMLNavigation in _coin:
_coin.SoScXMLNavigation_swigregister(SoScXMLNavigation)

def SoScXMLNavigation_initClasses() -> "void":
    r"""SoScXMLNavigation_initClasses()"""
    return _coin.SoScXMLNavigation_initClasses()

def SoScXMLNavigation_cleanClasses() -> "void":
    r"""SoScXMLNavigation_cleanClasses()"""
    return _coin.SoScXMLNavigation_cleanClasses()

def SoScXMLNavigation_syncLock() -> "void":
    r"""SoScXMLNavigation_syncLock()"""
    return _coin.SoScXMLNavigation_syncLock()

def SoScXMLNavigation_syncUnlock() -> "void":
    r"""SoScXMLNavigation_syncUnlock()"""
    return _coin.SoScXMLNavigation_syncUnlock()

COIN_NAVIGATION_PAN_TARGET_EVENT_PREFIX = _coin.COIN_NAVIGATION_PAN_TARGET_EVENT_PREFIX

class SoScXMLPanTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLPanTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLPanTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLPanTarget self) -> SoType"""
        return _coin.SoScXMLPanTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLPanTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLPanTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLPanTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLPanTarget *":
        r"""constructSingleton() -> SoScXMLPanTarget"""
        return _coin.SoScXMLPanTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLPanTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLPanTarget *":
        r"""singleton() -> SoScXMLPanTarget"""
        return _coin.SoScXMLPanTarget_singleton()

    @staticmethod
    def BEGIN() -> "SbName const &":
        r"""BEGIN() -> SbName"""
        return _coin.SoScXMLPanTarget_BEGIN()

    @staticmethod
    def UPDATE() -> "SbName const &":
        r"""UPDATE() -> SbName"""
        return _coin.SoScXMLPanTarget_UPDATE()

    @staticmethod
    def END() -> "SbName const &":
        r"""END() -> SbName"""
        return _coin.SoScXMLPanTarget_END()

    @staticmethod
    def SET_FOCAL_POINT() -> "SbName const &":
        r"""SET_FOCAL_POINT() -> SbName"""
        return _coin.SoScXMLPanTarget_SET_FOCAL_POINT()

    @staticmethod
    def MOVE() -> "SbName const &":
        r"""MOVE() -> SbName"""
        return _coin.SoScXMLPanTarget_MOVE()

    @staticmethod
    def panCamera(camera: "SoCamera", vpaspect: "float", panplane: "SbPlane", previous: "SbVec2f", current: "SbVec2f") -> "void":
        r"""panCamera(SoCamera camera, float vpaspect, SbPlane panplane, SbVec2f previous, SbVec2f current)"""
        return _coin.SoScXMLPanTarget_panCamera(camera, vpaspect, panplane, previous, current)

    @staticmethod
    def panSetFocalPoint(camera: "SoCamera", worldspace: "SbVec3f") -> "void":
        r"""panSetFocalPoint(SoCamera camera, SbVec3f worldspace)"""
        return _coin.SoScXMLPanTarget_panSetFocalPoint(camera, worldspace)

    @staticmethod
    def translateCamera(camera: "SoCamera", translation: "SbVec3f", cameraspace: "SbBool"=0) -> "void":
        r"""translateCamera(SoCamera camera, SbVec3f translation, SbBool cameraspace=0)"""
        return _coin.SoScXMLPanTarget_translateCamera(camera, translation, cameraspace)

# Register SoScXMLPanTarget in _coin:
_coin.SoScXMLPanTarget_swigregister(SoScXMLPanTarget)

def SoScXMLPanTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLPanTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLPanTarget_getClassTypeId()

def SoScXMLPanTarget_createInstance() -> "void *":
    r"""SoScXMLPanTarget_createInstance() -> void *"""
    return _coin.SoScXMLPanTarget_createInstance()

def SoScXMLPanTarget_initClass() -> "void":
    r"""SoScXMLPanTarget_initClass()"""
    return _coin.SoScXMLPanTarget_initClass()

def SoScXMLPanTarget_cleanClass() -> "void":
    r"""SoScXMLPanTarget_cleanClass()"""
    return _coin.SoScXMLPanTarget_cleanClass()

def SoScXMLPanTarget_constructSingleton() -> "SoScXMLPanTarget *":
    r"""SoScXMLPanTarget_constructSingleton() -> SoScXMLPanTarget"""
    return _coin.SoScXMLPanTarget_constructSingleton()

def SoScXMLPanTarget_destructSingleton() -> "void":
    r"""SoScXMLPanTarget_destructSingleton()"""
    return _coin.SoScXMLPanTarget_destructSingleton()

def SoScXMLPanTarget_singleton() -> "SoScXMLPanTarget *":
    r"""SoScXMLPanTarget_singleton() -> SoScXMLPanTarget"""
    return _coin.SoScXMLPanTarget_singleton()

def SoScXMLPanTarget_BEGIN() -> "SbName const &":
    r"""SoScXMLPanTarget_BEGIN() -> SbName"""
    return _coin.SoScXMLPanTarget_BEGIN()

def SoScXMLPanTarget_UPDATE() -> "SbName const &":
    r"""SoScXMLPanTarget_UPDATE() -> SbName"""
    return _coin.SoScXMLPanTarget_UPDATE()

def SoScXMLPanTarget_END() -> "SbName const &":
    r"""SoScXMLPanTarget_END() -> SbName"""
    return _coin.SoScXMLPanTarget_END()

def SoScXMLPanTarget_SET_FOCAL_POINT() -> "SbName const &":
    r"""SoScXMLPanTarget_SET_FOCAL_POINT() -> SbName"""
    return _coin.SoScXMLPanTarget_SET_FOCAL_POINT()

def SoScXMLPanTarget_MOVE() -> "SbName const &":
    r"""SoScXMLPanTarget_MOVE() -> SbName"""
    return _coin.SoScXMLPanTarget_MOVE()

def SoScXMLPanTarget_panCamera(camera: "SoCamera", vpaspect: "float", panplane: "SbPlane", previous: "SbVec2f", current: "SbVec2f") -> "void":
    r"""SoScXMLPanTarget_panCamera(SoCamera camera, float vpaspect, SbPlane panplane, SbVec2f previous, SbVec2f current)"""
    return _coin.SoScXMLPanTarget_panCamera(camera, vpaspect, panplane, previous, current)

def SoScXMLPanTarget_panSetFocalPoint(camera: "SoCamera", worldspace: "SbVec3f") -> "void":
    r"""SoScXMLPanTarget_panSetFocalPoint(SoCamera camera, SbVec3f worldspace)"""
    return _coin.SoScXMLPanTarget_panSetFocalPoint(camera, worldspace)

def SoScXMLPanTarget_translateCamera(camera: "SoCamera", translation: "SbVec3f", cameraspace: "SbBool"=0) -> "void":
    r"""SoScXMLPanTarget_translateCamera(SoCamera camera, SbVec3f translation, SbBool cameraspace=0)"""
    return _coin.SoScXMLPanTarget_translateCamera(camera, translation, cameraspace)

COIN_NAVIGATION_ROTATE_TARGET_EVENT_PREFIX = _coin.COIN_NAVIGATION_ROTATE_TARGET_EVENT_PREFIX

class SoScXMLRotateTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLRotateTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLRotateTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLRotateTarget self) -> SoType"""
        return _coin.SoScXMLRotateTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLRotateTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLRotateTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLRotateTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLRotateTarget *":
        r"""constructSingleton() -> SoScXMLRotateTarget"""
        return _coin.SoScXMLRotateTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLRotateTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLRotateTarget *":
        r"""singleton() -> SoScXMLRotateTarget"""
        return _coin.SoScXMLRotateTarget_singleton()

    @staticmethod
    def BEGIN() -> "SbName const &":
        r"""BEGIN() -> SbName"""
        return _coin.SoScXMLRotateTarget_BEGIN()

    @staticmethod
    def UPDATE() -> "SbName const &":
        r"""UPDATE() -> SbName"""
        return _coin.SoScXMLRotateTarget_UPDATE()

    @staticmethod
    def END() -> "SbName const &":
        r"""END() -> SbName"""
        return _coin.SoScXMLRotateTarget_END()

    @staticmethod
    def SET_FOCAL_POINT() -> "SbName const &":
        r"""SET_FOCAL_POINT() -> SbName"""
        return _coin.SoScXMLRotateTarget_SET_FOCAL_POINT()

    @staticmethod
    def setFocalPoint(*args) -> "void":
        r"""
        setFocalPoint(SoCamera camera, SbVec3f worldspace)
        setFocalPoint(SoCamera camera, SbVec3f worldspace, SbVec3f upvector)
        """
        return _coin.SoScXMLRotateTarget_setFocalPoint(*args)

    @staticmethod
    def reorientCamera(camera: "SoCamera", rot: "SbRotation") -> "void":
        r"""reorientCamera(SoCamera camera, SbRotation rot)"""
        return _coin.SoScXMLRotateTarget_reorientCamera(camera, rot)

# Register SoScXMLRotateTarget in _coin:
_coin.SoScXMLRotateTarget_swigregister(SoScXMLRotateTarget)

def SoScXMLRotateTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLRotateTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLRotateTarget_getClassTypeId()

def SoScXMLRotateTarget_createInstance() -> "void *":
    r"""SoScXMLRotateTarget_createInstance() -> void *"""
    return _coin.SoScXMLRotateTarget_createInstance()

def SoScXMLRotateTarget_initClass() -> "void":
    r"""SoScXMLRotateTarget_initClass()"""
    return _coin.SoScXMLRotateTarget_initClass()

def SoScXMLRotateTarget_cleanClass() -> "void":
    r"""SoScXMLRotateTarget_cleanClass()"""
    return _coin.SoScXMLRotateTarget_cleanClass()

def SoScXMLRotateTarget_constructSingleton() -> "SoScXMLRotateTarget *":
    r"""SoScXMLRotateTarget_constructSingleton() -> SoScXMLRotateTarget"""
    return _coin.SoScXMLRotateTarget_constructSingleton()

def SoScXMLRotateTarget_destructSingleton() -> "void":
    r"""SoScXMLRotateTarget_destructSingleton()"""
    return _coin.SoScXMLRotateTarget_destructSingleton()

def SoScXMLRotateTarget_singleton() -> "SoScXMLRotateTarget *":
    r"""SoScXMLRotateTarget_singleton() -> SoScXMLRotateTarget"""
    return _coin.SoScXMLRotateTarget_singleton()

def SoScXMLRotateTarget_BEGIN() -> "SbName const &":
    r"""SoScXMLRotateTarget_BEGIN() -> SbName"""
    return _coin.SoScXMLRotateTarget_BEGIN()

def SoScXMLRotateTarget_UPDATE() -> "SbName const &":
    r"""SoScXMLRotateTarget_UPDATE() -> SbName"""
    return _coin.SoScXMLRotateTarget_UPDATE()

def SoScXMLRotateTarget_END() -> "SbName const &":
    r"""SoScXMLRotateTarget_END() -> SbName"""
    return _coin.SoScXMLRotateTarget_END()

def SoScXMLRotateTarget_SET_FOCAL_POINT() -> "SbName const &":
    r"""SoScXMLRotateTarget_SET_FOCAL_POINT() -> SbName"""
    return _coin.SoScXMLRotateTarget_SET_FOCAL_POINT()

def SoScXMLRotateTarget_setFocalPoint(*args) -> "void":
    r"""
    SoScXMLRotateTarget_setFocalPoint(SoCamera camera, SbVec3f worldspace)
    SoScXMLRotateTarget_setFocalPoint(SoCamera camera, SbVec3f worldspace, SbVec3f upvector)
    """
    return _coin.SoScXMLRotateTarget_setFocalPoint(*args)

def SoScXMLRotateTarget_reorientCamera(camera: "SoCamera", rot: "SbRotation") -> "void":
    r"""SoScXMLRotateTarget_reorientCamera(SoCamera camera, SbRotation rot)"""
    return _coin.SoScXMLRotateTarget_reorientCamera(camera, rot)

COIN_NAVIGATION_SEEK_EVENT_PREFIX = _coin.COIN_NAVIGATION_SEEK_EVENT_PREFIX

class SoScXMLSeekTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLSeekTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLSeekTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLSeekTarget self) -> SoType"""
        return _coin.SoScXMLSeekTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLSeekTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLSeekTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLSeekTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLSeekTarget *":
        r"""constructSingleton() -> SoScXMLSeekTarget"""
        return _coin.SoScXMLSeekTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLSeekTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLSeekTarget *":
        r"""singleton() -> SoScXMLSeekTarget"""
        return _coin.SoScXMLSeekTarget_singleton()

    @staticmethod
    def BEGIN() -> "SbName const &":
        r"""BEGIN() -> SbName"""
        return _coin.SoScXMLSeekTarget_BEGIN()

    @staticmethod
    def UPDATE() -> "SbName const &":
        r"""UPDATE() -> SbName"""
        return _coin.SoScXMLSeekTarget_UPDATE()

    @staticmethod
    def END() -> "SbName const &":
        r"""END() -> SbName"""
        return _coin.SoScXMLSeekTarget_END()

# Register SoScXMLSeekTarget in _coin:
_coin.SoScXMLSeekTarget_swigregister(SoScXMLSeekTarget)

def SoScXMLSeekTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLSeekTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLSeekTarget_getClassTypeId()

def SoScXMLSeekTarget_createInstance() -> "void *":
    r"""SoScXMLSeekTarget_createInstance() -> void *"""
    return _coin.SoScXMLSeekTarget_createInstance()

def SoScXMLSeekTarget_initClass() -> "void":
    r"""SoScXMLSeekTarget_initClass()"""
    return _coin.SoScXMLSeekTarget_initClass()

def SoScXMLSeekTarget_cleanClass() -> "void":
    r"""SoScXMLSeekTarget_cleanClass()"""
    return _coin.SoScXMLSeekTarget_cleanClass()

def SoScXMLSeekTarget_constructSingleton() -> "SoScXMLSeekTarget *":
    r"""SoScXMLSeekTarget_constructSingleton() -> SoScXMLSeekTarget"""
    return _coin.SoScXMLSeekTarget_constructSingleton()

def SoScXMLSeekTarget_destructSingleton() -> "void":
    r"""SoScXMLSeekTarget_destructSingleton()"""
    return _coin.SoScXMLSeekTarget_destructSingleton()

def SoScXMLSeekTarget_singleton() -> "SoScXMLSeekTarget *":
    r"""SoScXMLSeekTarget_singleton() -> SoScXMLSeekTarget"""
    return _coin.SoScXMLSeekTarget_singleton()

def SoScXMLSeekTarget_BEGIN() -> "SbName const &":
    r"""SoScXMLSeekTarget_BEGIN() -> SbName"""
    return _coin.SoScXMLSeekTarget_BEGIN()

def SoScXMLSeekTarget_UPDATE() -> "SbName const &":
    r"""SoScXMLSeekTarget_UPDATE() -> SbName"""
    return _coin.SoScXMLSeekTarget_UPDATE()

def SoScXMLSeekTarget_END() -> "SbName const &":
    r"""SoScXMLSeekTarget_END() -> SbName"""
    return _coin.SoScXMLSeekTarget_END()

COIN_NAVIGATION_SPIN_EVENT_PREFIX = _coin.COIN_NAVIGATION_SPIN_EVENT_PREFIX

class SoScXMLSpinTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLSpinTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLSpinTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLSpinTarget self) -> SoType"""
        return _coin.SoScXMLSpinTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLSpinTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLSpinTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLSpinTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLSpinTarget *":
        r"""constructSingleton() -> SoScXMLSpinTarget"""
        return _coin.SoScXMLSpinTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLSpinTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLSpinTarget *":
        r"""singleton() -> SoScXMLSpinTarget"""
        return _coin.SoScXMLSpinTarget_singleton()

    @staticmethod
    def BEGIN() -> "SbName const &":
        r"""BEGIN() -> SbName"""
        return _coin.SoScXMLSpinTarget_BEGIN()

    @staticmethod
    def UPDATE() -> "SbName const &":
        r"""UPDATE() -> SbName"""
        return _coin.SoScXMLSpinTarget_UPDATE()

    @staticmethod
    def END() -> "SbName const &":
        r"""END() -> SbName"""
        return _coin.SoScXMLSpinTarget_END()

    @staticmethod
    def reorientCamera(camera: "SoCamera", rot: "SbRotation") -> "void":
        r"""reorientCamera(SoCamera camera, SbRotation rot)"""
        return _coin.SoScXMLSpinTarget_reorientCamera(camera, rot)

# Register SoScXMLSpinTarget in _coin:
_coin.SoScXMLSpinTarget_swigregister(SoScXMLSpinTarget)

def SoScXMLSpinTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLSpinTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLSpinTarget_getClassTypeId()

def SoScXMLSpinTarget_createInstance() -> "void *":
    r"""SoScXMLSpinTarget_createInstance() -> void *"""
    return _coin.SoScXMLSpinTarget_createInstance()

def SoScXMLSpinTarget_initClass() -> "void":
    r"""SoScXMLSpinTarget_initClass()"""
    return _coin.SoScXMLSpinTarget_initClass()

def SoScXMLSpinTarget_cleanClass() -> "void":
    r"""SoScXMLSpinTarget_cleanClass()"""
    return _coin.SoScXMLSpinTarget_cleanClass()

def SoScXMLSpinTarget_constructSingleton() -> "SoScXMLSpinTarget *":
    r"""SoScXMLSpinTarget_constructSingleton() -> SoScXMLSpinTarget"""
    return _coin.SoScXMLSpinTarget_constructSingleton()

def SoScXMLSpinTarget_destructSingleton() -> "void":
    r"""SoScXMLSpinTarget_destructSingleton()"""
    return _coin.SoScXMLSpinTarget_destructSingleton()

def SoScXMLSpinTarget_singleton() -> "SoScXMLSpinTarget *":
    r"""SoScXMLSpinTarget_singleton() -> SoScXMLSpinTarget"""
    return _coin.SoScXMLSpinTarget_singleton()

def SoScXMLSpinTarget_BEGIN() -> "SbName const &":
    r"""SoScXMLSpinTarget_BEGIN() -> SbName"""
    return _coin.SoScXMLSpinTarget_BEGIN()

def SoScXMLSpinTarget_UPDATE() -> "SbName const &":
    r"""SoScXMLSpinTarget_UPDATE() -> SbName"""
    return _coin.SoScXMLSpinTarget_UPDATE()

def SoScXMLSpinTarget_END() -> "SbName const &":
    r"""SoScXMLSpinTarget_END() -> SbName"""
    return _coin.SoScXMLSpinTarget_END()

def SoScXMLSpinTarget_reorientCamera(camera: "SoCamera", rot: "SbRotation") -> "void":
    r"""SoScXMLSpinTarget_reorientCamera(SoCamera camera, SbRotation rot)"""
    return _coin.SoScXMLSpinTarget_reorientCamera(camera, rot)

COIN_NAVIGATION_ZOOM_TARGET_EVENT_PREFIX = _coin.COIN_NAVIGATION_ZOOM_TARGET_EVENT_PREFIX

class SoScXMLZoomTarget(SoScXMLNavigationTarget):
    r"""Proxy of C++ SoScXMLZoomTarget class."""

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

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLZoomTarget_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLZoomTarget self) -> SoType"""
        return _coin.SoScXMLZoomTarget_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLZoomTarget_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLZoomTarget_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLZoomTarget_cleanClass()

    @staticmethod
    def constructSingleton() -> "SoScXMLZoomTarget *":
        r"""constructSingleton() -> SoScXMLZoomTarget"""
        return _coin.SoScXMLZoomTarget_constructSingleton()

    @staticmethod
    def destructSingleton() -> "void":
        r"""destructSingleton()"""
        return _coin.SoScXMLZoomTarget_destructSingleton()

    @staticmethod
    def singleton() -> "SoScXMLZoomTarget *":
        r"""singleton() -> SoScXMLZoomTarget"""
        return _coin.SoScXMLZoomTarget_singleton()

    @staticmethod
    def BEGIN() -> "SbName const &":
        r"""BEGIN() -> SbName"""
        return _coin.SoScXMLZoomTarget_BEGIN()

    @staticmethod
    def UPDATE() -> "SbName const &":
        r"""UPDATE() -> SbName"""
        return _coin.SoScXMLZoomTarget_UPDATE()

    @staticmethod
    def END() -> "SbName const &":
        r"""END() -> SbName"""
        return _coin.SoScXMLZoomTarget_END()

    @staticmethod
    def ZOOM() -> "SbName const &":
        r"""ZOOM() -> SbName"""
        return _coin.SoScXMLZoomTarget_ZOOM()

    @staticmethod
    def ZOOM_IN() -> "SbName const &":
        r"""ZOOM_IN() -> SbName"""
        return _coin.SoScXMLZoomTarget_ZOOM_IN()

    @staticmethod
    def ZOOM_OUT() -> "SbName const &":
        r"""ZOOM_OUT() -> SbName"""
        return _coin.SoScXMLZoomTarget_ZOOM_OUT()

    @staticmethod
    def RESET() -> "SbName const &":
        r"""RESET() -> SbName"""
        return _coin.SoScXMLZoomTarget_RESET()

    @staticmethod
    def zoom(camera: "SoCamera", factor: "float") -> "void":
        r"""zoom(SoCamera camera, float factor)"""
        return _coin.SoScXMLZoomTarget_zoom(camera, factor)

    @staticmethod
    def reset(camera: "SoCamera") -> "void":
        r"""reset(SoCamera camera)"""
        return _coin.SoScXMLZoomTarget_reset(camera)

# Register SoScXMLZoomTarget in _coin:
_coin.SoScXMLZoomTarget_swigregister(SoScXMLZoomTarget)

def SoScXMLZoomTarget_getClassTypeId() -> "SoType":
    r"""SoScXMLZoomTarget_getClassTypeId() -> SoType"""
    return _coin.SoScXMLZoomTarget_getClassTypeId()

def SoScXMLZoomTarget_createInstance() -> "void *":
    r"""SoScXMLZoomTarget_createInstance() -> void *"""
    return _coin.SoScXMLZoomTarget_createInstance()

def SoScXMLZoomTarget_initClass() -> "void":
    r"""SoScXMLZoomTarget_initClass()"""
    return _coin.SoScXMLZoomTarget_initClass()

def SoScXMLZoomTarget_cleanClass() -> "void":
    r"""SoScXMLZoomTarget_cleanClass()"""
    return _coin.SoScXMLZoomTarget_cleanClass()

def SoScXMLZoomTarget_constructSingleton() -> "SoScXMLZoomTarget *":
    r"""SoScXMLZoomTarget_constructSingleton() -> SoScXMLZoomTarget"""
    return _coin.SoScXMLZoomTarget_constructSingleton()

def SoScXMLZoomTarget_destructSingleton() -> "void":
    r"""SoScXMLZoomTarget_destructSingleton()"""
    return _coin.SoScXMLZoomTarget_destructSingleton()

def SoScXMLZoomTarget_singleton() -> "SoScXMLZoomTarget *":
    r"""SoScXMLZoomTarget_singleton() -> SoScXMLZoomTarget"""
    return _coin.SoScXMLZoomTarget_singleton()

def SoScXMLZoomTarget_BEGIN() -> "SbName const &":
    r"""SoScXMLZoomTarget_BEGIN() -> SbName"""
    return _coin.SoScXMLZoomTarget_BEGIN()

def SoScXMLZoomTarget_UPDATE() -> "SbName const &":
    r"""SoScXMLZoomTarget_UPDATE() -> SbName"""
    return _coin.SoScXMLZoomTarget_UPDATE()

def SoScXMLZoomTarget_END() -> "SbName const &":
    r"""SoScXMLZoomTarget_END() -> SbName"""
    return _coin.SoScXMLZoomTarget_END()

def SoScXMLZoomTarget_ZOOM() -> "SbName const &":
    r"""SoScXMLZoomTarget_ZOOM() -> SbName"""
    return _coin.SoScXMLZoomTarget_ZOOM()

def SoScXMLZoomTarget_ZOOM_IN() -> "SbName const &":
    r"""SoScXMLZoomTarget_ZOOM_IN() -> SbName"""
    return _coin.SoScXMLZoomTarget_ZOOM_IN()

def SoScXMLZoomTarget_ZOOM_OUT() -> "SbName const &":
    r"""SoScXMLZoomTarget_ZOOM_OUT() -> SbName"""
    return _coin.SoScXMLZoomTarget_ZOOM_OUT()

def SoScXMLZoomTarget_RESET() -> "SbName const &":
    r"""SoScXMLZoomTarget_RESET() -> SbName"""
    return _coin.SoScXMLZoomTarget_RESET()

def SoScXMLZoomTarget_zoom(camera: "SoCamera", factor: "float") -> "void":
    r"""SoScXMLZoomTarget_zoom(SoCamera camera, float factor)"""
    return _coin.SoScXMLZoomTarget_zoom(camera, factor)

def SoScXMLZoomTarget_reset(camera: "SoCamera") -> "void":
    r"""SoScXMLZoomTarget_reset(SoCamera camera)"""
    return _coin.SoScXMLZoomTarget_reset(camera)

class ScXML(object):
    r"""Proxy of C++ ScXML class."""

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

    @staticmethod
    def initClasses() -> "void":
        r"""initClasses()"""
        return _coin.ScXML_initClasses()

    @staticmethod
    def cleanClasses() -> "void":
        r"""cleanClasses()"""
        return _coin.ScXML_cleanClasses()

    @staticmethod
    def readFile(filename: "char const *") -> "ScXMLStateMachine *":
        r"""readFile(char const * filename) -> ScXMLStateMachine"""
        return _coin.ScXML_readFile(filename)

    @staticmethod
    def readBuffer(buffer: "SbByteBuffer const &") -> "ScXMLStateMachine *":
        r"""readBuffer(SbByteBuffer const & buffer) -> ScXMLStateMachine"""
        return _coin.ScXML_readBuffer(buffer)

    @staticmethod
    def registerEvaluatorType(profilename: "SbName", evaluatortype: "SoType") -> "SbBool":
        r"""registerEvaluatorType(SbName profilename, SoType evaluatortype) -> SbBool"""
        return _coin.ScXML_registerEvaluatorType(profilename, evaluatortype)

    @staticmethod
    def unregisterEvaluatorType(profilename: "SbName", evaluatortype: "SoType") -> "SbBool":
        r"""unregisterEvaluatorType(SbName profilename, SoType evaluatortype) -> SbBool"""
        return _coin.ScXML_unregisterEvaluatorType(profilename, evaluatortype)

    @staticmethod
    def getEvaluatorTypeForProfile(profilename: "SbName") -> "SoType":
        r"""getEvaluatorTypeForProfile(SbName profilename) -> SoType"""
        return _coin.ScXML_getEvaluatorTypeForProfile(profilename)

    def __init__(self):
        r"""__init__(ScXML self) -> ScXML"""
        _coin.ScXML_swiginit(self, _coin.new_ScXML())
    __swig_destroy__ = _coin.delete_ScXML

# Register ScXML in _coin:
_coin.ScXML_swigregister(ScXML)

def ScXML_initClasses() -> "void":
    r"""ScXML_initClasses()"""
    return _coin.ScXML_initClasses()

def ScXML_cleanClasses() -> "void":
    r"""ScXML_cleanClasses()"""
    return _coin.ScXML_cleanClasses()

def ScXML_readFile(filename: "char const *") -> "ScXMLStateMachine *":
    r"""ScXML_readFile(char const * filename) -> ScXMLStateMachine"""
    return _coin.ScXML_readFile(filename)

def ScXML_readBuffer(buffer: "SbByteBuffer const &") -> "ScXMLStateMachine *":
    r"""ScXML_readBuffer(SbByteBuffer const & buffer) -> ScXMLStateMachine"""
    return _coin.ScXML_readBuffer(buffer)

def ScXML_registerEvaluatorType(profilename: "SbName", evaluatortype: "SoType") -> "SbBool":
    r"""ScXML_registerEvaluatorType(SbName profilename, SoType evaluatortype) -> SbBool"""
    return _coin.ScXML_registerEvaluatorType(profilename, evaluatortype)

def ScXML_unregisterEvaluatorType(profilename: "SbName", evaluatortype: "SoType") -> "SbBool":
    r"""ScXML_unregisterEvaluatorType(SbName profilename, SoType evaluatortype) -> SbBool"""
    return _coin.ScXML_unregisterEvaluatorType(profilename, evaluatortype)

def ScXML_getEvaluatorTypeForProfile(profilename: "SbName") -> "SoType":
    r"""ScXML_getEvaluatorTypeForProfile(SbName profilename) -> SoType"""
    return _coin.ScXML_getEvaluatorTypeForProfile(profilename)

class ScXMLElt(ScXMLObject):
    r"""Proxy of C++ ScXMLElt class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLElt self) -> SoType"""
        return _coin.ScXMLElt_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLElt_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLElt

    def setXMLAttribute(self, attribute: "char const *", value: "char const *") -> "void":
        r"""setXMLAttribute(ScXMLElt self, char const * attribute, char const * value)"""
        return _coin.ScXMLElt_setXMLAttribute(self, attribute, value)

    def getXMLAttribute(self, attribute: "char const *") -> "char const *":
        r"""getXMLAttribute(ScXMLElt self, char const * attribute) -> char const *"""
        return _coin.ScXMLElt_getXMLAttribute(self, attribute)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLElt self) -> SbBool"""
        return _coin.ScXMLElt_handleXMLAttributes(self)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLElt_search(self, attrname, attrvalue)

    def clone(self) -> "ScXMLElt *":
        r"""clone(ScXMLElt self) -> ScXMLElt"""
        return _coin.ScXMLElt_clone(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLElt self, ScXMLElt rhs)"""
        return _coin.ScXMLElt_copyContents(self, rhs)

    def setContainer(self, container: "ScXMLElt") -> "void":
        r"""setContainer(ScXMLElt self, ScXMLElt container)"""
        return _coin.ScXMLElt_setContainer(self, container)

    def getContainer(self) -> "ScXMLElt *":
        r"""getContainer(ScXMLElt self) -> ScXMLElt"""
        return _coin.ScXMLElt_getContainer(self)

    def isContainedIn(self, object: "ScXMLElt") -> "SbBool":
        r"""isContainedIn(ScXMLElt self, ScXMLElt object) -> SbBool"""
        return _coin.ScXMLElt_isContainedIn(self, object)

# Register ScXMLElt in _coin:
_coin.ScXMLElt_swigregister(ScXMLElt)

def ScXMLElt_getClassTypeId() -> "SoType":
    r"""ScXMLElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLElt_getClassTypeId()

def ScXMLElt_initClass() -> "void":
    r"""ScXMLElt_initClass()"""
    return _coin.ScXMLElt_initClass()

def ScXMLElt_cleanClass() -> "void":
    r"""ScXMLElt_cleanClass()"""
    return _coin.ScXMLElt_cleanClass()

class ScXMLEltReader(object):
    r"""Proxy of C++ ScXMLEltReader class."""

    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__ = _coin.delete_ScXMLEltReader

    def read(self, container: "ScXMLElt", elt: "cc_xml_elt *", doc: "ScXMLDocument", sm: "ScXMLStateMachine") -> "ScXMLElt *":
        r"""read(ScXMLEltReader self, ScXMLElt container, cc_xml_elt * elt, ScXMLDocument doc, ScXMLStateMachine sm) -> ScXMLElt"""
        return _coin.ScXMLEltReader_read(self, container, elt, doc, sm)

# Register ScXMLEltReader in _coin:
_coin.ScXMLEltReader_swigregister(ScXMLEltReader)

class ScXMLAbstractStateElt(ScXMLElt):
    r"""Proxy of C++ ScXMLAbstractStateElt class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLAbstractStateElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLAbstractStateElt self) -> SoType"""
        return _coin.ScXMLAbstractStateElt_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLAbstractStateElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLAbstractStateElt_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLAbstractStateElt

    def setIdAttribute(self, id: "char const *") -> "void":
        r"""setIdAttribute(ScXMLAbstractStateElt self, char const * id)"""
        return _coin.ScXMLAbstractStateElt_setIdAttribute(self, id)

    def getIdAttribute(self) -> "char const *":
        r"""getIdAttribute(ScXMLAbstractStateElt self) -> char const *"""
        return _coin.ScXMLAbstractStateElt_getIdAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLAbstractStateElt self) -> SbBool"""
        return _coin.ScXMLAbstractStateElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLAbstractStateElt self, ScXMLElt rhs)"""
        return _coin.ScXMLAbstractStateElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLAbstractStateElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLAbstractStateElt_search(self, attrname, attrvalue)

# Register ScXMLAbstractStateElt in _coin:
_coin.ScXMLAbstractStateElt_swigregister(ScXMLAbstractStateElt)

def ScXMLAbstractStateElt_getClassTypeId() -> "SoType":
    r"""ScXMLAbstractStateElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLAbstractStateElt_getClassTypeId()

def ScXMLAbstractStateElt_initClass() -> "void":
    r"""ScXMLAbstractStateElt_initClass()"""
    return _coin.ScXMLAbstractStateElt_initClass()

def ScXMLAbstractStateElt_cleanClass() -> "void":
    r"""ScXMLAbstractStateElt_cleanClass()"""
    return _coin.ScXMLAbstractStateElt_cleanClass()

class ScXMLAnchorElt(ScXMLElt):
    r"""Proxy of C++ ScXMLAnchorElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLAnchorElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLAnchorElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLAnchorElt self) -> SoType"""
        return _coin.ScXMLAnchorElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLAnchorElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLAnchorElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLAnchorElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLAnchorElt self) -> ScXMLAnchorElt"""
        _coin.ScXMLAnchorElt_swiginit(self, _coin.new_ScXMLAnchorElt())
    __swig_destroy__ = _coin.delete_ScXMLAnchorElt

    def setTypeAttribute(self, type: "char const *") -> "void":
        r"""setTypeAttribute(ScXMLAnchorElt self, char const * type)"""
        return _coin.ScXMLAnchorElt_setTypeAttribute(self, type)

    def getTypeAttribute(self) -> "char const *":
        r"""getTypeAttribute(ScXMLAnchorElt self) -> char const *"""
        return _coin.ScXMLAnchorElt_getTypeAttribute(self)

    def setSnapshotAttribute(self, snapshot: "char const *") -> "void":
        r"""setSnapshotAttribute(ScXMLAnchorElt self, char const * snapshot)"""
        return _coin.ScXMLAnchorElt_setSnapshotAttribute(self, snapshot)

    def getSnapshotAttribute(self) -> "char const *":
        r"""getSnapshotAttribute(ScXMLAnchorElt self) -> char const *"""
        return _coin.ScXMLAnchorElt_getSnapshotAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLAnchorElt self) -> SbBool"""
        return _coin.ScXMLAnchorElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLAnchorElt self, ScXMLElt rhs)"""
        return _coin.ScXMLAnchorElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLAnchorElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLAnchorElt_search(self, attrname, attrvalue)

# Register ScXMLAnchorElt in _coin:
_coin.ScXMLAnchorElt_swigregister(ScXMLAnchorElt)

def ScXMLAnchorElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLAnchorElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLAnchorElt_getElementReader()

def ScXMLAnchorElt_getClassTypeId() -> "SoType":
    r"""ScXMLAnchorElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLAnchorElt_getClassTypeId()

def ScXMLAnchorElt_createInstance() -> "void *":
    r"""ScXMLAnchorElt_createInstance() -> void *"""
    return _coin.ScXMLAnchorElt_createInstance()

def ScXMLAnchorElt_initClass() -> "void":
    r"""ScXMLAnchorElt_initClass()"""
    return _coin.ScXMLAnchorElt_initClass()

def ScXMLAnchorElt_cleanClass() -> "void":
    r"""ScXMLAnchorElt_cleanClass()"""
    return _coin.ScXMLAnchorElt_cleanClass()

class ScXMLExecutableElt(ScXMLElt):
    r"""Proxy of C++ ScXMLExecutableElt class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLExecutableElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLExecutableElt self) -> SoType"""
        return _coin.ScXMLExecutableElt_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLExecutableElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLExecutableElt_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLExecutableElt

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLExecutableElt self, ScXMLElt rhs)"""
        return _coin.ScXMLExecutableElt_copyContents(self, rhs)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLExecutableElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLExecutableElt_execute(self, statemachine)

# Register ScXMLExecutableElt in _coin:
_coin.ScXMLExecutableElt_swigregister(ScXMLExecutableElt)

def ScXMLExecutableElt_getClassTypeId() -> "SoType":
    r"""ScXMLExecutableElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLExecutableElt_getClassTypeId()

def ScXMLExecutableElt_initClass() -> "void":
    r"""ScXMLExecutableElt_initClass()"""
    return _coin.ScXMLExecutableElt_initClass()

def ScXMLExecutableElt_cleanClass() -> "void":
    r"""ScXMLExecutableElt_cleanClass()"""
    return _coin.ScXMLExecutableElt_cleanClass()

class ScXMLAssignElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLAssignElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLAssignElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLAssignElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLAssignElt self) -> SoType"""
        return _coin.ScXMLAssignElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLAssignElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLAssignElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLAssignElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLAssignElt self) -> ScXMLAssignElt"""
        _coin.ScXMLAssignElt_swiginit(self, _coin.new_ScXMLAssignElt())
    __swig_destroy__ = _coin.delete_ScXMLAssignElt

    def setLocationAttribute(self, location: "char const *") -> "void":
        r"""setLocationAttribute(ScXMLAssignElt self, char const * location)"""
        return _coin.ScXMLAssignElt_setLocationAttribute(self, location)

    def getLocationAttribute(self) -> "char const *":
        r"""getLocationAttribute(ScXMLAssignElt self) -> char const *"""
        return _coin.ScXMLAssignElt_getLocationAttribute(self)

    def setDataIDAttribute(self, dataID: "char const *") -> "void":
        r"""setDataIDAttribute(ScXMLAssignElt self, char const * dataID)"""
        return _coin.ScXMLAssignElt_setDataIDAttribute(self, dataID)

    def getDataIDAttribute(self) -> "char const *":
        r"""getDataIDAttribute(ScXMLAssignElt self) -> char const *"""
        return _coin.ScXMLAssignElt_getDataIDAttribute(self)

    def setExprAttribute(self, expr: "char const *") -> "void":
        r"""setExprAttribute(ScXMLAssignElt self, char const * expr)"""
        return _coin.ScXMLAssignElt_setExprAttribute(self, expr)

    def getExprAttribute(self) -> "char const *":
        r"""getExprAttribute(ScXMLAssignElt self) -> char const *"""
        return _coin.ScXMLAssignElt_getExprAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLAssignElt self) -> SbBool"""
        return _coin.ScXMLAssignElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLAssignElt self, ScXMLElt rhs)"""
        return _coin.ScXMLAssignElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLAssignElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLAssignElt_search(self, attrname, attrvalue)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLAssignElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLAssignElt_execute(self, statemachine)

# Register ScXMLAssignElt in _coin:
_coin.ScXMLAssignElt_swigregister(ScXMLAssignElt)

def ScXMLAssignElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLAssignElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLAssignElt_getElementReader()

def ScXMLAssignElt_getClassTypeId() -> "SoType":
    r"""ScXMLAssignElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLAssignElt_getClassTypeId()

def ScXMLAssignElt_createInstance() -> "void *":
    r"""ScXMLAssignElt_createInstance() -> void *"""
    return _coin.ScXMLAssignElt_createInstance()

def ScXMLAssignElt_initClass() -> "void":
    r"""ScXMLAssignElt_initClass()"""
    return _coin.ScXMLAssignElt_initClass()

def ScXMLAssignElt_cleanClass() -> "void":
    r"""ScXMLAssignElt_cleanClass()"""
    return _coin.ScXMLAssignElt_cleanClass()

class ScXMLEvaluator(ScXMLObject):
    r"""Proxy of C++ ScXMLEvaluator class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLEvaluator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLEvaluator self) -> SoType"""
        return _coin.ScXMLEvaluator_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLEvaluator_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLEvaluator_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLEvaluator

    def setStateMachine(self, sm: "ScXMLStateMachine") -> "void":
        r"""setStateMachine(ScXMLEvaluator self, ScXMLStateMachine sm)"""
        return _coin.ScXMLEvaluator_setStateMachine(self, sm)

    def getStateMachine(self) -> "ScXMLStateMachine *":
        r"""getStateMachine(ScXMLEvaluator self) -> ScXMLStateMachine"""
        return _coin.ScXMLEvaluator_getStateMachine(self)

    def evaluate(self, expression: "char const *") -> "ScXMLDataObj *":
        r"""evaluate(ScXMLEvaluator self, char const * expression) -> ScXMLDataObj"""
        return _coin.ScXMLEvaluator_evaluate(self, expression)

    def setAtLocation(self, location: "char const *", obj: "ScXMLDataObj") -> "SbBool":
        r"""setAtLocation(ScXMLEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"""
        return _coin.ScXMLEvaluator_setAtLocation(self, location, obj)

    def locate(self, location: "char const *") -> "ScXMLDataObj *":
        r"""locate(ScXMLEvaluator self, char const * location) -> ScXMLDataObj"""
        return _coin.ScXMLEvaluator_locate(self, location)

    def clearTemporaryVariables(self) -> "void":
        r"""clearTemporaryVariables(ScXMLEvaluator self)"""
        return _coin.ScXMLEvaluator_clearTemporaryVariables(self)

# Register ScXMLEvaluator in _coin:
_coin.ScXMLEvaluator_swigregister(ScXMLEvaluator)

def ScXMLEvaluator_getClassTypeId() -> "SoType":
    r"""ScXMLEvaluator_getClassTypeId() -> SoType"""
    return _coin.ScXMLEvaluator_getClassTypeId()

def ScXMLEvaluator_initClass() -> "void":
    r"""ScXMLEvaluator_initClass()"""
    return _coin.ScXMLEvaluator_initClass()

def ScXMLEvaluator_cleanClass() -> "void":
    r"""ScXMLEvaluator_cleanClass()"""
    return _coin.ScXMLEvaluator_cleanClass()

class ScXMLDataObj(ScXMLObject):
    r"""Proxy of C++ ScXMLDataObj class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLDataObj self) -> SoType"""
        return _coin.ScXMLDataObj_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLDataObj_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLDataObj

    def setContainer(self, container: "ScXMLObject") -> "void":
        r"""setContainer(ScXMLDataObj self, ScXMLObject container)"""
        return _coin.ScXMLDataObj_setContainer(self, container)

    def getContainer(self) -> "ScXMLObject *":
        r"""getContainer(ScXMLDataObj self) -> ScXMLObject"""
        return _coin.ScXMLDataObj_getContainer(self)

# Register ScXMLDataObj in _coin:
_coin.ScXMLDataObj_swigregister(ScXMLDataObj)

def ScXMLDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLDataObj_getClassTypeId()

def ScXMLDataObj_initClass() -> "void":
    r"""ScXMLDataObj_initClass()"""
    return _coin.ScXMLDataObj_initClass()

def ScXMLDataObj_cleanClass() -> "void":
    r"""ScXMLDataObj_cleanClass()"""
    return _coin.ScXMLDataObj_cleanClass()

class ScXMLConstantDataObj(ScXMLDataObj):
    r"""Proxy of C++ ScXMLConstantDataObj class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLConstantDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLConstantDataObj self) -> SoType"""
        return _coin.ScXMLConstantDataObj_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLConstantDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLConstantDataObj_cleanClass()

    def clone(self) -> "ScXMLDataObj *":
        r"""clone(ScXMLConstantDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLConstantDataObj_clone(self)

    def convertToString(self, str: "SbString") -> "void":
        r"""convertToString(ScXMLConstantDataObj self, SbString str)"""
        return _coin.ScXMLConstantDataObj_convertToString(self, str)
    __swig_destroy__ = _coin.delete_ScXMLConstantDataObj

# Register ScXMLConstantDataObj in _coin:
_coin.ScXMLConstantDataObj_swigregister(ScXMLConstantDataObj)

def ScXMLConstantDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLConstantDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLConstantDataObj_getClassTypeId()

def ScXMLConstantDataObj_initClass() -> "void":
    r"""ScXMLConstantDataObj_initClass()"""
    return _coin.ScXMLConstantDataObj_initClass()

def ScXMLConstantDataObj_cleanClass() -> "void":
    r"""ScXMLConstantDataObj_cleanClass()"""
    return _coin.ScXMLConstantDataObj_cleanClass()

class ScXMLStringDataObj(ScXMLConstantDataObj):
    r"""Proxy of C++ ScXMLStringDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLStringDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLStringDataObj self) -> SoType"""
        return _coin.ScXMLStringDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLStringDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLStringDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLStringDataObj_cleanClass()

    @staticmethod
    def createFor(value: "char const *") -> "ScXMLDataObj *":
        r"""createFor(char const * value) -> ScXMLDataObj"""
        return _coin.ScXMLStringDataObj_createFor(value)

    def __init__(self, *args):
        r"""
        __init__(ScXMLStringDataObj self) -> ScXMLStringDataObj
        __init__(ScXMLStringDataObj self, char const * value) -> ScXMLStringDataObj
        """
        _coin.ScXMLStringDataObj_swiginit(self, _coin.new_ScXMLStringDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLStringDataObj

    def setString(self, value: "char const *") -> "void":
        r"""setString(ScXMLStringDataObj self, char const * value)"""
        return _coin.ScXMLStringDataObj_setString(self, value)

    def getString(self) -> "char const *":
        r"""getString(ScXMLStringDataObj self) -> char const *"""
        return _coin.ScXMLStringDataObj_getString(self)

    def clone(self) -> "ScXMLDataObj *":
        r"""clone(ScXMLStringDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLStringDataObj_clone(self)

    def convertToString(self, str: "SbString") -> "void":
        r"""convertToString(ScXMLStringDataObj self, SbString str)"""
        return _coin.ScXMLStringDataObj_convertToString(self, str)

# Register ScXMLStringDataObj in _coin:
_coin.ScXMLStringDataObj_swigregister(ScXMLStringDataObj)

def ScXMLStringDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLStringDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLStringDataObj_getClassTypeId()

def ScXMLStringDataObj_createInstance() -> "void *":
    r"""ScXMLStringDataObj_createInstance() -> void *"""
    return _coin.ScXMLStringDataObj_createInstance()

def ScXMLStringDataObj_initClass() -> "void":
    r"""ScXMLStringDataObj_initClass()"""
    return _coin.ScXMLStringDataObj_initClass()

def ScXMLStringDataObj_cleanClass() -> "void":
    r"""ScXMLStringDataObj_cleanClass()"""
    return _coin.ScXMLStringDataObj_cleanClass()

def ScXMLStringDataObj_createFor(value: "char const *") -> "ScXMLDataObj *":
    r"""ScXMLStringDataObj_createFor(char const * value) -> ScXMLDataObj"""
    return _coin.ScXMLStringDataObj_createFor(value)

class ScXMLRealDataObj(ScXMLConstantDataObj):
    r"""Proxy of C++ ScXMLRealDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLRealDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLRealDataObj self) -> SoType"""
        return _coin.ScXMLRealDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLRealDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLRealDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLRealDataObj_cleanClass()

    @staticmethod
    def createFor(value: "double") -> "ScXMLDataObj *":
        r"""createFor(double value) -> ScXMLDataObj"""
        return _coin.ScXMLRealDataObj_createFor(value)

    def __init__(self, *args):
        r"""
        __init__(ScXMLRealDataObj self) -> ScXMLRealDataObj
        __init__(ScXMLRealDataObj self, double value) -> ScXMLRealDataObj
        """
        _coin.ScXMLRealDataObj_swiginit(self, _coin.new_ScXMLRealDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLRealDataObj

    def setReal(self, value: "double") -> "void":
        r"""setReal(ScXMLRealDataObj self, double value)"""
        return _coin.ScXMLRealDataObj_setReal(self, value)

    def getReal(self) -> "double":
        r"""getReal(ScXMLRealDataObj self) -> double"""
        return _coin.ScXMLRealDataObj_getReal(self)

    def clone(self) -> "ScXMLDataObj *":
        r"""clone(ScXMLRealDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLRealDataObj_clone(self)

    def convertToString(self, str: "SbString") -> "void":
        r"""convertToString(ScXMLRealDataObj self, SbString str)"""
        return _coin.ScXMLRealDataObj_convertToString(self, str)

# Register ScXMLRealDataObj in _coin:
_coin.ScXMLRealDataObj_swigregister(ScXMLRealDataObj)

def ScXMLRealDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLRealDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLRealDataObj_getClassTypeId()

def ScXMLRealDataObj_createInstance() -> "void *":
    r"""ScXMLRealDataObj_createInstance() -> void *"""
    return _coin.ScXMLRealDataObj_createInstance()

def ScXMLRealDataObj_initClass() -> "void":
    r"""ScXMLRealDataObj_initClass()"""
    return _coin.ScXMLRealDataObj_initClass()

def ScXMLRealDataObj_cleanClass() -> "void":
    r"""ScXMLRealDataObj_cleanClass()"""
    return _coin.ScXMLRealDataObj_cleanClass()

def ScXMLRealDataObj_createFor(value: "double") -> "ScXMLDataObj *":
    r"""ScXMLRealDataObj_createFor(double value) -> ScXMLDataObj"""
    return _coin.ScXMLRealDataObj_createFor(value)

class ScXMLBoolDataObj(ScXMLConstantDataObj):
    r"""Proxy of C++ ScXMLBoolDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLBoolDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLBoolDataObj self) -> SoType"""
        return _coin.ScXMLBoolDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLBoolDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLBoolDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLBoolDataObj_cleanClass()

    @staticmethod
    def createFor(value: "SbBool") -> "ScXMLDataObj *":
        r"""createFor(SbBool value) -> ScXMLDataObj"""
        return _coin.ScXMLBoolDataObj_createFor(value)

    def __init__(self, *args):
        r"""
        __init__(ScXMLBoolDataObj self) -> ScXMLBoolDataObj
        __init__(ScXMLBoolDataObj self, SbBool value) -> ScXMLBoolDataObj
        """
        _coin.ScXMLBoolDataObj_swiginit(self, _coin.new_ScXMLBoolDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLBoolDataObj

    def setBool(self, value: "SbBool") -> "void":
        r"""setBool(ScXMLBoolDataObj self, SbBool value)"""
        return _coin.ScXMLBoolDataObj_setBool(self, value)

    def getBool(self) -> "SbBool":
        r"""getBool(ScXMLBoolDataObj self) -> SbBool"""
        return _coin.ScXMLBoolDataObj_getBool(self)

    def clone(self) -> "ScXMLDataObj *":
        r"""clone(ScXMLBoolDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLBoolDataObj_clone(self)

    def convertToString(self, str: "SbString") -> "void":
        r"""convertToString(ScXMLBoolDataObj self, SbString str)"""
        return _coin.ScXMLBoolDataObj_convertToString(self, str)

# Register ScXMLBoolDataObj in _coin:
_coin.ScXMLBoolDataObj_swigregister(ScXMLBoolDataObj)

def ScXMLBoolDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLBoolDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLBoolDataObj_getClassTypeId()

def ScXMLBoolDataObj_createInstance() -> "void *":
    r"""ScXMLBoolDataObj_createInstance() -> void *"""
    return _coin.ScXMLBoolDataObj_createInstance()

def ScXMLBoolDataObj_initClass() -> "void":
    r"""ScXMLBoolDataObj_initClass()"""
    return _coin.ScXMLBoolDataObj_initClass()

def ScXMLBoolDataObj_cleanClass() -> "void":
    r"""ScXMLBoolDataObj_cleanClass()"""
    return _coin.ScXMLBoolDataObj_cleanClass()

def ScXMLBoolDataObj_createFor(value: "SbBool") -> "ScXMLDataObj *":
    r"""ScXMLBoolDataObj_createFor(SbBool value) -> ScXMLDataObj"""
    return _coin.ScXMLBoolDataObj_createFor(value)

class ScXMLSbDataObj(ScXMLConstantDataObj):
    r"""Proxy of C++ ScXMLSbDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLSbDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLSbDataObj self) -> SoType"""
        return _coin.ScXMLSbDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLSbDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLSbDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLSbDataObj_cleanClass()

    @staticmethod
    def createFor(value: "char const *") -> "ScXMLDataObj *":
        r"""createFor(char const * value) -> ScXMLDataObj"""
        return _coin.ScXMLSbDataObj_createFor(value)

    def __init__(self, *args):
        r"""
        __init__(ScXMLSbDataObj self) -> ScXMLSbDataObj
        __init__(ScXMLSbDataObj self, char const * value) -> ScXMLSbDataObj
        """
        _coin.ScXMLSbDataObj_swiginit(self, _coin.new_ScXMLSbDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLSbDataObj

    def setSbValue(self, value: "char const *") -> "void":
        r"""setSbValue(ScXMLSbDataObj self, char const * value)"""
        return _coin.ScXMLSbDataObj_setSbValue(self, value)

    def getSbValue(self) -> "char const *":
        r"""getSbValue(ScXMLSbDataObj self) -> char const *"""
        return _coin.ScXMLSbDataObj_getSbValue(self)

    def clone(self) -> "ScXMLDataObj *":
        r"""clone(ScXMLSbDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLSbDataObj_clone(self)

    def convertToString(self, str: "SbString") -> "void":
        r"""convertToString(ScXMLSbDataObj self, SbString str)"""
        return _coin.ScXMLSbDataObj_convertToString(self, str)

# Register ScXMLSbDataObj in _coin:
_coin.ScXMLSbDataObj_swigregister(ScXMLSbDataObj)

def ScXMLSbDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLSbDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLSbDataObj_getClassTypeId()

def ScXMLSbDataObj_createInstance() -> "void *":
    r"""ScXMLSbDataObj_createInstance() -> void *"""
    return _coin.ScXMLSbDataObj_createInstance()

def ScXMLSbDataObj_initClass() -> "void":
    r"""ScXMLSbDataObj_initClass()"""
    return _coin.ScXMLSbDataObj_initClass()

def ScXMLSbDataObj_cleanClass() -> "void":
    r"""ScXMLSbDataObj_cleanClass()"""
    return _coin.ScXMLSbDataObj_cleanClass()

def ScXMLSbDataObj_createFor(value: "char const *") -> "ScXMLDataObj *":
    r"""ScXMLSbDataObj_createFor(char const * value) -> ScXMLDataObj"""
    return _coin.ScXMLSbDataObj_createFor(value)

class ScXMLXMLDataObj(ScXMLDataObj):
    r"""Proxy of C++ ScXMLXMLDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLXMLDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLXMLDataObj self) -> SoType"""
        return _coin.ScXMLXMLDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLXMLDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLXMLDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLXMLDataObj_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLXMLDataObj self) -> ScXMLXMLDataObj"""
        _coin.ScXMLXMLDataObj_swiginit(self, _coin.new_ScXMLXMLDataObj())
    __swig_destroy__ = _coin.delete_ScXMLXMLDataObj

    def clone(self) -> "ScXMLDataObj *":
        r"""clone(ScXMLXMLDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLXMLDataObj_clone(self)

# Register ScXMLXMLDataObj in _coin:
_coin.ScXMLXMLDataObj_swigregister(ScXMLXMLDataObj)

def ScXMLXMLDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLXMLDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLXMLDataObj_getClassTypeId()

def ScXMLXMLDataObj_createInstance() -> "void *":
    r"""ScXMLXMLDataObj_createInstance() -> void *"""
    return _coin.ScXMLXMLDataObj_createInstance()

def ScXMLXMLDataObj_initClass() -> "void":
    r"""ScXMLXMLDataObj_initClass()"""
    return _coin.ScXMLXMLDataObj_initClass()

def ScXMLXMLDataObj_cleanClass() -> "void":
    r"""ScXMLXMLDataObj_cleanClass()"""
    return _coin.ScXMLXMLDataObj_cleanClass()

class ScXMLExprDataObj(ScXMLDataObj):
    r"""Proxy of C++ ScXMLExprDataObj class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLExprDataObj self) -> SoType"""
        return _coin.ScXMLExprDataObj_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLExprDataObj_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLExprDataObj

    def evaluate(self, sm: "ScXMLStateMachine") -> "ScXMLDataObj *":
        r"""evaluate(ScXMLExprDataObj self, ScXMLStateMachine sm) -> ScXMLDataObj"""
        return _coin.ScXMLExprDataObj_evaluate(self, sm)

# Register ScXMLExprDataObj in _coin:
_coin.ScXMLExprDataObj_swigregister(ScXMLExprDataObj)

def ScXMLExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLExprDataObj_getClassTypeId()

def ScXMLExprDataObj_initClass() -> "void":
    r"""ScXMLExprDataObj_initClass()"""
    return _coin.ScXMLExprDataObj_initClass()

def ScXMLExprDataObj_cleanClass() -> "void":
    r"""ScXMLExprDataObj_cleanClass()"""
    return _coin.ScXMLExprDataObj_cleanClass()

class ScXMLReferenceDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLReferenceDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLReferenceDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLReferenceDataObj self) -> SoType"""
        return _coin.ScXMLReferenceDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLReferenceDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLReferenceDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLReferenceDataObj_cleanClass()

    @staticmethod
    def createFor(reference: "char const *") -> "ScXMLDataObj *":
        r"""createFor(char const * reference) -> ScXMLDataObj"""
        return _coin.ScXMLReferenceDataObj_createFor(reference)

    def __init__(self, *args):
        r"""
        __init__(ScXMLReferenceDataObj self) -> ScXMLReferenceDataObj
        __init__(ScXMLReferenceDataObj self, char const * reference) -> ScXMLReferenceDataObj
        """
        _coin.ScXMLReferenceDataObj_swiginit(self, _coin.new_ScXMLReferenceDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLReferenceDataObj

    def setReference(self, reference: "char const *") -> "void":
        r"""setReference(ScXMLReferenceDataObj self, char const * reference)"""
        return _coin.ScXMLReferenceDataObj_setReference(self, reference)

    def getReference(self) -> "char const *":
        r"""getReference(ScXMLReferenceDataObj self) -> char const *"""
        return _coin.ScXMLReferenceDataObj_getReference(self)

    def evaluateNow(self, sm: "ScXMLStateMachine", pointer: "ScXMLDataObj *&") -> "SbBool":
        r"""evaluateNow(ScXMLReferenceDataObj self, ScXMLStateMachine sm, ScXMLDataObj *& pointer) -> SbBool"""
        return _coin.ScXMLReferenceDataObj_evaluateNow(self, sm, pointer)

# Register ScXMLReferenceDataObj in _coin:
_coin.ScXMLReferenceDataObj_swigregister(ScXMLReferenceDataObj)

def ScXMLReferenceDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLReferenceDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLReferenceDataObj_getClassTypeId()

def ScXMLReferenceDataObj_createInstance() -> "void *":
    r"""ScXMLReferenceDataObj_createInstance() -> void *"""
    return _coin.ScXMLReferenceDataObj_createInstance()

def ScXMLReferenceDataObj_initClass() -> "void":
    r"""ScXMLReferenceDataObj_initClass()"""
    return _coin.ScXMLReferenceDataObj_initClass()

def ScXMLReferenceDataObj_cleanClass() -> "void":
    r"""ScXMLReferenceDataObj_cleanClass()"""
    return _coin.ScXMLReferenceDataObj_cleanClass()

def ScXMLReferenceDataObj_createFor(reference: "char const *") -> "ScXMLDataObj *":
    r"""ScXMLReferenceDataObj_createFor(char const * reference) -> ScXMLDataObj"""
    return _coin.ScXMLReferenceDataObj_createFor(reference)

class ScXMLAndOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLAndOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLAndOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLAndOpExprDataObj self) -> SoType"""
        return _coin.ScXMLAndOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLAndOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLAndOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLAndOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLAndOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLAndOpExprDataObj self) -> ScXMLAndOpExprDataObj
        __init__(ScXMLAndOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLAndOpExprDataObj
        """
        _coin.ScXMLAndOpExprDataObj_swiginit(self, _coin.new_ScXMLAndOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLAndOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLAndOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLAndOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLAndOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLAndOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLAndOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLAndOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLAndOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLAndOpExprDataObj_getRHS(self)

# Register ScXMLAndOpExprDataObj in _coin:
_coin.ScXMLAndOpExprDataObj_swigregister(ScXMLAndOpExprDataObj)

def ScXMLAndOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLAndOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLAndOpExprDataObj_getClassTypeId()

def ScXMLAndOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLAndOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLAndOpExprDataObj_createInstance()

def ScXMLAndOpExprDataObj_initClass() -> "void":
    r"""ScXMLAndOpExprDataObj_initClass()"""
    return _coin.ScXMLAndOpExprDataObj_initClass()

def ScXMLAndOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLAndOpExprDataObj_cleanClass()"""
    return _coin.ScXMLAndOpExprDataObj_cleanClass()

def ScXMLAndOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLAndOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLAndOpExprDataObj_createFor(lhs, rhs)

class ScXMLOrOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLOrOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLOrOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLOrOpExprDataObj self) -> SoType"""
        return _coin.ScXMLOrOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLOrOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLOrOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLOrOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLOrOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLOrOpExprDataObj self) -> ScXMLOrOpExprDataObj
        __init__(ScXMLOrOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLOrOpExprDataObj
        """
        _coin.ScXMLOrOpExprDataObj_swiginit(self, _coin.new_ScXMLOrOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLOrOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLOrOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLOrOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLOrOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLOrOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLOrOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLOrOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLOrOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLOrOpExprDataObj_getRHS(self)

# Register ScXMLOrOpExprDataObj in _coin:
_coin.ScXMLOrOpExprDataObj_swigregister(ScXMLOrOpExprDataObj)

def ScXMLOrOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLOrOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLOrOpExprDataObj_getClassTypeId()

def ScXMLOrOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLOrOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLOrOpExprDataObj_createInstance()

def ScXMLOrOpExprDataObj_initClass() -> "void":
    r"""ScXMLOrOpExprDataObj_initClass()"""
    return _coin.ScXMLOrOpExprDataObj_initClass()

def ScXMLOrOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLOrOpExprDataObj_cleanClass()"""
    return _coin.ScXMLOrOpExprDataObj_cleanClass()

def ScXMLOrOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLOrOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLOrOpExprDataObj_createFor(lhs, rhs)

class ScXMLNotOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLNotOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLNotOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLNotOpExprDataObj self) -> SoType"""
        return _coin.ScXMLNotOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLNotOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLNotOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLNotOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLNotOpExprDataObj_createFor(rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLNotOpExprDataObj self) -> ScXMLNotOpExprDataObj
        __init__(ScXMLNotOpExprDataObj self, ScXMLDataObj rhs) -> ScXMLNotOpExprDataObj
        """
        _coin.ScXMLNotOpExprDataObj_swiginit(self, _coin.new_ScXMLNotOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLNotOpExprDataObj

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLNotOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLNotOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLNotOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLNotOpExprDataObj_getRHS(self)

# Register ScXMLNotOpExprDataObj in _coin:
_coin.ScXMLNotOpExprDataObj_swigregister(ScXMLNotOpExprDataObj)

def ScXMLNotOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLNotOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLNotOpExprDataObj_getClassTypeId()

def ScXMLNotOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLNotOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLNotOpExprDataObj_createInstance()

def ScXMLNotOpExprDataObj_initClass() -> "void":
    r"""ScXMLNotOpExprDataObj_initClass()"""
    return _coin.ScXMLNotOpExprDataObj_initClass()

def ScXMLNotOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLNotOpExprDataObj_cleanClass()"""
    return _coin.ScXMLNotOpExprDataObj_cleanClass()

def ScXMLNotOpExprDataObj_createFor(rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLNotOpExprDataObj_createFor(ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLNotOpExprDataObj_createFor(rhs)

class ScXMLEqualsOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLEqualsOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLEqualsOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLEqualsOpExprDataObj self) -> SoType"""
        return _coin.ScXMLEqualsOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLEqualsOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLEqualsOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLEqualsOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLEqualsOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLEqualsOpExprDataObj self) -> ScXMLEqualsOpExprDataObj
        __init__(ScXMLEqualsOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLEqualsOpExprDataObj
        """
        _coin.ScXMLEqualsOpExprDataObj_swiginit(self, _coin.new_ScXMLEqualsOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLEqualsOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLEqualsOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLEqualsOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLEqualsOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLEqualsOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLEqualsOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLEqualsOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLEqualsOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLEqualsOpExprDataObj_getRHS(self)

# Register ScXMLEqualsOpExprDataObj in _coin:
_coin.ScXMLEqualsOpExprDataObj_swigregister(ScXMLEqualsOpExprDataObj)

def ScXMLEqualsOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLEqualsOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLEqualsOpExprDataObj_getClassTypeId()

def ScXMLEqualsOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLEqualsOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLEqualsOpExprDataObj_createInstance()

def ScXMLEqualsOpExprDataObj_initClass() -> "void":
    r"""ScXMLEqualsOpExprDataObj_initClass()"""
    return _coin.ScXMLEqualsOpExprDataObj_initClass()

def ScXMLEqualsOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLEqualsOpExprDataObj_cleanClass()"""
    return _coin.ScXMLEqualsOpExprDataObj_cleanClass()

def ScXMLEqualsOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLEqualsOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLEqualsOpExprDataObj_createFor(lhs, rhs)

class ScXMLAddOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLAddOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLAddOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLAddOpExprDataObj self) -> SoType"""
        return _coin.ScXMLAddOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLAddOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLAddOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLAddOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLAddOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLAddOpExprDataObj self) -> ScXMLAddOpExprDataObj
        __init__(ScXMLAddOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLAddOpExprDataObj
        """
        _coin.ScXMLAddOpExprDataObj_swiginit(self, _coin.new_ScXMLAddOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLAddOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLAddOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLAddOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLAddOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLAddOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLAddOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLAddOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLAddOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLAddOpExprDataObj_getRHS(self)

# Register ScXMLAddOpExprDataObj in _coin:
_coin.ScXMLAddOpExprDataObj_swigregister(ScXMLAddOpExprDataObj)

def ScXMLAddOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLAddOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLAddOpExprDataObj_getClassTypeId()

def ScXMLAddOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLAddOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLAddOpExprDataObj_createInstance()

def ScXMLAddOpExprDataObj_initClass() -> "void":
    r"""ScXMLAddOpExprDataObj_initClass()"""
    return _coin.ScXMLAddOpExprDataObj_initClass()

def ScXMLAddOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLAddOpExprDataObj_cleanClass()"""
    return _coin.ScXMLAddOpExprDataObj_cleanClass()

def ScXMLAddOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLAddOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLAddOpExprDataObj_createFor(lhs, rhs)

class ScXMLSubtractOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLSubtractOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLSubtractOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLSubtractOpExprDataObj self) -> SoType"""
        return _coin.ScXMLSubtractOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLSubtractOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLSubtractOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLSubtractOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLSubtractOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLSubtractOpExprDataObj self) -> ScXMLSubtractOpExprDataObj
        __init__(ScXMLSubtractOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLSubtractOpExprDataObj
        """
        _coin.ScXMLSubtractOpExprDataObj_swiginit(self, _coin.new_ScXMLSubtractOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLSubtractOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLSubtractOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLSubtractOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLSubtractOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLSubtractOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLSubtractOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLSubtractOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLSubtractOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLSubtractOpExprDataObj_getRHS(self)

# Register ScXMLSubtractOpExprDataObj in _coin:
_coin.ScXMLSubtractOpExprDataObj_swigregister(ScXMLSubtractOpExprDataObj)

def ScXMLSubtractOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLSubtractOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLSubtractOpExprDataObj_getClassTypeId()

def ScXMLSubtractOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLSubtractOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLSubtractOpExprDataObj_createInstance()

def ScXMLSubtractOpExprDataObj_initClass() -> "void":
    r"""ScXMLSubtractOpExprDataObj_initClass()"""
    return _coin.ScXMLSubtractOpExprDataObj_initClass()

def ScXMLSubtractOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLSubtractOpExprDataObj_cleanClass()"""
    return _coin.ScXMLSubtractOpExprDataObj_cleanClass()

def ScXMLSubtractOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLSubtractOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLSubtractOpExprDataObj_createFor(lhs, rhs)

class ScXMLMultiplyOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLMultiplyOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLMultiplyOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLMultiplyOpExprDataObj self) -> SoType"""
        return _coin.ScXMLMultiplyOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLMultiplyOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLMultiplyOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLMultiplyOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLMultiplyOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLMultiplyOpExprDataObj self) -> ScXMLMultiplyOpExprDataObj
        __init__(ScXMLMultiplyOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLMultiplyOpExprDataObj
        """
        _coin.ScXMLMultiplyOpExprDataObj_swiginit(self, _coin.new_ScXMLMultiplyOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLMultiplyOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLMultiplyOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLMultiplyOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLMultiplyOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLMultiplyOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLMultiplyOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLMultiplyOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLMultiplyOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLMultiplyOpExprDataObj_getRHS(self)

# Register ScXMLMultiplyOpExprDataObj in _coin:
_coin.ScXMLMultiplyOpExprDataObj_swigregister(ScXMLMultiplyOpExprDataObj)

def ScXMLMultiplyOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLMultiplyOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLMultiplyOpExprDataObj_getClassTypeId()

def ScXMLMultiplyOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLMultiplyOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLMultiplyOpExprDataObj_createInstance()

def ScXMLMultiplyOpExprDataObj_initClass() -> "void":
    r"""ScXMLMultiplyOpExprDataObj_initClass()"""
    return _coin.ScXMLMultiplyOpExprDataObj_initClass()

def ScXMLMultiplyOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLMultiplyOpExprDataObj_cleanClass()"""
    return _coin.ScXMLMultiplyOpExprDataObj_cleanClass()

def ScXMLMultiplyOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLMultiplyOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLMultiplyOpExprDataObj_createFor(lhs, rhs)

class ScXMLDivideOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLDivideOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLDivideOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLDivideOpExprDataObj self) -> SoType"""
        return _coin.ScXMLDivideOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLDivideOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLDivideOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLDivideOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLDivideOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLDivideOpExprDataObj self) -> ScXMLDivideOpExprDataObj
        __init__(ScXMLDivideOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDivideOpExprDataObj
        """
        _coin.ScXMLDivideOpExprDataObj_swiginit(self, _coin.new_ScXMLDivideOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLDivideOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLDivideOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLDivideOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLDivideOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLDivideOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLDivideOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLDivideOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLDivideOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLDivideOpExprDataObj_getRHS(self)

# Register ScXMLDivideOpExprDataObj in _coin:
_coin.ScXMLDivideOpExprDataObj_swigregister(ScXMLDivideOpExprDataObj)

def ScXMLDivideOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLDivideOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLDivideOpExprDataObj_getClassTypeId()

def ScXMLDivideOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLDivideOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLDivideOpExprDataObj_createInstance()

def ScXMLDivideOpExprDataObj_initClass() -> "void":
    r"""ScXMLDivideOpExprDataObj_initClass()"""
    return _coin.ScXMLDivideOpExprDataObj_initClass()

def ScXMLDivideOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLDivideOpExprDataObj_cleanClass()"""
    return _coin.ScXMLDivideOpExprDataObj_cleanClass()

def ScXMLDivideOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLDivideOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLDivideOpExprDataObj_createFor(lhs, rhs)

class ScXMLNegateOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLNegateOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLNegateOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLNegateOpExprDataObj self) -> SoType"""
        return _coin.ScXMLNegateOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLNegateOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLNegateOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLNegateOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLNegateOpExprDataObj_createFor(rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLNegateOpExprDataObj self) -> ScXMLNegateOpExprDataObj
        __init__(ScXMLNegateOpExprDataObj self, ScXMLDataObj rhs) -> ScXMLNegateOpExprDataObj
        """
        _coin.ScXMLNegateOpExprDataObj_swiginit(self, _coin.new_ScXMLNegateOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLNegateOpExprDataObj

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLNegateOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLNegateOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLNegateOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLNegateOpExprDataObj_getRHS(self)

# Register ScXMLNegateOpExprDataObj in _coin:
_coin.ScXMLNegateOpExprDataObj_swigregister(ScXMLNegateOpExprDataObj)

def ScXMLNegateOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLNegateOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLNegateOpExprDataObj_getClassTypeId()

def ScXMLNegateOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLNegateOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLNegateOpExprDataObj_createInstance()

def ScXMLNegateOpExprDataObj_initClass() -> "void":
    r"""ScXMLNegateOpExprDataObj_initClass()"""
    return _coin.ScXMLNegateOpExprDataObj_initClass()

def ScXMLNegateOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLNegateOpExprDataObj_cleanClass()"""
    return _coin.ScXMLNegateOpExprDataObj_cleanClass()

def ScXMLNegateOpExprDataObj_createFor(rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLNegateOpExprDataObj_createFor(ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLNegateOpExprDataObj_createFor(rhs)

class ScXMLCoinEvaluator(ScXMLEvaluator):
    r"""Proxy of C++ ScXMLCoinEvaluator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLCoinEvaluator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLCoinEvaluator self) -> SoType"""
        return _coin.ScXMLCoinEvaluator_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLCoinEvaluator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLCoinEvaluator_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLCoinEvaluator_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLCoinEvaluator self) -> ScXMLCoinEvaluator"""
        _coin.ScXMLCoinEvaluator_swiginit(self, _coin.new_ScXMLCoinEvaluator())
    __swig_destroy__ = _coin.delete_ScXMLCoinEvaluator

    def setStateMachine(self, sm: "ScXMLStateMachine") -> "void":
        r"""setStateMachine(ScXMLCoinEvaluator self, ScXMLStateMachine sm)"""
        return _coin.ScXMLCoinEvaluator_setStateMachine(self, sm)

    def evaluate(self, expression: "char const *") -> "ScXMLDataObj *":
        r"""evaluate(ScXMLCoinEvaluator self, char const * expression) -> ScXMLDataObj"""
        return _coin.ScXMLCoinEvaluator_evaluate(self, expression)

    def setAtLocation(self, location: "char const *", obj: "ScXMLDataObj") -> "SbBool":
        r"""setAtLocation(ScXMLCoinEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"""
        return _coin.ScXMLCoinEvaluator_setAtLocation(self, location, obj)

    def locate(self, location: "char const *") -> "ScXMLDataObj *":
        r"""locate(ScXMLCoinEvaluator self, char const * location) -> ScXMLDataObj"""
        return _coin.ScXMLCoinEvaluator_locate(self, location)

    def clearTemporaryVariables(self) -> "void":
        r"""clearTemporaryVariables(ScXMLCoinEvaluator self)"""
        return _coin.ScXMLCoinEvaluator_clearTemporaryVariables(self)

    def dumpTemporaries(self) -> "void":
        r"""dumpTemporaries(ScXMLCoinEvaluator self)"""
        return _coin.ScXMLCoinEvaluator_dumpTemporaries(self)

# Register ScXMLCoinEvaluator in _coin:
_coin.ScXMLCoinEvaluator_swigregister(ScXMLCoinEvaluator)

def ScXMLCoinEvaluator_getClassTypeId() -> "SoType":
    r"""ScXMLCoinEvaluator_getClassTypeId() -> SoType"""
    return _coin.ScXMLCoinEvaluator_getClassTypeId()

def ScXMLCoinEvaluator_createInstance() -> "void *":
    r"""ScXMLCoinEvaluator_createInstance() -> void *"""
    return _coin.ScXMLCoinEvaluator_createInstance()

def ScXMLCoinEvaluator_initClass() -> "void":
    r"""ScXMLCoinEvaluator_initClass()"""
    return _coin.ScXMLCoinEvaluator_initClass()

def ScXMLCoinEvaluator_cleanClass() -> "void":
    r"""ScXMLCoinEvaluator_cleanClass()"""
    return _coin.ScXMLCoinEvaluator_cleanClass()

class ScXMLCoinEqualsOpExprDataObj(ScXMLEqualsOpExprDataObj):
    r"""Proxy of C++ ScXMLCoinEqualsOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLCoinEqualsOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLCoinEqualsOpExprDataObj self) -> SoType"""
        return _coin.ScXMLCoinEqualsOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLCoinEqualsOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLCoinEqualsOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLCoinEqualsOpExprDataObj_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLCoinEqualsOpExprDataObj self) -> ScXMLCoinEqualsOpExprDataObj"""
        _coin.ScXMLCoinEqualsOpExprDataObj_swiginit(self, _coin.new_ScXMLCoinEqualsOpExprDataObj())
    __swig_destroy__ = _coin.delete_ScXMLCoinEqualsOpExprDataObj

# Register ScXMLCoinEqualsOpExprDataObj in _coin:
_coin.ScXMLCoinEqualsOpExprDataObj_swigregister(ScXMLCoinEqualsOpExprDataObj)

def ScXMLCoinEqualsOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLCoinEqualsOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLCoinEqualsOpExprDataObj_getClassTypeId()

def ScXMLCoinEqualsOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLCoinEqualsOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLCoinEqualsOpExprDataObj_createInstance()

def ScXMLCoinEqualsOpExprDataObj_initClass() -> "void":
    r"""ScXMLCoinEqualsOpExprDataObj_initClass()"""
    return _coin.ScXMLCoinEqualsOpExprDataObj_initClass()

def ScXMLCoinEqualsOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLCoinEqualsOpExprDataObj_cleanClass()"""
    return _coin.ScXMLCoinEqualsOpExprDataObj_cleanClass()

class ScXMLCoinAddOpExprDataObj(ScXMLAddOpExprDataObj):
    r"""Proxy of C++ ScXMLCoinAddOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLCoinAddOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLCoinAddOpExprDataObj self) -> SoType"""
        return _coin.ScXMLCoinAddOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLCoinAddOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLCoinAddOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLCoinAddOpExprDataObj_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLCoinAddOpExprDataObj self) -> ScXMLCoinAddOpExprDataObj"""
        _coin.ScXMLCoinAddOpExprDataObj_swiginit(self, _coin.new_ScXMLCoinAddOpExprDataObj())
    __swig_destroy__ = _coin.delete_ScXMLCoinAddOpExprDataObj

# Register ScXMLCoinAddOpExprDataObj in _coin:
_coin.ScXMLCoinAddOpExprDataObj_swigregister(ScXMLCoinAddOpExprDataObj)

def ScXMLCoinAddOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLCoinAddOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLCoinAddOpExprDataObj_getClassTypeId()

def ScXMLCoinAddOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLCoinAddOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLCoinAddOpExprDataObj_createInstance()

def ScXMLCoinAddOpExprDataObj_initClass() -> "void":
    r"""ScXMLCoinAddOpExprDataObj_initClass()"""
    return _coin.ScXMLCoinAddOpExprDataObj_initClass()

def ScXMLCoinAddOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLCoinAddOpExprDataObj_cleanClass()"""
    return _coin.ScXMLCoinAddOpExprDataObj_cleanClass()

class ScXMLCoinSubtractOpExprDataObj(ScXMLSubtractOpExprDataObj):
    r"""Proxy of C++ ScXMLCoinSubtractOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLCoinSubtractOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLCoinSubtractOpExprDataObj self) -> SoType"""
        return _coin.ScXMLCoinSubtractOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLCoinSubtractOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLCoinSubtractOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLCoinSubtractOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLCoinSubtractOpExprDataObj_createFor(lhs, rhs)

    def __init__(self):
        r"""__init__(ScXMLCoinSubtractOpExprDataObj self) -> ScXMLCoinSubtractOpExprDataObj"""
        _coin.ScXMLCoinSubtractOpExprDataObj_swiginit(self, _coin.new_ScXMLCoinSubtractOpExprDataObj())
    __swig_destroy__ = _coin.delete_ScXMLCoinSubtractOpExprDataObj

# Register ScXMLCoinSubtractOpExprDataObj in _coin:
_coin.ScXMLCoinSubtractOpExprDataObj_swigregister(ScXMLCoinSubtractOpExprDataObj)

def ScXMLCoinSubtractOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLCoinSubtractOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLCoinSubtractOpExprDataObj_getClassTypeId()

def ScXMLCoinSubtractOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLCoinSubtractOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLCoinSubtractOpExprDataObj_createInstance()

def ScXMLCoinSubtractOpExprDataObj_initClass() -> "void":
    r"""ScXMLCoinSubtractOpExprDataObj_initClass()"""
    return _coin.ScXMLCoinSubtractOpExprDataObj_initClass()

def ScXMLCoinSubtractOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLCoinSubtractOpExprDataObj_cleanClass()"""
    return _coin.ScXMLCoinSubtractOpExprDataObj_cleanClass()

def ScXMLCoinSubtractOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLCoinSubtractOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLCoinSubtractOpExprDataObj_createFor(lhs, rhs)

class ScXMLCoinMultiplyOpExprDataObj(ScXMLMultiplyOpExprDataObj):
    r"""Proxy of C++ ScXMLCoinMultiplyOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLCoinMultiplyOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLCoinMultiplyOpExprDataObj self) -> SoType"""
        return _coin.ScXMLCoinMultiplyOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLCoinMultiplyOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLCoinMultiplyOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLCoinMultiplyOpExprDataObj_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLCoinMultiplyOpExprDataObj self) -> ScXMLCoinMultiplyOpExprDataObj"""
        _coin.ScXMLCoinMultiplyOpExprDataObj_swiginit(self, _coin.new_ScXMLCoinMultiplyOpExprDataObj())
    __swig_destroy__ = _coin.delete_ScXMLCoinMultiplyOpExprDataObj

# Register ScXMLCoinMultiplyOpExprDataObj in _coin:
_coin.ScXMLCoinMultiplyOpExprDataObj_swigregister(ScXMLCoinMultiplyOpExprDataObj)

def ScXMLCoinMultiplyOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLCoinMultiplyOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLCoinMultiplyOpExprDataObj_getClassTypeId()

def ScXMLCoinMultiplyOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLCoinMultiplyOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLCoinMultiplyOpExprDataObj_createInstance()

def ScXMLCoinMultiplyOpExprDataObj_initClass() -> "void":
    r"""ScXMLCoinMultiplyOpExprDataObj_initClass()"""
    return _coin.ScXMLCoinMultiplyOpExprDataObj_initClass()

def ScXMLCoinMultiplyOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLCoinMultiplyOpExprDataObj_cleanClass()"""
    return _coin.ScXMLCoinMultiplyOpExprDataObj_cleanClass()

class ScXMLCoinDivideOpExprDataObj(ScXMLDivideOpExprDataObj):
    r"""Proxy of C++ ScXMLCoinDivideOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLCoinDivideOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLCoinDivideOpExprDataObj self) -> SoType"""
        return _coin.ScXMLCoinDivideOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLCoinDivideOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLCoinDivideOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLCoinDivideOpExprDataObj_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLCoinDivideOpExprDataObj self) -> ScXMLCoinDivideOpExprDataObj"""
        _coin.ScXMLCoinDivideOpExprDataObj_swiginit(self, _coin.new_ScXMLCoinDivideOpExprDataObj())
    __swig_destroy__ = _coin.delete_ScXMLCoinDivideOpExprDataObj

# Register ScXMLCoinDivideOpExprDataObj in _coin:
_coin.ScXMLCoinDivideOpExprDataObj_swigregister(ScXMLCoinDivideOpExprDataObj)

def ScXMLCoinDivideOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLCoinDivideOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLCoinDivideOpExprDataObj_getClassTypeId()

def ScXMLCoinDivideOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLCoinDivideOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLCoinDivideOpExprDataObj_createInstance()

def ScXMLCoinDivideOpExprDataObj_initClass() -> "void":
    r"""ScXMLCoinDivideOpExprDataObj_initClass()"""
    return _coin.ScXMLCoinDivideOpExprDataObj_initClass()

def ScXMLCoinDivideOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLCoinDivideOpExprDataObj_cleanClass()"""
    return _coin.ScXMLCoinDivideOpExprDataObj_cleanClass()

class ScXMLCoinLengthFuncExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLCoinLengthFuncExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLCoinLengthFuncExprDataObj self) -> SoType"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_cleanClass()

    @staticmethod
    def createFor(obj: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj obj) -> ScXMLDataObj"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_createFor(obj)

    def __init__(self, *args):
        r"""
        __init__(ScXMLCoinLengthFuncExprDataObj self) -> ScXMLCoinLengthFuncExprDataObj
        __init__(ScXMLCoinLengthFuncExprDataObj self, ScXMLDataObj obj) -> ScXMLCoinLengthFuncExprDataObj
        """
        _coin.ScXMLCoinLengthFuncExprDataObj_swiginit(self, _coin.new_ScXMLCoinLengthFuncExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLCoinLengthFuncExprDataObj

    def setExpr(self, obj: "ScXMLDataObj") -> "void":
        r"""setExpr(ScXMLCoinLengthFuncExprDataObj self, ScXMLDataObj obj)"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_setExpr(self, obj)

    def getExpr(self) -> "ScXMLDataObj *":
        r"""getExpr(ScXMLCoinLengthFuncExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLCoinLengthFuncExprDataObj_getExpr(self)

# Register ScXMLCoinLengthFuncExprDataObj in _coin:
_coin.ScXMLCoinLengthFuncExprDataObj_swigregister(ScXMLCoinLengthFuncExprDataObj)

def ScXMLCoinLengthFuncExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLCoinLengthFuncExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLCoinLengthFuncExprDataObj_getClassTypeId()

def ScXMLCoinLengthFuncExprDataObj_createInstance() -> "void *":
    r"""ScXMLCoinLengthFuncExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLCoinLengthFuncExprDataObj_createInstance()

def ScXMLCoinLengthFuncExprDataObj_initClass() -> "void":
    r"""ScXMLCoinLengthFuncExprDataObj_initClass()"""
    return _coin.ScXMLCoinLengthFuncExprDataObj_initClass()

def ScXMLCoinLengthFuncExprDataObj_cleanClass() -> "void":
    r"""ScXMLCoinLengthFuncExprDataObj_cleanClass()"""
    return _coin.ScXMLCoinLengthFuncExprDataObj_cleanClass()

def ScXMLCoinLengthFuncExprDataObj_createFor(obj: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLCoinLengthFuncExprDataObj_createFor(ScXMLDataObj obj) -> ScXMLDataObj"""
    return _coin.ScXMLCoinLengthFuncExprDataObj_createFor(obj)

class ScXMLContentElt(ScXMLElt):
    r"""Proxy of C++ ScXMLContentElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLContentElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLContentElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLContentElt self) -> SoType"""
        return _coin.ScXMLContentElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLContentElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLContentElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLContentElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLContentElt self) -> ScXMLContentElt"""
        _coin.ScXMLContentElt_swiginit(self, _coin.new_ScXMLContentElt())
    __swig_destroy__ = _coin.delete_ScXMLContentElt

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLContentElt self, ScXMLElt rhs)"""
        return _coin.ScXMLContentElt_copyContents(self, rhs)

# Register ScXMLContentElt in _coin:
_coin.ScXMLContentElt_swigregister(ScXMLContentElt)

def ScXMLContentElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLContentElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLContentElt_getElementReader()

def ScXMLContentElt_getClassTypeId() -> "SoType":
    r"""ScXMLContentElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLContentElt_getClassTypeId()

def ScXMLContentElt_createInstance() -> "void *":
    r"""ScXMLContentElt_createInstance() -> void *"""
    return _coin.ScXMLContentElt_createInstance()

def ScXMLContentElt_initClass() -> "void":
    r"""ScXMLContentElt_initClass()"""
    return _coin.ScXMLContentElt_initClass()

def ScXMLContentElt_cleanClass() -> "void":
    r"""ScXMLContentElt_cleanClass()"""
    return _coin.ScXMLContentElt_cleanClass()

class ScXMLDataElt(ScXMLElt):
    r"""Proxy of C++ ScXMLDataElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLDataElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLDataElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLDataElt self) -> SoType"""
        return _coin.ScXMLDataElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLDataElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLDataElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLDataElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLDataElt self) -> ScXMLDataElt"""
        _coin.ScXMLDataElt_swiginit(self, _coin.new_ScXMLDataElt())
    __swig_destroy__ = _coin.delete_ScXMLDataElt

    def setIDAttribute(self, ID: "char const *") -> "void":
        r"""setIDAttribute(ScXMLDataElt self, char const * ID)"""
        return _coin.ScXMLDataElt_setIDAttribute(self, ID)

    def getIDAttribute(self) -> "char const *":
        r"""getIDAttribute(ScXMLDataElt self) -> char const *"""
        return _coin.ScXMLDataElt_getIDAttribute(self)

    def setSrcAttribute(self, src: "char const *") -> "void":
        r"""setSrcAttribute(ScXMLDataElt self, char const * src)"""
        return _coin.ScXMLDataElt_setSrcAttribute(self, src)

    def getSrcAttribute(self) -> "char const *":
        r"""getSrcAttribute(ScXMLDataElt self) -> char const *"""
        return _coin.ScXMLDataElt_getSrcAttribute(self)

    def setExprAttribute(self, expr: "char const *") -> "void":
        r"""setExprAttribute(ScXMLDataElt self, char const * expr)"""
        return _coin.ScXMLDataElt_setExprAttribute(self, expr)

    def getExprAttribute(self) -> "char const *":
        r"""getExprAttribute(ScXMLDataElt self) -> char const *"""
        return _coin.ScXMLDataElt_getExprAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLDataElt self) -> SbBool"""
        return _coin.ScXMLDataElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLDataElt self, ScXMLElt rhs)"""
        return _coin.ScXMLDataElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLDataElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLDataElt_search(self, attrname, attrvalue)

    def setValueObj(self, value: "ScXMLDataObj") -> "void":
        r"""setValueObj(ScXMLDataElt self, ScXMLDataObj value)"""
        return _coin.ScXMLDataElt_setValueObj(self, value)

    def getValueObj(self) -> "ScXMLDataObj *":
        r"""getValueObj(ScXMLDataElt self) -> ScXMLDataObj"""
        return _coin.ScXMLDataElt_getValueObj(self)

# Register ScXMLDataElt in _coin:
_coin.ScXMLDataElt_swigregister(ScXMLDataElt)

def ScXMLDataElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLDataElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLDataElt_getElementReader()

def ScXMLDataElt_getClassTypeId() -> "SoType":
    r"""ScXMLDataElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLDataElt_getClassTypeId()

def ScXMLDataElt_createInstance() -> "void *":
    r"""ScXMLDataElt_createInstance() -> void *"""
    return _coin.ScXMLDataElt_createInstance()

def ScXMLDataElt_initClass() -> "void":
    r"""ScXMLDataElt_initClass()"""
    return _coin.ScXMLDataElt_initClass()

def ScXMLDataElt_cleanClass() -> "void":
    r"""ScXMLDataElt_cleanClass()"""
    return _coin.ScXMLDataElt_cleanClass()

class ScXMLDataModelElt(ScXMLElt):
    r"""Proxy of C++ ScXMLDataModelElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLDataModelElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLDataModelElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLDataModelElt self) -> SoType"""
        return _coin.ScXMLDataModelElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLDataModelElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLDataModelElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLDataModelElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLDataModelElt self) -> ScXMLDataModelElt"""
        _coin.ScXMLDataModelElt_swiginit(self, _coin.new_ScXMLDataModelElt())
    __swig_destroy__ = _coin.delete_ScXMLDataModelElt

    def setSchemaAttribute(self, schema: "char const *") -> "void":
        r"""setSchemaAttribute(ScXMLDataModelElt self, char const * schema)"""
        return _coin.ScXMLDataModelElt_setSchemaAttribute(self, schema)

    def getSchemaAttribute(self) -> "char const *":
        r"""getSchemaAttribute(ScXMLDataModelElt self) -> char const *"""
        return _coin.ScXMLDataModelElt_getSchemaAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLDataModelElt self) -> SbBool"""
        return _coin.ScXMLDataModelElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLDataModelElt self, ScXMLElt rhs)"""
        return _coin.ScXMLDataModelElt_copyContents(self, rhs)

    def getNumData(self) -> "int":
        r"""getNumData(ScXMLDataModelElt self) -> int"""
        return _coin.ScXMLDataModelElt_getNumData(self)

    def getData(self, idx: "int") -> "ScXMLDataElt *":
        r"""getData(ScXMLDataModelElt self, int idx) -> ScXMLDataElt"""
        return _coin.ScXMLDataModelElt_getData(self, idx)

    def addData(self, data: "ScXMLDataElt") -> "void":
        r"""addData(ScXMLDataModelElt self, ScXMLDataElt data)"""
        return _coin.ScXMLDataModelElt_addData(self, data)

    def removeData(self, data: "ScXMLDataElt") -> "void":
        r"""removeData(ScXMLDataModelElt self, ScXMLDataElt data)"""
        return _coin.ScXMLDataModelElt_removeData(self, data)

    def clearAllData(self) -> "void":
        r"""clearAllData(ScXMLDataModelElt self)"""
        return _coin.ScXMLDataModelElt_clearAllData(self)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLDataModelElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLDataModelElt_search(self, attrname, attrvalue)

# Register ScXMLDataModelElt in _coin:
_coin.ScXMLDataModelElt_swigregister(ScXMLDataModelElt)

def ScXMLDataModelElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLDataModelElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLDataModelElt_getElementReader()

def ScXMLDataModelElt_getClassTypeId() -> "SoType":
    r"""ScXMLDataModelElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLDataModelElt_getClassTypeId()

def ScXMLDataModelElt_createInstance() -> "void *":
    r"""ScXMLDataModelElt_createInstance() -> void *"""
    return _coin.ScXMLDataModelElt_createInstance()

def ScXMLDataModelElt_initClass() -> "void":
    r"""ScXMLDataModelElt_initClass()"""
    return _coin.ScXMLDataModelElt_initClass()

def ScXMLDataModelElt_cleanClass() -> "void":
    r"""ScXMLDataModelElt_cleanClass()"""
    return _coin.ScXMLDataModelElt_cleanClass()

class ScXMLDocument(ScXMLObject):
    r"""Proxy of C++ ScXMLDocument class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLDocument_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLDocument self) -> SoType"""
        return _coin.ScXMLDocument_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLDocument_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLDocument_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLDocument_cleanClass()

    @staticmethod
    def readFile(filename: "char const *") -> "ScXMLDocument *":
        r"""readFile(char const * filename) -> ScXMLDocument"""
        return _coin.ScXMLDocument_readFile(filename)

    @staticmethod
    def readBuffer(buffer: "SbByteBuffer const &") -> "ScXMLDocument *":
        r"""readBuffer(SbByteBuffer const & buffer) -> ScXMLDocument"""
        return _coin.ScXMLDocument_readBuffer(buffer)

    @staticmethod
    def readXMLData(xmldoc: "cc_xml_doc *") -> "ScXMLDocument *":
        r"""readXMLData(cc_xml_doc * xmldoc) -> ScXMLDocument"""
        return _coin.ScXMLDocument_readXMLData(xmldoc)

    def __init__(self):
        r"""__init__(ScXMLDocument self) -> ScXMLDocument"""
        _coin.ScXMLDocument_swiginit(self, _coin.new_ScXMLDocument())
    __swig_destroy__ = _coin.delete_ScXMLDocument

    def setFilename(self, filename: "char const *") -> "void":
        r"""setFilename(ScXMLDocument self, char const * filename)"""
        return _coin.ScXMLDocument_setFilename(self, filename)

    def getFilename(self) -> "char const *":
        r"""getFilename(ScXMLDocument self) -> char const *"""
        return _coin.ScXMLDocument_getFilename(self)

    def setRoot(self, root: "ScXMLScxmlElt") -> "void":
        r"""setRoot(ScXMLDocument self, ScXMLScxmlElt root)"""
        return _coin.ScXMLDocument_setRoot(self, root)

    def getRoot(self) -> "ScXMLScxmlElt *":
        r"""getRoot(ScXMLDocument self) -> ScXMLScxmlElt"""
        return _coin.ScXMLDocument_getRoot(self)

    def getStateById(self, id: "SbName") -> "ScXMLAbstractStateElt *":
        r"""getStateById(ScXMLDocument self, SbName id) -> ScXMLAbstractStateElt"""
        return _coin.ScXMLDocument_getStateById(self, id)

    def getDataById(self, id: "SbName") -> "ScXMLDataElt *":
        r"""getDataById(ScXMLDocument self, SbName id) -> ScXMLDataElt"""
        return _coin.ScXMLDocument_getDataById(self, id)

# Register ScXMLDocument in _coin:
_coin.ScXMLDocument_swigregister(ScXMLDocument)

def ScXMLDocument_getClassTypeId() -> "SoType":
    r"""ScXMLDocument_getClassTypeId() -> SoType"""
    return _coin.ScXMLDocument_getClassTypeId()

def ScXMLDocument_createInstance() -> "void *":
    r"""ScXMLDocument_createInstance() -> void *"""
    return _coin.ScXMLDocument_createInstance()

def ScXMLDocument_initClass() -> "void":
    r"""ScXMLDocument_initClass()"""
    return _coin.ScXMLDocument_initClass()

def ScXMLDocument_cleanClass() -> "void":
    r"""ScXMLDocument_cleanClass()"""
    return _coin.ScXMLDocument_cleanClass()

def ScXMLDocument_readFile(filename: "char const *") -> "ScXMLDocument *":
    r"""ScXMLDocument_readFile(char const * filename) -> ScXMLDocument"""
    return _coin.ScXMLDocument_readFile(filename)

def ScXMLDocument_readBuffer(buffer: "SbByteBuffer const &") -> "ScXMLDocument *":
    r"""ScXMLDocument_readBuffer(SbByteBuffer const & buffer) -> ScXMLDocument"""
    return _coin.ScXMLDocument_readBuffer(buffer)

def ScXMLDocument_readXMLData(xmldoc: "cc_xml_doc *") -> "ScXMLDocument *":
    r"""ScXMLDocument_readXMLData(cc_xml_doc * xmldoc) -> ScXMLDocument"""
    return _coin.ScXMLDocument_readXMLData(xmldoc)

class ScXMLECMAScriptEvaluator(ScXMLEvaluator):
    r"""Proxy of C++ ScXMLECMAScriptEvaluator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLECMAScriptEvaluator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLECMAScriptEvaluator self) -> SoType"""
        return _coin.ScXMLECMAScriptEvaluator_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLECMAScriptEvaluator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLECMAScriptEvaluator_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLECMAScriptEvaluator_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLECMAScriptEvaluator self) -> ScXMLECMAScriptEvaluator"""
        _coin.ScXMLECMAScriptEvaluator_swiginit(self, _coin.new_ScXMLECMAScriptEvaluator())
    __swig_destroy__ = _coin.delete_ScXMLECMAScriptEvaluator

    def evaluate(self, expression: "char const *") -> "ScXMLDataObj *":
        r"""evaluate(ScXMLECMAScriptEvaluator self, char const * expression) -> ScXMLDataObj"""
        return _coin.ScXMLECMAScriptEvaluator_evaluate(self, expression)

    def setAtLocation(self, location: "char const *", obj: "ScXMLDataObj") -> "SbBool":
        r"""setAtLocation(ScXMLECMAScriptEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"""
        return _coin.ScXMLECMAScriptEvaluator_setAtLocation(self, location, obj)

    def locate(self, location: "char const *") -> "ScXMLDataObj *":
        r"""locate(ScXMLECMAScriptEvaluator self, char const * location) -> ScXMLDataObj"""
        return _coin.ScXMLECMAScriptEvaluator_locate(self, location)

# Register ScXMLECMAScriptEvaluator in _coin:
_coin.ScXMLECMAScriptEvaluator_swigregister(ScXMLECMAScriptEvaluator)

def ScXMLECMAScriptEvaluator_getClassTypeId() -> "SoType":
    r"""ScXMLECMAScriptEvaluator_getClassTypeId() -> SoType"""
    return _coin.ScXMLECMAScriptEvaluator_getClassTypeId()

def ScXMLECMAScriptEvaluator_createInstance() -> "void *":
    r"""ScXMLECMAScriptEvaluator_createInstance() -> void *"""
    return _coin.ScXMLECMAScriptEvaluator_createInstance()

def ScXMLECMAScriptEvaluator_initClass() -> "void":
    r"""ScXMLECMAScriptEvaluator_initClass()"""
    return _coin.ScXMLECMAScriptEvaluator_initClass()

def ScXMLECMAScriptEvaluator_cleanClass() -> "void":
    r"""ScXMLECMAScriptEvaluator_cleanClass()"""
    return _coin.ScXMLECMAScriptEvaluator_cleanClass()

class ScXMLElseElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLElseElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLElseElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLElseElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLElseElt self) -> SoType"""
        return _coin.ScXMLElseElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLElseElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLElseElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLElseElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLElseElt self) -> ScXMLElseElt"""
        _coin.ScXMLElseElt_swiginit(self, _coin.new_ScXMLElseElt())
    __swig_destroy__ = _coin.delete_ScXMLElseElt

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLElseElt self, ScXMLElt rhs)"""
        return _coin.ScXMLElseElt_copyContents(self, rhs)

# Register ScXMLElseElt in _coin:
_coin.ScXMLElseElt_swigregister(ScXMLElseElt)

def ScXMLElseElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLElseElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLElseElt_getElementReader()

def ScXMLElseElt_getClassTypeId() -> "SoType":
    r"""ScXMLElseElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLElseElt_getClassTypeId()

def ScXMLElseElt_createInstance() -> "void *":
    r"""ScXMLElseElt_createInstance() -> void *"""
    return _coin.ScXMLElseElt_createInstance()

def ScXMLElseElt_initClass() -> "void":
    r"""ScXMLElseElt_initClass()"""
    return _coin.ScXMLElseElt_initClass()

def ScXMLElseElt_cleanClass() -> "void":
    r"""ScXMLElseElt_cleanClass()"""
    return _coin.ScXMLElseElt_cleanClass()

class ScXMLElseIfElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLElseIfElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLElseIfElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLElseIfElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLElseIfElt self) -> SoType"""
        return _coin.ScXMLElseIfElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLElseIfElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLElseIfElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLElseIfElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLElseIfElt self) -> ScXMLElseIfElt"""
        _coin.ScXMLElseIfElt_swiginit(self, _coin.new_ScXMLElseIfElt())
    __swig_destroy__ = _coin.delete_ScXMLElseIfElt

    def setCondAttribute(self, cond: "char const *") -> "void":
        r"""setCondAttribute(ScXMLElseIfElt self, char const * cond)"""
        return _coin.ScXMLElseIfElt_setCondAttribute(self, cond)

    def getCondAttribute(self) -> "char const *":
        r"""getCondAttribute(ScXMLElseIfElt self) -> char const *"""
        return _coin.ScXMLElseIfElt_getCondAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLElseIfElt self) -> SbBool"""
        return _coin.ScXMLElseIfElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLElseIfElt self, ScXMLElt rhs)"""
        return _coin.ScXMLElseIfElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLElseIfElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLElseIfElt_search(self, attrname, attrvalue)

# Register ScXMLElseIfElt in _coin:
_coin.ScXMLElseIfElt_swigregister(ScXMLElseIfElt)

def ScXMLElseIfElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLElseIfElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLElseIfElt_getElementReader()

def ScXMLElseIfElt_getClassTypeId() -> "SoType":
    r"""ScXMLElseIfElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLElseIfElt_getClassTypeId()

def ScXMLElseIfElt_createInstance() -> "void *":
    r"""ScXMLElseIfElt_createInstance() -> void *"""
    return _coin.ScXMLElseIfElt_createInstance()

def ScXMLElseIfElt_initClass() -> "void":
    r"""ScXMLElseIfElt_initClass()"""
    return _coin.ScXMLElseIfElt_initClass()

def ScXMLElseIfElt_cleanClass() -> "void":
    r"""ScXMLElseIfElt_cleanClass()"""
    return _coin.ScXMLElseIfElt_cleanClass()

class ScXMLEvent(ScXMLObject):
    r"""Proxy of C++ ScXMLEvent class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLEvent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLEvent self) -> SoType"""
        return _coin.ScXMLEvent_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLEvent_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLEvent_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLEvent_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLEvent self) -> ScXMLEvent"""
        _coin.ScXMLEvent_swiginit(self, _coin.new_ScXMLEvent())
    __swig_destroy__ = _coin.delete_ScXMLEvent

    def setEventName(self, name: "SbName") -> "void":
        r"""setEventName(ScXMLEvent self, SbName name)"""
        return _coin.ScXMLEvent_setEventName(self, name)

    def getEventName(self) -> "SbName const &":
        r"""getEventName(ScXMLEvent self) -> SbName"""
        return _coin.ScXMLEvent_getEventName(self)

    def clone(self) -> "ScXMLEvent *":
        r"""clone(ScXMLEvent self) -> ScXMLEvent"""
        return _coin.ScXMLEvent_clone(self)

    def setAssociation(self, key: "char const *", value: "char const *") -> "void":
        r"""setAssociation(ScXMLEvent self, char const * key, char const * value)"""
        return _coin.ScXMLEvent_setAssociation(self, key, value)

    def getAssociation(self, key: "char const *") -> "char const *":
        r"""getAssociation(ScXMLEvent self, char const * key) -> char const *"""
        return _coin.ScXMLEvent_getAssociation(self, key)

    def getNumAssociations(self) -> "size_t":
        r"""getNumAssociations(ScXMLEvent self) -> size_t"""
        return _coin.ScXMLEvent_getNumAssociations(self)

    def getAssociationKeys(self, keys: "SbList< char const * > &") -> "size_t":
        r"""getAssociationKeys(ScXMLEvent self, SbList< char const * > & keys) -> size_t"""
        return _coin.ScXMLEvent_getAssociationKeys(self, keys)

# Register ScXMLEvent in _coin:
_coin.ScXMLEvent_swigregister(ScXMLEvent)

def ScXMLEvent_getClassTypeId() -> "SoType":
    r"""ScXMLEvent_getClassTypeId() -> SoType"""
    return _coin.ScXMLEvent_getClassTypeId()

def ScXMLEvent_createInstance() -> "void *":
    r"""ScXMLEvent_createInstance() -> void *"""
    return _coin.ScXMLEvent_createInstance()

def ScXMLEvent_initClass() -> "void":
    r"""ScXMLEvent_initClass()"""
    return _coin.ScXMLEvent_initClass()

def ScXMLEvent_cleanClass() -> "void":
    r"""ScXMLEvent_cleanClass()"""
    return _coin.ScXMLEvent_cleanClass()

class ScXMLEventElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLEventElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLEventElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLEventElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLEventElt self) -> SoType"""
        return _coin.ScXMLEventElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLEventElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLEventElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLEventElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLEventElt self) -> ScXMLEventElt"""
        _coin.ScXMLEventElt_swiginit(self, _coin.new_ScXMLEventElt())
    __swig_destroy__ = _coin.delete_ScXMLEventElt

    def setNameAttribute(self, name: "char const *") -> "void":
        r"""setNameAttribute(ScXMLEventElt self, char const * name)"""
        return _coin.ScXMLEventElt_setNameAttribute(self, name)

    def getNameAttribute(self) -> "char const *":
        r"""getNameAttribute(ScXMLEventElt self) -> char const *"""
        return _coin.ScXMLEventElt_getNameAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLEventElt self) -> SbBool"""
        return _coin.ScXMLEventElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLEventElt self, ScXMLElt rhs)"""
        return _coin.ScXMLEventElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLEventElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLEventElt_search(self, attrname, attrvalue)

    def createEvent(self, host: "ScXMLEventTarget") -> "ScXMLEvent *":
        r"""createEvent(ScXMLEventElt self, ScXMLEventTarget host) -> ScXMLEvent"""
        return _coin.ScXMLEventElt_createEvent(self, host)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLEventElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLEventElt_execute(self, statemachine)

# Register ScXMLEventElt in _coin:
_coin.ScXMLEventElt_swigregister(ScXMLEventElt)

def ScXMLEventElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLEventElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLEventElt_getElementReader()

def ScXMLEventElt_getClassTypeId() -> "SoType":
    r"""ScXMLEventElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLEventElt_getClassTypeId()

def ScXMLEventElt_createInstance() -> "void *":
    r"""ScXMLEventElt_createInstance() -> void *"""
    return _coin.ScXMLEventElt_createInstance()

def ScXMLEventElt_initClass() -> "void":
    r"""ScXMLEventElt_initClass()"""
    return _coin.ScXMLEventElt_initClass()

def ScXMLEventElt_cleanClass() -> "void":
    r"""ScXMLEventElt_cleanClass()"""
    return _coin.ScXMLEventElt_cleanClass()

class ScXMLFinalElt(ScXMLAbstractStateElt):
    r"""Proxy of C++ ScXMLFinalElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLFinalElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLFinalElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLFinalElt self) -> SoType"""
        return _coin.ScXMLFinalElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLFinalElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLFinalElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLFinalElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLFinalElt self) -> ScXMLFinalElt"""
        _coin.ScXMLFinalElt_swiginit(self, _coin.new_ScXMLFinalElt())
    __swig_destroy__ = _coin.delete_ScXMLFinalElt

    def setOnEntry(self, onentry: "ScXMLOnEntryElt") -> "void":
        r"""setOnEntry(ScXMLFinalElt self, ScXMLOnEntryElt onentry)"""
        return _coin.ScXMLFinalElt_setOnEntry(self, onentry)

    def getOnEntry(self) -> "ScXMLOnEntryElt *":
        r"""getOnEntry(ScXMLFinalElt self) -> ScXMLOnEntryElt"""
        return _coin.ScXMLFinalElt_getOnEntry(self)

    def setOnExit(self, onexit: "ScXMLOnExitElt") -> "void":
        r"""setOnExit(ScXMLFinalElt self, ScXMLOnExitElt onexit)"""
        return _coin.ScXMLFinalElt_setOnExit(self, onexit)

    def getOnExit(self) -> "ScXMLOnExitElt *":
        r"""getOnExit(ScXMLFinalElt self) -> ScXMLOnExitElt"""
        return _coin.ScXMLFinalElt_getOnExit(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLFinalElt self, ScXMLElt rhs)"""
        return _coin.ScXMLFinalElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLFinalElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLFinalElt_search(self, attrname, attrvalue)

# Register ScXMLFinalElt in _coin:
_coin.ScXMLFinalElt_swigregister(ScXMLFinalElt)

def ScXMLFinalElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLFinalElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLFinalElt_getElementReader()

def ScXMLFinalElt_getClassTypeId() -> "SoType":
    r"""ScXMLFinalElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLFinalElt_getClassTypeId()

def ScXMLFinalElt_createInstance() -> "void *":
    r"""ScXMLFinalElt_createInstance() -> void *"""
    return _coin.ScXMLFinalElt_createInstance()

def ScXMLFinalElt_initClass() -> "void":
    r"""ScXMLFinalElt_initClass()"""
    return _coin.ScXMLFinalElt_initClass()

def ScXMLFinalElt_cleanClass() -> "void":
    r"""ScXMLFinalElt_cleanClass()"""
    return _coin.ScXMLFinalElt_cleanClass()

class ScXMLFinalizeElt(ScXMLElt):
    r"""Proxy of C++ ScXMLFinalizeElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLFinalizeElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLFinalizeElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLFinalizeElt self) -> SoType"""
        return _coin.ScXMLFinalizeElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLFinalizeElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLFinalizeElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLFinalizeElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLFinalizeElt self) -> ScXMLFinalizeElt"""
        _coin.ScXMLFinalizeElt_swiginit(self, _coin.new_ScXMLFinalizeElt())
    __swig_destroy__ = _coin.delete_ScXMLFinalizeElt

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLFinalizeElt self, ScXMLElt rhs)"""
        return _coin.ScXMLFinalizeElt_copyContents(self, rhs)

# Register ScXMLFinalizeElt in _coin:
_coin.ScXMLFinalizeElt_swigregister(ScXMLFinalizeElt)

def ScXMLFinalizeElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLFinalizeElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLFinalizeElt_getElementReader()

def ScXMLFinalizeElt_getClassTypeId() -> "SoType":
    r"""ScXMLFinalizeElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLFinalizeElt_getClassTypeId()

def ScXMLFinalizeElt_createInstance() -> "void *":
    r"""ScXMLFinalizeElt_createInstance() -> void *"""
    return _coin.ScXMLFinalizeElt_createInstance()

def ScXMLFinalizeElt_initClass() -> "void":
    r"""ScXMLFinalizeElt_initClass()"""
    return _coin.ScXMLFinalizeElt_initClass()

def ScXMLFinalizeElt_cleanClass() -> "void":
    r"""ScXMLFinalizeElt_cleanClass()"""
    return _coin.ScXMLFinalizeElt_cleanClass()

class ScXMLHistoryElt(ScXMLElt):
    r"""Proxy of C++ ScXMLHistoryElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLHistoryElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLHistoryElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLHistoryElt self) -> SoType"""
        return _coin.ScXMLHistoryElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLHistoryElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLHistoryElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLHistoryElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLHistoryElt self) -> ScXMLHistoryElt"""
        _coin.ScXMLHistoryElt_swiginit(self, _coin.new_ScXMLHistoryElt())
    __swig_destroy__ = _coin.delete_ScXMLHistoryElt

    def setIdAttribute(self, id: "char const *") -> "void":
        r"""setIdAttribute(ScXMLHistoryElt self, char const * id)"""
        return _coin.ScXMLHistoryElt_setIdAttribute(self, id)

    def getIdAttribute(self) -> "char const *":
        r"""getIdAttribute(ScXMLHistoryElt self) -> char const *"""
        return _coin.ScXMLHistoryElt_getIdAttribute(self)

    def setTypeAttribute(self, type: "char const *") -> "void":
        r"""setTypeAttribute(ScXMLHistoryElt self, char const * type)"""
        return _coin.ScXMLHistoryElt_setTypeAttribute(self, type)

    def getTypeAttribute(self) -> "char const *":
        r"""getTypeAttribute(ScXMLHistoryElt self) -> char const *"""
        return _coin.ScXMLHistoryElt_getTypeAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLHistoryElt self) -> SbBool"""
        return _coin.ScXMLHistoryElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLHistoryElt self, ScXMLElt rhs)"""
        return _coin.ScXMLHistoryElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLHistoryElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLHistoryElt_search(self, attrname, attrvalue)

    def setTransition(self, transition: "ScXMLTransitionElt") -> "void":
        r"""setTransition(ScXMLHistoryElt self, ScXMLTransitionElt transition)"""
        return _coin.ScXMLHistoryElt_setTransition(self, transition)

    def getTransition(self) -> "ScXMLTransitionElt *":
        r"""getTransition(ScXMLHistoryElt self) -> ScXMLTransitionElt"""
        return _coin.ScXMLHistoryElt_getTransition(self)

# Register ScXMLHistoryElt in _coin:
_coin.ScXMLHistoryElt_swigregister(ScXMLHistoryElt)

def ScXMLHistoryElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLHistoryElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLHistoryElt_getElementReader()

def ScXMLHistoryElt_getClassTypeId() -> "SoType":
    r"""ScXMLHistoryElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLHistoryElt_getClassTypeId()

def ScXMLHistoryElt_createInstance() -> "void *":
    r"""ScXMLHistoryElt_createInstance() -> void *"""
    return _coin.ScXMLHistoryElt_createInstance()

def ScXMLHistoryElt_initClass() -> "void":
    r"""ScXMLHistoryElt_initClass()"""
    return _coin.ScXMLHistoryElt_initClass()

def ScXMLHistoryElt_cleanClass() -> "void":
    r"""ScXMLHistoryElt_cleanClass()"""
    return _coin.ScXMLHistoryElt_cleanClass()

class ScXMLIfElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLIfElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLIfElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLIfElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLIfElt self) -> SoType"""
        return _coin.ScXMLIfElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLIfElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLIfElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLIfElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLIfElt self) -> ScXMLIfElt"""
        _coin.ScXMLIfElt_swiginit(self, _coin.new_ScXMLIfElt())
    __swig_destroy__ = _coin.delete_ScXMLIfElt

    def setCondAttribute(self, cond: "char const *") -> "void":
        r"""setCondAttribute(ScXMLIfElt self, char const * cond)"""
        return _coin.ScXMLIfElt_setCondAttribute(self, cond)

    def getCondAttribute(self) -> "char const *":
        r"""getCondAttribute(ScXMLIfElt self) -> char const *"""
        return _coin.ScXMLIfElt_getCondAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLIfElt self) -> SbBool"""
        return _coin.ScXMLIfElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLIfElt self, ScXMLElt rhs)"""
        return _coin.ScXMLIfElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLIfElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLIfElt_search(self, attrname, attrvalue)

    def getNumElseIfs(self) -> "int":
        r"""getNumElseIfs(ScXMLIfElt self) -> int"""
        return _coin.ScXMLIfElt_getNumElseIfs(self)

    def getElseIf(self, idx: "int") -> "ScXMLElseIfElt *":
        r"""getElseIf(ScXMLIfElt self, int idx) -> ScXMLElseIfElt"""
        return _coin.ScXMLIfElt_getElseIf(self, idx)

    def addElseIf(self, elseif: "ScXMLElseIfElt") -> "void":
        r"""addElseIf(ScXMLIfElt self, ScXMLElseIfElt elseif)"""
        return _coin.ScXMLIfElt_addElseIf(self, elseif)

    def removeElseIf(self, elseif: "ScXMLElseIfElt") -> "void":
        r"""removeElseIf(ScXMLIfElt self, ScXMLElseIfElt elseif)"""
        return _coin.ScXMLIfElt_removeElseIf(self, elseif)

    def clearAllElseIfs(self) -> "void":
        r"""clearAllElseIfs(ScXMLIfElt self)"""
        return _coin.ScXMLIfElt_clearAllElseIfs(self)

    def setElse(self, elseelt: "ScXMLElseElt") -> "void":
        r"""setElse(ScXMLIfElt self, ScXMLElseElt elseelt)"""
        return _coin.ScXMLIfElt_setElse(self, elseelt)

    def getElse(self) -> "ScXMLElseElt *":
        r"""getElse(ScXMLIfElt self) -> ScXMLElseElt"""
        return _coin.ScXMLIfElt_getElse(self)

    def getNumExecutables(self, conditional: "ScXMLExecutableElt") -> "int":
        r"""getNumExecutables(ScXMLIfElt self, ScXMLExecutableElt conditional) -> int"""
        return _coin.ScXMLIfElt_getNumExecutables(self, conditional)

    def getExecutable(self, conditional: "ScXMLExecutableElt", idx: "int") -> "ScXMLExecutableElt *":
        r"""getExecutable(ScXMLIfElt self, ScXMLExecutableElt conditional, int idx) -> ScXMLExecutableElt"""
        return _coin.ScXMLIfElt_getExecutable(self, conditional, idx)

    def addExecutable(self, conditional: "ScXMLExecutableElt", executable: "ScXMLExecutableElt") -> "void":
        r"""addExecutable(ScXMLIfElt self, ScXMLExecutableElt conditional, ScXMLExecutableElt executable)"""
        return _coin.ScXMLIfElt_addExecutable(self, conditional, executable)

    def removeExecutable(self, conditional: "ScXMLExecutableElt", executable: "ScXMLExecutableElt") -> "void":
        r"""removeExecutable(ScXMLIfElt self, ScXMLExecutableElt conditional, ScXMLExecutableElt executable)"""
        return _coin.ScXMLIfElt_removeExecutable(self, conditional, executable)

    def clearAllExecutables(self, conditional: "ScXMLExecutableElt") -> "void":
        r"""clearAllExecutables(ScXMLIfElt self, ScXMLExecutableElt conditional)"""
        return _coin.ScXMLIfElt_clearAllExecutables(self, conditional)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLIfElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLIfElt_execute(self, statemachine)

# Register ScXMLIfElt in _coin:
_coin.ScXMLIfElt_swigregister(ScXMLIfElt)

def ScXMLIfElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLIfElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLIfElt_getElementReader()

def ScXMLIfElt_getClassTypeId() -> "SoType":
    r"""ScXMLIfElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLIfElt_getClassTypeId()

def ScXMLIfElt_createInstance() -> "void *":
    r"""ScXMLIfElt_createInstance() -> void *"""
    return _coin.ScXMLIfElt_createInstance()

def ScXMLIfElt_initClass() -> "void":
    r"""ScXMLIfElt_initClass()"""
    return _coin.ScXMLIfElt_initClass()

def ScXMLIfElt_cleanClass() -> "void":
    r"""ScXMLIfElt_cleanClass()"""
    return _coin.ScXMLIfElt_cleanClass()

class ScXMLInitialElt(ScXMLElt):
    r"""Proxy of C++ ScXMLInitialElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLInitialElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLInitialElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLInitialElt self) -> SoType"""
        return _coin.ScXMLInitialElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLInitialElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLInitialElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLInitialElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLInitialElt self) -> ScXMLInitialElt"""
        _coin.ScXMLInitialElt_swiginit(self, _coin.new_ScXMLInitialElt())
    __swig_destroy__ = _coin.delete_ScXMLInitialElt

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLInitialElt self, ScXMLElt rhs)"""
        return _coin.ScXMLInitialElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLInitialElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLInitialElt_search(self, attrname, attrvalue)

    def setTransition(self, transition: "ScXMLTransitionElt") -> "void":
        r"""setTransition(ScXMLInitialElt self, ScXMLTransitionElt transition)"""
        return _coin.ScXMLInitialElt_setTransition(self, transition)

    def getTransition(self) -> "ScXMLTransitionElt *":
        r"""getTransition(ScXMLInitialElt self) -> ScXMLTransitionElt"""
        return _coin.ScXMLInitialElt_getTransition(self)

# Register ScXMLInitialElt in _coin:
_coin.ScXMLInitialElt_swigregister(ScXMLInitialElt)

def ScXMLInitialElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLInitialElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLInitialElt_getElementReader()

def ScXMLInitialElt_getClassTypeId() -> "SoType":
    r"""ScXMLInitialElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLInitialElt_getClassTypeId()

def ScXMLInitialElt_createInstance() -> "void *":
    r"""ScXMLInitialElt_createInstance() -> void *"""
    return _coin.ScXMLInitialElt_createInstance()

def ScXMLInitialElt_initClass() -> "void":
    r"""ScXMLInitialElt_initClass()"""
    return _coin.ScXMLInitialElt_initClass()

def ScXMLInitialElt_cleanClass() -> "void":
    r"""ScXMLInitialElt_cleanClass()"""
    return _coin.ScXMLInitialElt_cleanClass()

class ScXMLInvokeElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLInvokeElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLInvokeElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLInvokeElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLInvokeElt self) -> SoType"""
        return _coin.ScXMLInvokeElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLInvokeElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLInvokeElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLInvokeElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLInvokeElt self) -> ScXMLInvokeElt"""
        _coin.ScXMLInvokeElt_swiginit(self, _coin.new_ScXMLInvokeElt())
    __swig_destroy__ = _coin.delete_ScXMLInvokeElt

    def setTargetTypeAttribute(self, id: "char const *") -> "void":
        r"""setTargetTypeAttribute(ScXMLInvokeElt self, char const * id)"""
        return _coin.ScXMLInvokeElt_setTargetTypeAttribute(self, id)

    def getTargetTypeAttribute(self) -> "char const *":
        r"""getTargetTypeAttribute(ScXMLInvokeElt self) -> char const *"""
        return _coin.ScXMLInvokeElt_getTargetTypeAttribute(self)

    def setSrcAttribute(self, id: "char const *") -> "void":
        r"""setSrcAttribute(ScXMLInvokeElt self, char const * id)"""
        return _coin.ScXMLInvokeElt_setSrcAttribute(self, id)

    def getSrcAttribute(self) -> "char const *":
        r"""getSrcAttribute(ScXMLInvokeElt self) -> char const *"""
        return _coin.ScXMLInvokeElt_getSrcAttribute(self)

    def setSrcExprAttribute(self, id: "char const *") -> "void":
        r"""setSrcExprAttribute(ScXMLInvokeElt self, char const * id)"""
        return _coin.ScXMLInvokeElt_setSrcExprAttribute(self, id)

    def getSrcExprAttribute(self) -> "char const *":
        r"""getSrcExprAttribute(ScXMLInvokeElt self) -> char const *"""
        return _coin.ScXMLInvokeElt_getSrcExprAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLInvokeElt self) -> SbBool"""
        return _coin.ScXMLInvokeElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLInvokeElt self, ScXMLElt rhs)"""
        return _coin.ScXMLInvokeElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLInvokeElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLInvokeElt_search(self, attrname, attrvalue)

    def getNumParams(self) -> "int":
        r"""getNumParams(ScXMLInvokeElt self) -> int"""
        return _coin.ScXMLInvokeElt_getNumParams(self)

    def getParam(self, idx: "int") -> "ScXMLParamElt *":
        r"""getParam(ScXMLInvokeElt self, int idx) -> ScXMLParamElt"""
        return _coin.ScXMLInvokeElt_getParam(self, idx)

    def addParam(self, param: "ScXMLParamElt") -> "void":
        r"""addParam(ScXMLInvokeElt self, ScXMLParamElt param)"""
        return _coin.ScXMLInvokeElt_addParam(self, param)

    def removeParam(self, param: "ScXMLParamElt") -> "void":
        r"""removeParam(ScXMLInvokeElt self, ScXMLParamElt param)"""
        return _coin.ScXMLInvokeElt_removeParam(self, param)

    def clearAllParams(self) -> "void":
        r"""clearAllParams(ScXMLInvokeElt self)"""
        return _coin.ScXMLInvokeElt_clearAllParams(self)

    def setFinalize(self, finalize: "ScXMLFinalizeElt") -> "void":
        r"""setFinalize(ScXMLInvokeElt self, ScXMLFinalizeElt finalize)"""
        return _coin.ScXMLInvokeElt_setFinalize(self, finalize)

    def getFinalize(self) -> "ScXMLFinalizeElt *":
        r"""getFinalize(ScXMLInvokeElt self) -> ScXMLFinalizeElt"""
        return _coin.ScXMLInvokeElt_getFinalize(self)

    def setContent(self, content: "ScXMLContentElt") -> "void":
        r"""setContent(ScXMLInvokeElt self, ScXMLContentElt content)"""
        return _coin.ScXMLInvokeElt_setContent(self, content)

    def getContent(self) -> "ScXMLContentElt *":
        r"""getContent(ScXMLInvokeElt self) -> ScXMLContentElt"""
        return _coin.ScXMLInvokeElt_getContent(self)

# Register ScXMLInvokeElt in _coin:
_coin.ScXMLInvokeElt_swigregister(ScXMLInvokeElt)

def ScXMLInvokeElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLInvokeElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLInvokeElt_getElementReader()

def ScXMLInvokeElt_getClassTypeId() -> "SoType":
    r"""ScXMLInvokeElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLInvokeElt_getClassTypeId()

def ScXMLInvokeElt_createInstance() -> "void *":
    r"""ScXMLInvokeElt_createInstance() -> void *"""
    return _coin.ScXMLInvokeElt_createInstance()

def ScXMLInvokeElt_initClass() -> "void":
    r"""ScXMLInvokeElt_initClass()"""
    return _coin.ScXMLInvokeElt_initClass()

def ScXMLInvokeElt_cleanClass() -> "void":
    r"""ScXMLInvokeElt_cleanClass()"""
    return _coin.ScXMLInvokeElt_cleanClass()

class ScXMLLogElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLLogElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLLogElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLLogElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLLogElt self) -> SoType"""
        return _coin.ScXMLLogElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLLogElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLLogElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLLogElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLLogElt self) -> ScXMLLogElt"""
        _coin.ScXMLLogElt_swiginit(self, _coin.new_ScXMLLogElt())
    __swig_destroy__ = _coin.delete_ScXMLLogElt

    def setLabelAttribute(self, label: "char const *") -> "void":
        r"""setLabelAttribute(ScXMLLogElt self, char const * label)"""
        return _coin.ScXMLLogElt_setLabelAttribute(self, label)

    def getLabelAttribute(self) -> "char const *":
        r"""getLabelAttribute(ScXMLLogElt self) -> char const *"""
        return _coin.ScXMLLogElt_getLabelAttribute(self)

    def setExprAttribute(self, expr: "char const *") -> "void":
        r"""setExprAttribute(ScXMLLogElt self, char const * expr)"""
        return _coin.ScXMLLogElt_setExprAttribute(self, expr)

    def getExprAttribute(self) -> "char const *":
        r"""getExprAttribute(ScXMLLogElt self) -> char const *"""
        return _coin.ScXMLLogElt_getExprAttribute(self)

    def setLevelAttribute(self, level: "char const *") -> "void":
        r"""setLevelAttribute(ScXMLLogElt self, char const * level)"""
        return _coin.ScXMLLogElt_setLevelAttribute(self, level)

    def getLevelAttribute(self) -> "char const *":
        r"""getLevelAttribute(ScXMLLogElt self) -> char const *"""
        return _coin.ScXMLLogElt_getLevelAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLLogElt self) -> SbBool"""
        return _coin.ScXMLLogElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLLogElt self, ScXMLElt rhs)"""
        return _coin.ScXMLLogElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLLogElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLLogElt_search(self, attrname, attrvalue)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLLogElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLLogElt_execute(self, statemachine)

# Register ScXMLLogElt in _coin:
_coin.ScXMLLogElt_swigregister(ScXMLLogElt)

def ScXMLLogElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLLogElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLLogElt_getElementReader()

def ScXMLLogElt_getClassTypeId() -> "SoType":
    r"""ScXMLLogElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLLogElt_getClassTypeId()

def ScXMLLogElt_createInstance() -> "void *":
    r"""ScXMLLogElt_createInstance() -> void *"""
    return _coin.ScXMLLogElt_createInstance()

def ScXMLLogElt_initClass() -> "void":
    r"""ScXMLLogElt_initClass()"""
    return _coin.ScXMLLogElt_initClass()

def ScXMLLogElt_cleanClass() -> "void":
    r"""ScXMLLogElt_cleanClass()"""
    return _coin.ScXMLLogElt_cleanClass()

class ScXMLMinimumEvaluator(ScXMLEvaluator):
    r"""Proxy of C++ ScXMLMinimumEvaluator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLMinimumEvaluator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLMinimumEvaluator self) -> SoType"""
        return _coin.ScXMLMinimumEvaluator_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLMinimumEvaluator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLMinimumEvaluator_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLMinimumEvaluator_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLMinimumEvaluator self) -> ScXMLMinimumEvaluator"""
        _coin.ScXMLMinimumEvaluator_swiginit(self, _coin.new_ScXMLMinimumEvaluator())
    __swig_destroy__ = _coin.delete_ScXMLMinimumEvaluator

    def setStateMachine(self, arg2: "ScXMLStateMachine") -> "void":
        r"""setStateMachine(ScXMLMinimumEvaluator self, ScXMLStateMachine arg2)"""
        return _coin.ScXMLMinimumEvaluator_setStateMachine(self, arg2)

    def evaluate(self, expression: "char const *") -> "ScXMLDataObj *":
        r"""evaluate(ScXMLMinimumEvaluator self, char const * expression) -> ScXMLDataObj"""
        return _coin.ScXMLMinimumEvaluator_evaluate(self, expression)

    def setAtLocation(self, location: "char const *", obj: "ScXMLDataObj") -> "SbBool":
        r"""setAtLocation(ScXMLMinimumEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"""
        return _coin.ScXMLMinimumEvaluator_setAtLocation(self, location, obj)

    def locate(self, location: "char const *") -> "ScXMLDataObj *":
        r"""locate(ScXMLMinimumEvaluator self, char const * location) -> ScXMLDataObj"""
        return _coin.ScXMLMinimumEvaluator_locate(self, location)

    def clearTemporaryVariables(self) -> "void":
        r"""clearTemporaryVariables(ScXMLMinimumEvaluator self)"""
        return _coin.ScXMLMinimumEvaluator_clearTemporaryVariables(self)

# Register ScXMLMinimumEvaluator in _coin:
_coin.ScXMLMinimumEvaluator_swigregister(ScXMLMinimumEvaluator)

def ScXMLMinimumEvaluator_getClassTypeId() -> "SoType":
    r"""ScXMLMinimumEvaluator_getClassTypeId() -> SoType"""
    return _coin.ScXMLMinimumEvaluator_getClassTypeId()

def ScXMLMinimumEvaluator_createInstance() -> "void *":
    r"""ScXMLMinimumEvaluator_createInstance() -> void *"""
    return _coin.ScXMLMinimumEvaluator_createInstance()

def ScXMLMinimumEvaluator_initClass() -> "void":
    r"""ScXMLMinimumEvaluator_initClass()"""
    return _coin.ScXMLMinimumEvaluator_initClass()

def ScXMLMinimumEvaluator_cleanClass() -> "void":
    r"""ScXMLMinimumEvaluator_cleanClass()"""
    return _coin.ScXMLMinimumEvaluator_cleanClass()

class ScXMLMinimumExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLMinimumExprDataObj class."""

    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 getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLMinimumExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLMinimumExprDataObj self) -> SoType"""
        return _coin.ScXMLMinimumExprDataObj_getTypeId(self)

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLMinimumExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLMinimumExprDataObj_cleanClass()
    __swig_destroy__ = _coin.delete_ScXMLMinimumExprDataObj

# Register ScXMLMinimumExprDataObj in _coin:
_coin.ScXMLMinimumExprDataObj_swigregister(ScXMLMinimumExprDataObj)

def ScXMLMinimumExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLMinimumExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLMinimumExprDataObj_getClassTypeId()

def ScXMLMinimumExprDataObj_initClass() -> "void":
    r"""ScXMLMinimumExprDataObj_initClass()"""
    return _coin.ScXMLMinimumExprDataObj_initClass()

def ScXMLMinimumExprDataObj_cleanClass() -> "void":
    r"""ScXMLMinimumExprDataObj_cleanClass()"""
    return _coin.ScXMLMinimumExprDataObj_cleanClass()

class ScXMLInExprDataObj(ScXMLMinimumExprDataObj):
    r"""Proxy of C++ ScXMLInExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLInExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLInExprDataObj self) -> SoType"""
        return _coin.ScXMLInExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLInExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLInExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLInExprDataObj_cleanClass()

    @staticmethod
    def createFor(stateid: "char const *") -> "ScXMLDataObj *":
        r"""createFor(char const * stateid) -> ScXMLDataObj"""
        return _coin.ScXMLInExprDataObj_createFor(stateid)

    def __init__(self, *args):
        r"""
        __init__(ScXMLInExprDataObj self) -> ScXMLInExprDataObj
        __init__(ScXMLInExprDataObj self, char const * stateid) -> ScXMLInExprDataObj
        """
        _coin.ScXMLInExprDataObj_swiginit(self, _coin.new_ScXMLInExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLInExprDataObj

    def setStateId(self, stateid: "char const *") -> "void":
        r"""setStateId(ScXMLInExprDataObj self, char const * stateid)"""
        return _coin.ScXMLInExprDataObj_setStateId(self, stateid)

    def getStateId(self) -> "char const *":
        r"""getStateId(ScXMLInExprDataObj self) -> char const *"""
        return _coin.ScXMLInExprDataObj_getStateId(self)

# Register ScXMLInExprDataObj in _coin:
_coin.ScXMLInExprDataObj_swigregister(ScXMLInExprDataObj)

def ScXMLInExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLInExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLInExprDataObj_getClassTypeId()

def ScXMLInExprDataObj_createInstance() -> "void *":
    r"""ScXMLInExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLInExprDataObj_createInstance()

def ScXMLInExprDataObj_initClass() -> "void":
    r"""ScXMLInExprDataObj_initClass()"""
    return _coin.ScXMLInExprDataObj_initClass()

def ScXMLInExprDataObj_cleanClass() -> "void":
    r"""ScXMLInExprDataObj_cleanClass()"""
    return _coin.ScXMLInExprDataObj_cleanClass()

def ScXMLInExprDataObj_createFor(stateid: "char const *") -> "ScXMLDataObj *":
    r"""ScXMLInExprDataObj_createFor(char const * stateid) -> ScXMLDataObj"""
    return _coin.ScXMLInExprDataObj_createFor(stateid)

class ScXMLAppendOpExprDataObj(ScXMLExprDataObj):
    r"""Proxy of C++ ScXMLAppendOpExprDataObj class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLAppendOpExprDataObj_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLAppendOpExprDataObj self) -> SoType"""
        return _coin.ScXMLAppendOpExprDataObj_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLAppendOpExprDataObj_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLAppendOpExprDataObj_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLAppendOpExprDataObj_cleanClass()

    @staticmethod
    def createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
        r"""createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
        return _coin.ScXMLAppendOpExprDataObj_createFor(lhs, rhs)

    def __init__(self, *args):
        r"""
        __init__(ScXMLAppendOpExprDataObj self) -> ScXMLAppendOpExprDataObj
        __init__(ScXMLAppendOpExprDataObj self, ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLAppendOpExprDataObj
        """
        _coin.ScXMLAppendOpExprDataObj_swiginit(self, _coin.new_ScXMLAppendOpExprDataObj(*args))
    __swig_destroy__ = _coin.delete_ScXMLAppendOpExprDataObj

    def setLHS(self, lhs: "ScXMLDataObj") -> "void":
        r"""setLHS(ScXMLAppendOpExprDataObj self, ScXMLDataObj lhs)"""
        return _coin.ScXMLAppendOpExprDataObj_setLHS(self, lhs)

    def getLHS(self) -> "ScXMLDataObj const *":
        r"""getLHS(ScXMLAppendOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLAppendOpExprDataObj_getLHS(self)

    def setRHS(self, rhs: "ScXMLDataObj") -> "void":
        r"""setRHS(ScXMLAppendOpExprDataObj self, ScXMLDataObj rhs)"""
        return _coin.ScXMLAppendOpExprDataObj_setRHS(self, rhs)

    def getRHS(self) -> "ScXMLDataObj const *":
        r"""getRHS(ScXMLAppendOpExprDataObj self) -> ScXMLDataObj"""
        return _coin.ScXMLAppendOpExprDataObj_getRHS(self)

# Register ScXMLAppendOpExprDataObj in _coin:
_coin.ScXMLAppendOpExprDataObj_swigregister(ScXMLAppendOpExprDataObj)

def ScXMLAppendOpExprDataObj_getClassTypeId() -> "SoType":
    r"""ScXMLAppendOpExprDataObj_getClassTypeId() -> SoType"""
    return _coin.ScXMLAppendOpExprDataObj_getClassTypeId()

def ScXMLAppendOpExprDataObj_createInstance() -> "void *":
    r"""ScXMLAppendOpExprDataObj_createInstance() -> void *"""
    return _coin.ScXMLAppendOpExprDataObj_createInstance()

def ScXMLAppendOpExprDataObj_initClass() -> "void":
    r"""ScXMLAppendOpExprDataObj_initClass()"""
    return _coin.ScXMLAppendOpExprDataObj_initClass()

def ScXMLAppendOpExprDataObj_cleanClass() -> "void":
    r"""ScXMLAppendOpExprDataObj_cleanClass()"""
    return _coin.ScXMLAppendOpExprDataObj_cleanClass()

def ScXMLAppendOpExprDataObj_createFor(lhs: "ScXMLDataObj", rhs: "ScXMLDataObj") -> "ScXMLDataObj *":
    r"""ScXMLAppendOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"""
    return _coin.ScXMLAppendOpExprDataObj_createFor(lhs, rhs)

class ScXMLOnEntryElt(ScXMLElt):
    r"""Proxy of C++ ScXMLOnEntryElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLOnEntryElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLOnEntryElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLOnEntryElt self) -> SoType"""
        return _coin.ScXMLOnEntryElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLOnEntryElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLOnEntryElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLOnEntryElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLOnEntryElt self) -> ScXMLOnEntryElt"""
        _coin.ScXMLOnEntryElt_swiginit(self, _coin.new_ScXMLOnEntryElt())
    __swig_destroy__ = _coin.delete_ScXMLOnEntryElt

    def getNumExecutables(self) -> "int":
        r"""getNumExecutables(ScXMLOnEntryElt self) -> int"""
        return _coin.ScXMLOnEntryElt_getNumExecutables(self)

    def getExecutable(self, idx: "int") -> "ScXMLExecutableElt *":
        r"""getExecutable(ScXMLOnEntryElt self, int idx) -> ScXMLExecutableElt"""
        return _coin.ScXMLOnEntryElt_getExecutable(self, idx)

    def addExecutable(self, exectable: "ScXMLExecutableElt") -> "void":
        r"""addExecutable(ScXMLOnEntryElt self, ScXMLExecutableElt exectable)"""
        return _coin.ScXMLOnEntryElt_addExecutable(self, exectable)

    def removeExecutable(self, exectable: "ScXMLExecutableElt") -> "void":
        r"""removeExecutable(ScXMLOnEntryElt self, ScXMLExecutableElt exectable)"""
        return _coin.ScXMLOnEntryElt_removeExecutable(self, exectable)

    def clearAllExecutables(self) -> "void":
        r"""clearAllExecutables(ScXMLOnEntryElt self)"""
        return _coin.ScXMLOnEntryElt_clearAllExecutables(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLOnEntryElt self, ScXMLElt rhs)"""
        return _coin.ScXMLOnEntryElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLOnEntryElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLOnEntryElt_search(self, attrname, attrvalue)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLOnEntryElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLOnEntryElt_execute(self, statemachine)

# Register ScXMLOnEntryElt in _coin:
_coin.ScXMLOnEntryElt_swigregister(ScXMLOnEntryElt)

def ScXMLOnEntryElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLOnEntryElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLOnEntryElt_getElementReader()

def ScXMLOnEntryElt_getClassTypeId() -> "SoType":
    r"""ScXMLOnEntryElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLOnEntryElt_getClassTypeId()

def ScXMLOnEntryElt_createInstance() -> "void *":
    r"""ScXMLOnEntryElt_createInstance() -> void *"""
    return _coin.ScXMLOnEntryElt_createInstance()

def ScXMLOnEntryElt_initClass() -> "void":
    r"""ScXMLOnEntryElt_initClass()"""
    return _coin.ScXMLOnEntryElt_initClass()

def ScXMLOnEntryElt_cleanClass() -> "void":
    r"""ScXMLOnEntryElt_cleanClass()"""
    return _coin.ScXMLOnEntryElt_cleanClass()

class ScXMLOnExitElt(ScXMLElt):
    r"""Proxy of C++ ScXMLOnExitElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLOnExitElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLOnExitElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLOnExitElt self) -> SoType"""
        return _coin.ScXMLOnExitElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLOnExitElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLOnExitElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLOnExitElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLOnExitElt self) -> ScXMLOnExitElt"""
        _coin.ScXMLOnExitElt_swiginit(self, _coin.new_ScXMLOnExitElt())
    __swig_destroy__ = _coin.delete_ScXMLOnExitElt

    def getNumExecutables(self) -> "int":
        r"""getNumExecutables(ScXMLOnExitElt self) -> int"""
        return _coin.ScXMLOnExitElt_getNumExecutables(self)

    def getExecutable(self, idx: "int") -> "ScXMLExecutableElt *":
        r"""getExecutable(ScXMLOnExitElt self, int idx) -> ScXMLExecutableElt"""
        return _coin.ScXMLOnExitElt_getExecutable(self, idx)

    def addExecutable(self, executable: "ScXMLExecutableElt") -> "void":
        r"""addExecutable(ScXMLOnExitElt self, ScXMLExecutableElt executable)"""
        return _coin.ScXMLOnExitElt_addExecutable(self, executable)

    def removeExecutable(self, executable: "ScXMLExecutableElt") -> "void":
        r"""removeExecutable(ScXMLOnExitElt self, ScXMLExecutableElt executable)"""
        return _coin.ScXMLOnExitElt_removeExecutable(self, executable)

    def clearAllExecutables(self) -> "void":
        r"""clearAllExecutables(ScXMLOnExitElt self)"""
        return _coin.ScXMLOnExitElt_clearAllExecutables(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLOnExitElt self, ScXMLElt rhs)"""
        return _coin.ScXMLOnExitElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLOnExitElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLOnExitElt_search(self, attrname, attrvalue)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLOnExitElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLOnExitElt_execute(self, statemachine)

# Register ScXMLOnExitElt in _coin:
_coin.ScXMLOnExitElt_swigregister(ScXMLOnExitElt)

def ScXMLOnExitElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLOnExitElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLOnExitElt_getElementReader()

def ScXMLOnExitElt_getClassTypeId() -> "SoType":
    r"""ScXMLOnExitElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLOnExitElt_getClassTypeId()

def ScXMLOnExitElt_createInstance() -> "void *":
    r"""ScXMLOnExitElt_createInstance() -> void *"""
    return _coin.ScXMLOnExitElt_createInstance()

def ScXMLOnExitElt_initClass() -> "void":
    r"""ScXMLOnExitElt_initClass()"""
    return _coin.ScXMLOnExitElt_initClass()

def ScXMLOnExitElt_cleanClass() -> "void":
    r"""ScXMLOnExitElt_cleanClass()"""
    return _coin.ScXMLOnExitElt_cleanClass()

class ScXMLParallelElt(ScXMLAbstractStateElt):
    r"""Proxy of C++ ScXMLParallelElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLParallelElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLParallelElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLParallelElt self) -> SoType"""
        return _coin.ScXMLParallelElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLParallelElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLParallelElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLParallelElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLParallelElt self) -> ScXMLParallelElt"""
        _coin.ScXMLParallelElt_swiginit(self, _coin.new_ScXMLParallelElt())
    __swig_destroy__ = _coin.delete_ScXMLParallelElt

    def setSrcAttribute(self, src: "char const *") -> "void":
        r"""setSrcAttribute(ScXMLParallelElt self, char const * src)"""
        return _coin.ScXMLParallelElt_setSrcAttribute(self, src)

    def getSrcAttribute(self) -> "char const *":
        r"""getSrcAttribute(ScXMLParallelElt self) -> char const *"""
        return _coin.ScXMLParallelElt_getSrcAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLParallelElt self) -> SbBool"""
        return _coin.ScXMLParallelElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLParallelElt self, ScXMLElt rhs)"""
        return _coin.ScXMLParallelElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLParallelElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLParallelElt_search(self, attrname, attrvalue)

    def setOnEntry(self, onentry: "ScXMLOnEntryElt") -> "void":
        r"""setOnEntry(ScXMLParallelElt self, ScXMLOnEntryElt onentry)"""
        return _coin.ScXMLParallelElt_setOnEntry(self, onentry)

    def getOnEntry(self) -> "ScXMLOnEntryElt *":
        r"""getOnEntry(ScXMLParallelElt self) -> ScXMLOnEntryElt"""
        return _coin.ScXMLParallelElt_getOnEntry(self)

    def setOnExit(self, onexit: "ScXMLOnExitElt") -> "void":
        r"""setOnExit(ScXMLParallelElt self, ScXMLOnExitElt onexit)"""
        return _coin.ScXMLParallelElt_setOnExit(self, onexit)

    def getOnExit(self) -> "ScXMLOnExitElt *":
        r"""getOnExit(ScXMLParallelElt self) -> ScXMLOnExitElt"""
        return _coin.ScXMLParallelElt_getOnExit(self)

    def getNumTransitions(self) -> "int":
        r"""getNumTransitions(ScXMLParallelElt self) -> int"""
        return _coin.ScXMLParallelElt_getNumTransitions(self)

    def getTransition(self, idx: "int") -> "ScXMLTransitionElt *":
        r"""getTransition(ScXMLParallelElt self, int idx) -> ScXMLTransitionElt"""
        return _coin.ScXMLParallelElt_getTransition(self, idx)

    def addTransition(self, transition: "ScXMLTransitionElt") -> "void":
        r"""addTransition(ScXMLParallelElt self, ScXMLTransitionElt transition)"""
        return _coin.ScXMLParallelElt_addTransition(self, transition)

    def removeTransition(self, transition: "ScXMLTransitionElt") -> "void":
        r"""removeTransition(ScXMLParallelElt self, ScXMLTransitionElt transition)"""
        return _coin.ScXMLParallelElt_removeTransition(self, transition)

    def clearAllTransitions(self) -> "void":
        r"""clearAllTransitions(ScXMLParallelElt self)"""
        return _coin.ScXMLParallelElt_clearAllTransitions(self)

    def setInitial(self, initial: "ScXMLInitialElt") -> "void":
        r"""setInitial(ScXMLParallelElt self, ScXMLInitialElt initial)"""
        return _coin.ScXMLParallelElt_setInitial(self, initial)

    def getInitial(self) -> "ScXMLInitialElt *":
        r"""getInitial(ScXMLParallelElt self) -> ScXMLInitialElt"""
        return _coin.ScXMLParallelElt_getInitial(self)

    def getNumStates(self) -> "int":
        r"""getNumStates(ScXMLParallelElt self) -> int"""
        return _coin.ScXMLParallelElt_getNumStates(self)

    def getState(self, idx: "int") -> "ScXMLStateElt *":
        r"""getState(ScXMLParallelElt self, int idx) -> ScXMLStateElt"""
        return _coin.ScXMLParallelElt_getState(self, idx)

    def addState(self, state: "ScXMLStateElt") -> "void":
        r"""addState(ScXMLParallelElt self, ScXMLStateElt state)"""
        return _coin.ScXMLParallelElt_addState(self, state)

    def removeState(self, state: "ScXMLStateElt") -> "void":
        r"""removeState(ScXMLParallelElt self, ScXMLStateElt state)"""
        return _coin.ScXMLParallelElt_removeState(self, state)

    def clearAllStates(self) -> "void":
        r"""clearAllStates(ScXMLParallelElt self)"""
        return _coin.ScXMLParallelElt_clearAllStates(self)

    def getNumParallels(self) -> "int":
        r"""getNumParallels(ScXMLParallelElt self) -> int"""
        return _coin.ScXMLParallelElt_getNumParallels(self)

    def getParallel(self, idx: "int") -> "ScXMLParallelElt *":
        r"""getParallel(ScXMLParallelElt self, int idx) -> ScXMLParallelElt"""
        return _coin.ScXMLParallelElt_getParallel(self, idx)

    def addParallel(self, state: "ScXMLParallelElt") -> "void":
        r"""addParallel(ScXMLParallelElt self, ScXMLParallelElt state)"""
        return _coin.ScXMLParallelElt_addParallel(self, state)

    def removeParallel(self, state: "ScXMLParallelElt") -> "void":
        r"""removeParallel(ScXMLParallelElt self, ScXMLParallelElt state)"""
        return _coin.ScXMLParallelElt_removeParallel(self, state)

    def clearAllParallels(self) -> "void":
        r"""clearAllParallels(ScXMLParallelElt self)"""
        return _coin.ScXMLParallelElt_clearAllParallels(self)

    def getNumFinals(self) -> "int":
        r"""getNumFinals(ScXMLParallelElt self) -> int"""
        return _coin.ScXMLParallelElt_getNumFinals(self)

    def getFinal(self, idx: "int") -> "ScXMLFinalElt *":
        r"""getFinal(ScXMLParallelElt self, int idx) -> ScXMLFinalElt"""
        return _coin.ScXMLParallelElt_getFinal(self, idx)

    def addFinal(self, state: "ScXMLFinalElt") -> "void":
        r"""addFinal(ScXMLParallelElt self, ScXMLFinalElt state)"""
        return _coin.ScXMLParallelElt_addFinal(self, state)

    def removeFinal(self, state: "ScXMLFinalElt") -> "void":
        r"""removeFinal(ScXMLParallelElt self, ScXMLFinalElt state)"""
        return _coin.ScXMLParallelElt_removeFinal(self, state)

    def clearAllFinals(self) -> "void":
        r"""clearAllFinals(ScXMLParallelElt self)"""
        return _coin.ScXMLParallelElt_clearAllFinals(self)

    def getNumHistories(self) -> "int":
        r"""getNumHistories(ScXMLParallelElt self) -> int"""
        return _coin.ScXMLParallelElt_getNumHistories(self)

    def getHistory(self, idx: "int") -> "ScXMLHistoryElt *":
        r"""getHistory(ScXMLParallelElt self, int idx) -> ScXMLHistoryElt"""
        return _coin.ScXMLParallelElt_getHistory(self, idx)

    def addHistory(self, history: "ScXMLHistoryElt") -> "void":
        r"""addHistory(ScXMLParallelElt self, ScXMLHistoryElt history)"""
        return _coin.ScXMLParallelElt_addHistory(self, history)

    def removeHistory(self, history: "ScXMLHistoryElt") -> "void":
        r"""removeHistory(ScXMLParallelElt self, ScXMLHistoryElt history)"""
        return _coin.ScXMLParallelElt_removeHistory(self, history)

    def clearAllHistories(self) -> "void":
        r"""clearAllHistories(ScXMLParallelElt self)"""
        return _coin.ScXMLParallelElt_clearAllHistories(self)

    def getNumAnchors(self) -> "int":
        r"""getNumAnchors(ScXMLParallelElt self) -> int"""
        return _coin.ScXMLParallelElt_getNumAnchors(self)

    def getAnchor(self, idx: "int") -> "ScXMLAnchorElt *":
        r"""getAnchor(ScXMLParallelElt self, int idx) -> ScXMLAnchorElt"""
        return _coin.ScXMLParallelElt_getAnchor(self, idx)

    def addAnchor(self, anchor: "ScXMLAnchorElt") -> "void":
        r"""addAnchor(ScXMLParallelElt self, ScXMLAnchorElt anchor)"""
        return _coin.ScXMLParallelElt_addAnchor(self, anchor)

    def removeAnchor(self, anchor: "ScXMLAnchorElt") -> "void":
        r"""removeAnchor(ScXMLParallelElt self, ScXMLAnchorElt anchor)"""
        return _coin.ScXMLParallelElt_removeAnchor(self, anchor)

    def clearAllAnchors(self) -> "void":
        r"""clearAllAnchors(ScXMLParallelElt self)"""
        return _coin.ScXMLParallelElt_clearAllAnchors(self)

    def setDataModel(self, datamodel: "ScXMLDataModelElt") -> "void":
        r"""setDataModel(ScXMLParallelElt self, ScXMLDataModelElt datamodel)"""
        return _coin.ScXMLParallelElt_setDataModel(self, datamodel)

    def getDataModel(self) -> "ScXMLDataModelElt *":
        r"""getDataModel(ScXMLParallelElt self) -> ScXMLDataModelElt"""
        return _coin.ScXMLParallelElt_getDataModel(self)

    def isAtomicState(self) -> "SbBool":
        r"""isAtomicState(ScXMLParallelElt self) -> SbBool"""
        return _coin.ScXMLParallelElt_isAtomicState(self)

# Register ScXMLParallelElt in _coin:
_coin.ScXMLParallelElt_swigregister(ScXMLParallelElt)

def ScXMLParallelElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLParallelElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLParallelElt_getElementReader()

def ScXMLParallelElt_getClassTypeId() -> "SoType":
    r"""ScXMLParallelElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLParallelElt_getClassTypeId()

def ScXMLParallelElt_createInstance() -> "void *":
    r"""ScXMLParallelElt_createInstance() -> void *"""
    return _coin.ScXMLParallelElt_createInstance()

def ScXMLParallelElt_initClass() -> "void":
    r"""ScXMLParallelElt_initClass()"""
    return _coin.ScXMLParallelElt_initClass()

def ScXMLParallelElt_cleanClass() -> "void":
    r"""ScXMLParallelElt_cleanClass()"""
    return _coin.ScXMLParallelElt_cleanClass()

class ScXMLParamElt(ScXMLElt):
    r"""Proxy of C++ ScXMLParamElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLParamElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLParamElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLParamElt self) -> SoType"""
        return _coin.ScXMLParamElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLParamElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLParamElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLParamElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLParamElt self) -> ScXMLParamElt"""
        _coin.ScXMLParamElt_swiginit(self, _coin.new_ScXMLParamElt())
    __swig_destroy__ = _coin.delete_ScXMLParamElt

    def setNameAttribute(self, name: "char const *") -> "void":
        r"""setNameAttribute(ScXMLParamElt self, char const * name)"""
        return _coin.ScXMLParamElt_setNameAttribute(self, name)

    def getNameAttribute(self) -> "char const *":
        r"""getNameAttribute(ScXMLParamElt self) -> char const *"""
        return _coin.ScXMLParamElt_getNameAttribute(self)

    def setExprAttribute(self, expr: "char const *") -> "void":
        r"""setExprAttribute(ScXMLParamElt self, char const * expr)"""
        return _coin.ScXMLParamElt_setExprAttribute(self, expr)

    def getExprAttribute(self) -> "char const *":
        r"""getExprAttribute(ScXMLParamElt self) -> char const *"""
        return _coin.ScXMLParamElt_getExprAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLParamElt self) -> SbBool"""
        return _coin.ScXMLParamElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLParamElt self, ScXMLElt rhs)"""
        return _coin.ScXMLParamElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLParamElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLParamElt_search(self, attrname, attrvalue)

# Register ScXMLParamElt in _coin:
_coin.ScXMLParamElt_swigregister(ScXMLParamElt)

def ScXMLParamElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLParamElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLParamElt_getElementReader()

def ScXMLParamElt_getClassTypeId() -> "SoType":
    r"""ScXMLParamElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLParamElt_getClassTypeId()

def ScXMLParamElt_createInstance() -> "void *":
    r"""ScXMLParamElt_createInstance() -> void *"""
    return _coin.ScXMLParamElt_createInstance()

def ScXMLParamElt_initClass() -> "void":
    r"""ScXMLParamElt_initClass()"""
    return _coin.ScXMLParamElt_initClass()

def ScXMLParamElt_cleanClass() -> "void":
    r"""ScXMLParamElt_cleanClass()"""
    return _coin.ScXMLParamElt_cleanClass()

class ScXMLScriptElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLScriptElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLScriptElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLScriptElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLScriptElt self) -> SoType"""
        return _coin.ScXMLScriptElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLScriptElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLScriptElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLScriptElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLScriptElt self) -> ScXMLScriptElt"""
        _coin.ScXMLScriptElt_swiginit(self, _coin.new_ScXMLScriptElt())
    __swig_destroy__ = _coin.delete_ScXMLScriptElt

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLScriptElt self, ScXMLElt rhs)"""
        return _coin.ScXMLScriptElt_copyContents(self, rhs)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLScriptElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLScriptElt_execute(self, statemachine)

# Register ScXMLScriptElt in _coin:
_coin.ScXMLScriptElt_swigregister(ScXMLScriptElt)

def ScXMLScriptElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLScriptElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLScriptElt_getElementReader()

def ScXMLScriptElt_getClassTypeId() -> "SoType":
    r"""ScXMLScriptElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLScriptElt_getClassTypeId()

def ScXMLScriptElt_createInstance() -> "void *":
    r"""ScXMLScriptElt_createInstance() -> void *"""
    return _coin.ScXMLScriptElt_createInstance()

def ScXMLScriptElt_initClass() -> "void":
    r"""ScXMLScriptElt_initClass()"""
    return _coin.ScXMLScriptElt_initClass()

def ScXMLScriptElt_cleanClass() -> "void":
    r"""ScXMLScriptElt_cleanClass()"""
    return _coin.ScXMLScriptElt_cleanClass()

class ScXMLScxmlElt(ScXMLElt):
    r"""Proxy of C++ ScXMLScxmlElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLScxmlElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLScxmlElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLScxmlElt self) -> SoType"""
        return _coin.ScXMLScxmlElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLScxmlElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLScxmlElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLScxmlElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLScxmlElt self) -> ScXMLScxmlElt"""
        _coin.ScXMLScxmlElt_swiginit(self, _coin.new_ScXMLScxmlElt())
    __swig_destroy__ = _coin.delete_ScXMLScxmlElt

    def setIsReferenced(self, referenced: "SbBool") -> "void":
        r"""setIsReferenced(ScXMLScxmlElt self, SbBool referenced)"""
        return _coin.ScXMLScxmlElt_setIsReferenced(self, referenced)

    def isReferenced(self) -> "SbBool":
        r"""isReferenced(ScXMLScxmlElt self) -> SbBool"""
        return _coin.ScXMLScxmlElt_isReferenced(self)

    def setInitialAttribute(self, initial: "char const *") -> "void":
        r"""setInitialAttribute(ScXMLScxmlElt self, char const * initial)"""
        return _coin.ScXMLScxmlElt_setInitialAttribute(self, initial)

    def getInitialAttribute(self) -> "char const *":
        r"""getInitialAttribute(ScXMLScxmlElt self) -> char const *"""
        return _coin.ScXMLScxmlElt_getInitialAttribute(self)

    def setNameAttribute(self, name: "char const *") -> "void":
        r"""setNameAttribute(ScXMLScxmlElt self, char const * name)"""
        return _coin.ScXMLScxmlElt_setNameAttribute(self, name)

    def getNameAttribute(self) -> "char const *":
        r"""getNameAttribute(ScXMLScxmlElt self) -> char const *"""
        return _coin.ScXMLScxmlElt_getNameAttribute(self)

    def setXMLNSAttribute(self, xmlns: "char const *") -> "void":
        r"""setXMLNSAttribute(ScXMLScxmlElt self, char const * xmlns)"""
        return _coin.ScXMLScxmlElt_setXMLNSAttribute(self, xmlns)

    def getXMLNSAttribute(self) -> "char const *":
        r"""getXMLNSAttribute(ScXMLScxmlElt self) -> char const *"""
        return _coin.ScXMLScxmlElt_getXMLNSAttribute(self)

    def setVersionAttribute(self, version: "char const *") -> "void":
        r"""setVersionAttribute(ScXMLScxmlElt self, char const * version)"""
        return _coin.ScXMLScxmlElt_setVersionAttribute(self, version)

    def getVersionAttribute(self) -> "char const *":
        r"""getVersionAttribute(ScXMLScxmlElt self) -> char const *"""
        return _coin.ScXMLScxmlElt_getVersionAttribute(self)

    def setProfileAttribute(self, profile: "char const *") -> "void":
        r"""setProfileAttribute(ScXMLScxmlElt self, char const * profile)"""
        return _coin.ScXMLScxmlElt_setProfileAttribute(self, profile)

    def getProfileAttribute(self) -> "char const *":
        r"""getProfileAttribute(ScXMLScxmlElt self) -> char const *"""
        return _coin.ScXMLScxmlElt_getProfileAttribute(self)

    def setExModeAttribute(self, exmode: "char const *") -> "void":
        r"""setExModeAttribute(ScXMLScxmlElt self, char const * exmode)"""
        return _coin.ScXMLScxmlElt_setExModeAttribute(self, exmode)

    def getExModeAttribute(self) -> "char const *":
        r"""getExModeAttribute(ScXMLScxmlElt self) -> char const *"""
        return _coin.ScXMLScxmlElt_getExModeAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLScxmlElt self) -> SbBool"""
        return _coin.ScXMLScxmlElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLScxmlElt self, ScXMLElt rhs)"""
        return _coin.ScXMLScxmlElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLScxmlElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLScxmlElt_search(self, attrname, attrvalue)

    def setInitial(self, initial: "ScXMLInitialElt") -> "void":
        r"""setInitial(ScXMLScxmlElt self, ScXMLInitialElt initial)"""
        return _coin.ScXMLScxmlElt_setInitial(self, initial)

    def getInitial(self) -> "ScXMLInitialElt *":
        r"""getInitial(ScXMLScxmlElt self) -> ScXMLInitialElt"""
        return _coin.ScXMLScxmlElt_getInitial(self)

    def getNumStates(self) -> "int":
        r"""getNumStates(ScXMLScxmlElt self) -> int"""
        return _coin.ScXMLScxmlElt_getNumStates(self)

    def getState(self, idx: "int") -> "ScXMLStateElt *":
        r"""getState(ScXMLScxmlElt self, int idx) -> ScXMLStateElt"""
        return _coin.ScXMLScxmlElt_getState(self, idx)

    def addState(self, state: "ScXMLStateElt") -> "void":
        r"""addState(ScXMLScxmlElt self, ScXMLStateElt state)"""
        return _coin.ScXMLScxmlElt_addState(self, state)

    def removeState(self, state: "ScXMLStateElt") -> "void":
        r"""removeState(ScXMLScxmlElt self, ScXMLStateElt state)"""
        return _coin.ScXMLScxmlElt_removeState(self, state)

    def clearAllStates(self) -> "void":
        r"""clearAllStates(ScXMLScxmlElt self)"""
        return _coin.ScXMLScxmlElt_clearAllStates(self)

    def getNumParallels(self) -> "int":
        r"""getNumParallels(ScXMLScxmlElt self) -> int"""
        return _coin.ScXMLScxmlElt_getNumParallels(self)

    def getParallel(self, idx: "int") -> "ScXMLParallelElt *":
        r"""getParallel(ScXMLScxmlElt self, int idx) -> ScXMLParallelElt"""
        return _coin.ScXMLScxmlElt_getParallel(self, idx)

    def addParallel(self, state: "ScXMLParallelElt") -> "void":
        r"""addParallel(ScXMLScxmlElt self, ScXMLParallelElt state)"""
        return _coin.ScXMLScxmlElt_addParallel(self, state)

    def removeParallel(self, state: "ScXMLParallelElt") -> "void":
        r"""removeParallel(ScXMLScxmlElt self, ScXMLParallelElt state)"""
        return _coin.ScXMLScxmlElt_removeParallel(self, state)

    def clearAllParallels(self) -> "void":
        r"""clearAllParallels(ScXMLScxmlElt self)"""
        return _coin.ScXMLScxmlElt_clearAllParallels(self)

    def getNumFinals(self) -> "int":
        r"""getNumFinals(ScXMLScxmlElt self) -> int"""
        return _coin.ScXMLScxmlElt_getNumFinals(self)

    def getFinal(self, idx: "int") -> "ScXMLFinalElt *":
        r"""getFinal(ScXMLScxmlElt self, int idx) -> ScXMLFinalElt"""
        return _coin.ScXMLScxmlElt_getFinal(self, idx)

    def addFinal(self, state: "ScXMLFinalElt") -> "void":
        r"""addFinal(ScXMLScxmlElt self, ScXMLFinalElt state)"""
        return _coin.ScXMLScxmlElt_addFinal(self, state)

    def removeFinal(self, state: "ScXMLFinalElt") -> "void":
        r"""removeFinal(ScXMLScxmlElt self, ScXMLFinalElt state)"""
        return _coin.ScXMLScxmlElt_removeFinal(self, state)

    def clearAllFinals(self) -> "void":
        r"""clearAllFinals(ScXMLScxmlElt self)"""
        return _coin.ScXMLScxmlElt_clearAllFinals(self)

    def setDataModel(self, datamodel: "ScXMLDataModelElt") -> "void":
        r"""setDataModel(ScXMLScxmlElt self, ScXMLDataModelElt datamodel)"""
        return _coin.ScXMLScxmlElt_setDataModel(self, datamodel)

    def getDataModel(self) -> "ScXMLDataModelElt *":
        r"""getDataModel(ScXMLScxmlElt self) -> ScXMLDataModelElt"""
        return _coin.ScXMLScxmlElt_getDataModel(self)

    def getNumScripts(self) -> "int":
        r"""getNumScripts(ScXMLScxmlElt self) -> int"""
        return _coin.ScXMLScxmlElt_getNumScripts(self)

    def getScript(self, idx: "int") -> "ScXMLScriptElt *":
        r"""getScript(ScXMLScxmlElt self, int idx) -> ScXMLScriptElt"""
        return _coin.ScXMLScxmlElt_getScript(self, idx)

    def addScript(self, state: "ScXMLScriptElt") -> "void":
        r"""addScript(ScXMLScxmlElt self, ScXMLScriptElt state)"""
        return _coin.ScXMLScxmlElt_addScript(self, state)

    def removeScript(self, state: "ScXMLScriptElt") -> "void":
        r"""removeScript(ScXMLScxmlElt self, ScXMLScriptElt state)"""
        return _coin.ScXMLScxmlElt_removeScript(self, state)

    def clearAllScripts(self) -> "void":
        r"""clearAllScripts(ScXMLScxmlElt self)"""
        return _coin.ScXMLScxmlElt_clearAllScripts(self)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLScxmlElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLScxmlElt_execute(self, statemachine)

# Register ScXMLScxmlElt in _coin:
_coin.ScXMLScxmlElt_swigregister(ScXMLScxmlElt)

def ScXMLScxmlElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLScxmlElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLScxmlElt_getElementReader()

def ScXMLScxmlElt_getClassTypeId() -> "SoType":
    r"""ScXMLScxmlElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLScxmlElt_getClassTypeId()

def ScXMLScxmlElt_createInstance() -> "void *":
    r"""ScXMLScxmlElt_createInstance() -> void *"""
    return _coin.ScXMLScxmlElt_createInstance()

def ScXMLScxmlElt_initClass() -> "void":
    r"""ScXMLScxmlElt_initClass()"""
    return _coin.ScXMLScxmlElt_initClass()

def ScXMLScxmlElt_cleanClass() -> "void":
    r"""ScXMLScxmlElt_cleanClass()"""
    return _coin.ScXMLScxmlElt_cleanClass()

class ScXMLSendElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLSendElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLSendElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLSendElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLSendElt self) -> SoType"""
        return _coin.ScXMLSendElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLSendElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLSendElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLSendElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLSendElt self) -> ScXMLSendElt"""
        _coin.ScXMLSendElt_swiginit(self, _coin.new_ScXMLSendElt())
    __swig_destroy__ = _coin.delete_ScXMLSendElt

    def setEventAttribute(self, event: "char const *") -> "void":
        r"""setEventAttribute(ScXMLSendElt self, char const * event)"""
        return _coin.ScXMLSendElt_setEventAttribute(self, event)

    def getEventAttribute(self) -> "char const *":
        r"""getEventAttribute(ScXMLSendElt self) -> char const *"""
        return _coin.ScXMLSendElt_getEventAttribute(self)

    def setTargetAttribute(self, event: "char const *") -> "void":
        r"""setTargetAttribute(ScXMLSendElt self, char const * event)"""
        return _coin.ScXMLSendElt_setTargetAttribute(self, event)

    def getTargetAttribute(self) -> "char const *":
        r"""getTargetAttribute(ScXMLSendElt self) -> char const *"""
        return _coin.ScXMLSendElt_getTargetAttribute(self)

    def setTargetTypeAttribute(self, event: "char const *") -> "void":
        r"""setTargetTypeAttribute(ScXMLSendElt self, char const * event)"""
        return _coin.ScXMLSendElt_setTargetTypeAttribute(self, event)

    def getTargetTypeAttribute(self) -> "char const *":
        r"""getTargetTypeAttribute(ScXMLSendElt self) -> char const *"""
        return _coin.ScXMLSendElt_getTargetTypeAttribute(self)

    def setSendIDAttribute(self, event: "char const *") -> "void":
        r"""setSendIDAttribute(ScXMLSendElt self, char const * event)"""
        return _coin.ScXMLSendElt_setSendIDAttribute(self, event)

    def getSendIDAttribute(self) -> "char const *":
        r"""getSendIDAttribute(ScXMLSendElt self) -> char const *"""
        return _coin.ScXMLSendElt_getSendIDAttribute(self)

    def setDelayAttribute(self, event: "char const *") -> "void":
        r"""setDelayAttribute(ScXMLSendElt self, char const * event)"""
        return _coin.ScXMLSendElt_setDelayAttribute(self, event)

    def getDelayAttribute(self) -> "char const *":
        r"""getDelayAttribute(ScXMLSendElt self) -> char const *"""
        return _coin.ScXMLSendElt_getDelayAttribute(self)

    def setNameListAttribute(self, event: "char const *") -> "void":
        r"""setNameListAttribute(ScXMLSendElt self, char const * event)"""
        return _coin.ScXMLSendElt_setNameListAttribute(self, event)

    def getNameListAttribute(self) -> "char const *":
        r"""getNameListAttribute(ScXMLSendElt self) -> char const *"""
        return _coin.ScXMLSendElt_getNameListAttribute(self)

    def setHintsAttribute(self, event: "char const *") -> "void":
        r"""setHintsAttribute(ScXMLSendElt self, char const * event)"""
        return _coin.ScXMLSendElt_setHintsAttribute(self, event)

    def getHintsAttribute(self) -> "char const *":
        r"""getHintsAttribute(ScXMLSendElt self) -> char const *"""
        return _coin.ScXMLSendElt_getHintsAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLSendElt self) -> SbBool"""
        return _coin.ScXMLSendElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLSendElt self, ScXMLElt rhs)"""
        return _coin.ScXMLSendElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLSendElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLSendElt_search(self, attrname, attrvalue)

    def createEvent(self, host: "ScXMLEventTarget") -> "ScXMLEvent *":
        r"""createEvent(ScXMLSendElt self, ScXMLEventTarget host) -> ScXMLEvent"""
        return _coin.ScXMLSendElt_createEvent(self, host)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLSendElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLSendElt_execute(self, statemachine)

# Register ScXMLSendElt in _coin:
_coin.ScXMLSendElt_swigregister(ScXMLSendElt)

def ScXMLSendElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLSendElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLSendElt_getElementReader()

def ScXMLSendElt_getClassTypeId() -> "SoType":
    r"""ScXMLSendElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLSendElt_getClassTypeId()

def ScXMLSendElt_createInstance() -> "void *":
    r"""ScXMLSendElt_createInstance() -> void *"""
    return _coin.ScXMLSendElt_createInstance()

def ScXMLSendElt_initClass() -> "void":
    r"""ScXMLSendElt_initClass()"""
    return _coin.ScXMLSendElt_initClass()

def ScXMLSendElt_cleanClass() -> "void":
    r"""ScXMLSendElt_cleanClass()"""
    return _coin.ScXMLSendElt_cleanClass()

class ScXMLStateElt(ScXMLAbstractStateElt):
    r"""Proxy of C++ ScXMLStateElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLStateElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLStateElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLStateElt self) -> SoType"""
        return _coin.ScXMLStateElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLStateElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLStateElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLStateElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLStateElt self) -> ScXMLStateElt"""
        _coin.ScXMLStateElt_swiginit(self, _coin.new_ScXMLStateElt())
    __swig_destroy__ = _coin.delete_ScXMLStateElt

    def setSrcAttribute(self, src: "char const *") -> "void":
        r"""setSrcAttribute(ScXMLStateElt self, char const * src)"""
        return _coin.ScXMLStateElt_setSrcAttribute(self, src)

    def getSrcAttribute(self) -> "char const *":
        r"""getSrcAttribute(ScXMLStateElt self) -> char const *"""
        return _coin.ScXMLStateElt_getSrcAttribute(self)

    def setInitialAttribute(self, initial: "char const *") -> "void":
        r"""setInitialAttribute(ScXMLStateElt self, char const * initial)"""
        return _coin.ScXMLStateElt_setInitialAttribute(self, initial)

    def getInitialAttribute(self) -> "char const *":
        r"""getInitialAttribute(ScXMLStateElt self) -> char const *"""
        return _coin.ScXMLStateElt_getInitialAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLStateElt self) -> SbBool"""
        return _coin.ScXMLStateElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLStateElt self, ScXMLElt rhs)"""
        return _coin.ScXMLStateElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLStateElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLStateElt_search(self, attrname, attrvalue)

    def setOnEntry(self, onentry: "ScXMLOnEntryElt") -> "void":
        r"""setOnEntry(ScXMLStateElt self, ScXMLOnEntryElt onentry)"""
        return _coin.ScXMLStateElt_setOnEntry(self, onentry)

    def getOnEntry(self) -> "ScXMLOnEntryElt *":
        r"""getOnEntry(ScXMLStateElt self) -> ScXMLOnEntryElt"""
        return _coin.ScXMLStateElt_getOnEntry(self)

    def setOnExit(self, onexit: "ScXMLOnExitElt") -> "void":
        r"""setOnExit(ScXMLStateElt self, ScXMLOnExitElt onexit)"""
        return _coin.ScXMLStateElt_setOnExit(self, onexit)

    def getOnExit(self) -> "ScXMLOnExitElt *":
        r"""getOnExit(ScXMLStateElt self) -> ScXMLOnExitElt"""
        return _coin.ScXMLStateElt_getOnExit(self)

    def getNumTransitions(self) -> "int":
        r"""getNumTransitions(ScXMLStateElt self) -> int"""
        return _coin.ScXMLStateElt_getNumTransitions(self)

    def getTransition(self, idx: "int") -> "ScXMLTransitionElt *":
        r"""getTransition(ScXMLStateElt self, int idx) -> ScXMLTransitionElt"""
        return _coin.ScXMLStateElt_getTransition(self, idx)

    def addTransition(self, transition: "ScXMLTransitionElt") -> "void":
        r"""addTransition(ScXMLStateElt self, ScXMLTransitionElt transition)"""
        return _coin.ScXMLStateElt_addTransition(self, transition)

    def removeTransition(self, transition: "ScXMLTransitionElt") -> "void":
        r"""removeTransition(ScXMLStateElt self, ScXMLTransitionElt transition)"""
        return _coin.ScXMLStateElt_removeTransition(self, transition)

    def clearAllTransitions(self) -> "void":
        r"""clearAllTransitions(ScXMLStateElt self)"""
        return _coin.ScXMLStateElt_clearAllTransitions(self)

    def setInitial(self, initial: "ScXMLInitialElt") -> "void":
        r"""setInitial(ScXMLStateElt self, ScXMLInitialElt initial)"""
        return _coin.ScXMLStateElt_setInitial(self, initial)

    def getInitial(self) -> "ScXMLInitialElt *":
        r"""getInitial(ScXMLStateElt self) -> ScXMLInitialElt"""
        return _coin.ScXMLStateElt_getInitial(self)

    def getNumStates(self) -> "int":
        r"""getNumStates(ScXMLStateElt self) -> int"""
        return _coin.ScXMLStateElt_getNumStates(self)

    def getState(self, idx: "int") -> "ScXMLStateElt *":
        r"""getState(ScXMLStateElt self, int idx) -> ScXMLStateElt"""
        return _coin.ScXMLStateElt_getState(self, idx)

    def addState(self, state: "ScXMLStateElt") -> "void":
        r"""addState(ScXMLStateElt self, ScXMLStateElt state)"""
        return _coin.ScXMLStateElt_addState(self, state)

    def removeState(self, state: "ScXMLStateElt") -> "void":
        r"""removeState(ScXMLStateElt self, ScXMLStateElt state)"""
        return _coin.ScXMLStateElt_removeState(self, state)

    def clearAllStates(self) -> "void":
        r"""clearAllStates(ScXMLStateElt self)"""
        return _coin.ScXMLStateElt_clearAllStates(self)

    def getNumParallels(self) -> "int":
        r"""getNumParallels(ScXMLStateElt self) -> int"""
        return _coin.ScXMLStateElt_getNumParallels(self)

    def getParallel(self, idx: "int") -> "ScXMLParallelElt *":
        r"""getParallel(ScXMLStateElt self, int idx) -> ScXMLParallelElt"""
        return _coin.ScXMLStateElt_getParallel(self, idx)

    def addParallel(self, state: "ScXMLParallelElt") -> "void":
        r"""addParallel(ScXMLStateElt self, ScXMLParallelElt state)"""
        return _coin.ScXMLStateElt_addParallel(self, state)

    def removeParallel(self, state: "ScXMLParallelElt") -> "void":
        r"""removeParallel(ScXMLStateElt self, ScXMLParallelElt state)"""
        return _coin.ScXMLStateElt_removeParallel(self, state)

    def clearAllParallels(self) -> "void":
        r"""clearAllParallels(ScXMLStateElt self)"""
        return _coin.ScXMLStateElt_clearAllParallels(self)

    def getNumFinals(self) -> "int":
        r"""getNumFinals(ScXMLStateElt self) -> int"""
        return _coin.ScXMLStateElt_getNumFinals(self)

    def getFinal(self, idx: "int") -> "ScXMLFinalElt *":
        r"""getFinal(ScXMLStateElt self, int idx) -> ScXMLFinalElt"""
        return _coin.ScXMLStateElt_getFinal(self, idx)

    def addFinal(self, state: "ScXMLFinalElt") -> "void":
        r"""addFinal(ScXMLStateElt self, ScXMLFinalElt state)"""
        return _coin.ScXMLStateElt_addFinal(self, state)

    def removeFinal(self, state: "ScXMLFinalElt") -> "void":
        r"""removeFinal(ScXMLStateElt self, ScXMLFinalElt state)"""
        return _coin.ScXMLStateElt_removeFinal(self, state)

    def clearAllFinals(self) -> "void":
        r"""clearAllFinals(ScXMLStateElt self)"""
        return _coin.ScXMLStateElt_clearAllFinals(self)

    def getNumHistories(self) -> "int":
        r"""getNumHistories(ScXMLStateElt self) -> int"""
        return _coin.ScXMLStateElt_getNumHistories(self)

    def getHistory(self, idx: "int") -> "ScXMLHistoryElt *":
        r"""getHistory(ScXMLStateElt self, int idx) -> ScXMLHistoryElt"""
        return _coin.ScXMLStateElt_getHistory(self, idx)

    def addHistory(self, history: "ScXMLHistoryElt") -> "void":
        r"""addHistory(ScXMLStateElt self, ScXMLHistoryElt history)"""
        return _coin.ScXMLStateElt_addHistory(self, history)

    def removeHistory(self, history: "ScXMLHistoryElt") -> "void":
        r"""removeHistory(ScXMLStateElt self, ScXMLHistoryElt history)"""
        return _coin.ScXMLStateElt_removeHistory(self, history)

    def clearAllHistories(self) -> "void":
        r"""clearAllHistories(ScXMLStateElt self)"""
        return _coin.ScXMLStateElt_clearAllHistories(self)

    def getNumAnchors(self) -> "int":
        r"""getNumAnchors(ScXMLStateElt self) -> int"""
        return _coin.ScXMLStateElt_getNumAnchors(self)

    def getAnchor(self, idx: "int") -> "ScXMLAnchorElt *":
        r"""getAnchor(ScXMLStateElt self, int idx) -> ScXMLAnchorElt"""
        return _coin.ScXMLStateElt_getAnchor(self, idx)

    def addAnchor(self, anchor: "ScXMLAnchorElt") -> "void":
        r"""addAnchor(ScXMLStateElt self, ScXMLAnchorElt anchor)"""
        return _coin.ScXMLStateElt_addAnchor(self, anchor)

    def removeAnchor(self, anchor: "ScXMLAnchorElt") -> "void":
        r"""removeAnchor(ScXMLStateElt self, ScXMLAnchorElt anchor)"""
        return _coin.ScXMLStateElt_removeAnchor(self, anchor)

    def clearAllAnchors(self) -> "void":
        r"""clearAllAnchors(ScXMLStateElt self)"""
        return _coin.ScXMLStateElt_clearAllAnchors(self)

    def setDataModel(self, datamodel: "ScXMLDataModelElt") -> "void":
        r"""setDataModel(ScXMLStateElt self, ScXMLDataModelElt datamodel)"""
        return _coin.ScXMLStateElt_setDataModel(self, datamodel)

    def getDataModel(self) -> "ScXMLDataModelElt *":
        r"""getDataModel(ScXMLStateElt self) -> ScXMLDataModelElt"""
        return _coin.ScXMLStateElt_getDataModel(self)

    def isAtomicState(self) -> "SbBool":
        r"""isAtomicState(ScXMLStateElt self) -> SbBool"""
        return _coin.ScXMLStateElt_isAtomicState(self)

# Register ScXMLStateElt in _coin:
_coin.ScXMLStateElt_swigregister(ScXMLStateElt)

def ScXMLStateElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLStateElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLStateElt_getElementReader()

def ScXMLStateElt_getClassTypeId() -> "SoType":
    r"""ScXMLStateElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLStateElt_getClassTypeId()

def ScXMLStateElt_createInstance() -> "void *":
    r"""ScXMLStateElt_createInstance() -> void *"""
    return _coin.ScXMLStateElt_createInstance()

def ScXMLStateElt_initClass() -> "void":
    r"""ScXMLStateElt_initClass()"""
    return _coin.ScXMLStateElt_initClass()

def ScXMLStateElt_cleanClass() -> "void":
    r"""ScXMLStateElt_cleanClass()"""
    return _coin.ScXMLStateElt_cleanClass()

class ScXMLStateMachine(ScXMLEventTarget):
    r"""Proxy of C++ ScXMLStateMachine class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLStateMachine_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLStateMachine self) -> SoType"""
        return _coin.ScXMLStateMachine_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLStateMachine_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLStateMachine_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLStateMachine_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLStateMachine self) -> ScXMLStateMachine"""
        _coin.ScXMLStateMachine_swiginit(self, _coin.new_ScXMLStateMachine())
    __swig_destroy__ = _coin.delete_ScXMLStateMachine

    def setName(self, name: "SbName") -> "void":
        r"""setName(ScXMLStateMachine self, SbName name)"""
        return _coin.ScXMLStateMachine_setName(self, name)

    def getName(self) -> "SbName const &":
        r"""getName(ScXMLStateMachine self) -> SbName"""
        return _coin.ScXMLStateMachine_getName(self)

    def setDescription(self, document: "ScXMLDocument") -> "void":
        r"""setDescription(ScXMLStateMachine self, ScXMLDocument document)"""
        return _coin.ScXMLStateMachine_setDescription(self, document)

    def getDescription(self) -> "ScXMLDocument const *":
        r"""getDescription(ScXMLStateMachine self) -> ScXMLDocument"""
        return _coin.ScXMLStateMachine_getDescription(self)

    def setSessionId(self, sessionid: "SbName") -> "void":
        r"""setSessionId(ScXMLStateMachine self, SbName sessionid)"""
        return _coin.ScXMLStateMachine_setSessionId(self, sessionid)

    def getSessionId(self) -> "SbName const &":
        r"""getSessionId(ScXMLStateMachine self) -> SbName"""
        return _coin.ScXMLStateMachine_getSessionId(self)

    def initialize(self) -> "void":
        r"""initialize(ScXMLStateMachine self)"""
        return _coin.ScXMLStateMachine_initialize(self)

    def isActive(self) -> "SbBool":
        r"""isActive(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_isActive(self)

    def isFinished(self) -> "SbBool":
        r"""isFinished(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_isFinished(self)

    def getNumActiveStates(self) -> "int":
        r"""getNumActiveStates(ScXMLStateMachine self) -> int"""
        return _coin.ScXMLStateMachine_getNumActiveStates(self)

    def getActiveState(self, idx: "int") -> "ScXMLElt const *":
        r"""getActiveState(ScXMLStateMachine self, int idx) -> ScXMLElt"""
        return _coin.ScXMLStateMachine_getActiveState(self, idx)

    def setVariable(self, name: "char const *", value: "char const *") -> "void":
        r"""setVariable(ScXMLStateMachine self, char const * name, char const * value)"""
        return _coin.ScXMLStateMachine_setVariable(self, name, value)

    def getVariable(self, name: "char const *") -> "char const *":
        r"""getVariable(ScXMLStateMachine self, char const * name) -> char const *"""
        return _coin.ScXMLStateMachine_getVariable(self, name)

    @staticmethod
    def getStateMachineForSessionId(sessionid: "SbName") -> "ScXMLStateMachine *":
        r"""getStateMachineForSessionId(SbName sessionid) -> ScXMLStateMachine"""
        return _coin.ScXMLStateMachine_getStateMachineForSessionId(sessionid)

    def setLogLevel(self, loglevel: "int") -> "void":
        r"""setLogLevel(ScXMLStateMachine self, int loglevel)"""
        return _coin.ScXMLStateMachine_setLogLevel(self, loglevel)

    def getLogLevel(self) -> "int":
        r"""getLogLevel(ScXMLStateMachine self) -> int"""
        return _coin.ScXMLStateMachine_getLogLevel(self)

    def setEvaluator(self, evaluator: "ScXMLEvaluator") -> "void":
        r"""setEvaluator(ScXMLStateMachine self, ScXMLEvaluator evaluator)"""
        return _coin.ScXMLStateMachine_setEvaluator(self, evaluator)

    def getEvaluator(self) -> "ScXMLEvaluator *":
        r"""getEvaluator(ScXMLStateMachine self) -> ScXMLEvaluator"""
        return _coin.ScXMLStateMachine_getEvaluator(self)

    def isModuleEnabled(self, modulename: "char const *") -> "SbBool":
        r"""isModuleEnabled(ScXMLStateMachine self, char const * modulename) -> SbBool"""
        return _coin.ScXMLStateMachine_isModuleEnabled(self, modulename)

    def getNumEnabledModules(self) -> "int":
        r"""getNumEnabledModules(ScXMLStateMachine self) -> int"""
        return _coin.ScXMLStateMachine_getNumEnabledModules(self)

    def getEnabledModuleName(self, idx: "int") -> "char const *":
        r"""getEnabledModuleName(ScXMLStateMachine self, int idx) -> char const *"""
        return _coin.ScXMLStateMachine_getEnabledModuleName(self, idx)

    def setEnabledModulesList(self, modulenames: "SbList< char const * > const &") -> "void":
        r"""setEnabledModulesList(ScXMLStateMachine self, SbList< char const * > const & modulenames)"""
        return _coin.ScXMLStateMachine_setEnabledModulesList(self, modulenames)

    def addDeleteCallback(self, *args) -> "void":
        r"""
        addDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)
        addDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_addDeleteCallback(self, *args)

    def removeDeleteCallback(self, *args) -> "void":
        r"""
        removeDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)
        removeDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_removeDeleteCallback(self, *args)

    def addStateChangeCallback(self, *args) -> "void":
        r"""
        addStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)
        addStateChangeCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_addStateChangeCallback(self, *args)

    def removeStateChangeCallback(self, *args) -> "void":
        r"""
        removeStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)
        removeStateChangeCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_removeStateChangeCallback(self, *args)

# Register ScXMLStateMachine in _coin:
_coin.ScXMLStateMachine_swigregister(ScXMLStateMachine)

def ScXMLStateMachine_getClassTypeId() -> "SoType":
    r"""ScXMLStateMachine_getClassTypeId() -> SoType"""
    return _coin.ScXMLStateMachine_getClassTypeId()

def ScXMLStateMachine_createInstance() -> "void *":
    r"""ScXMLStateMachine_createInstance() -> void *"""
    return _coin.ScXMLStateMachine_createInstance()

def ScXMLStateMachine_initClass() -> "void":
    r"""ScXMLStateMachine_initClass()"""
    return _coin.ScXMLStateMachine_initClass()

def ScXMLStateMachine_cleanClass() -> "void":
    r"""ScXMLStateMachine_cleanClass()"""
    return _coin.ScXMLStateMachine_cleanClass()

def ScXMLStateMachine_getStateMachineForSessionId(sessionid: "SbName") -> "ScXMLStateMachine *":
    r"""ScXMLStateMachine_getStateMachineForSessionId(SbName sessionid) -> ScXMLStateMachine"""
    return _coin.ScXMLStateMachine_getStateMachineForSessionId(sessionid)

class ScXMLTransitionElt(ScXMLElt):
    r"""Proxy of C++ ScXMLTransitionElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLTransitionElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLTransitionElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLTransitionElt self) -> SoType"""
        return _coin.ScXMLTransitionElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLTransitionElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLTransitionElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLTransitionElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLTransitionElt self) -> ScXMLTransitionElt"""
        _coin.ScXMLTransitionElt_swiginit(self, _coin.new_ScXMLTransitionElt())
    __swig_destroy__ = _coin.delete_ScXMLTransitionElt

    def setEventAttribute(self, event: "char const *") -> "void":
        r"""setEventAttribute(ScXMLTransitionElt self, char const * event)"""
        return _coin.ScXMLTransitionElt_setEventAttribute(self, event)

    def getEventAttribute(self) -> "char const *":
        r"""getEventAttribute(ScXMLTransitionElt self) -> char const *"""
        return _coin.ScXMLTransitionElt_getEventAttribute(self)

    def setCondAttribute(self, cond: "char const *") -> "void":
        r"""setCondAttribute(ScXMLTransitionElt self, char const * cond)"""
        return _coin.ScXMLTransitionElt_setCondAttribute(self, cond)

    def getCondAttribute(self) -> "char const *":
        r"""getCondAttribute(ScXMLTransitionElt self) -> char const *"""
        return _coin.ScXMLTransitionElt_getCondAttribute(self)

    def setTargetAttribute(self, target: "char const *") -> "void":
        r"""setTargetAttribute(ScXMLTransitionElt self, char const * target)"""
        return _coin.ScXMLTransitionElt_setTargetAttribute(self, target)

    def getTargetAttribute(self) -> "char const *":
        r"""getTargetAttribute(ScXMLTransitionElt self) -> char const *"""
        return _coin.ScXMLTransitionElt_getTargetAttribute(self)

    def setAnchorAttribute(self, anchor: "char const *") -> "void":
        r"""setAnchorAttribute(ScXMLTransitionElt self, char const * anchor)"""
        return _coin.ScXMLTransitionElt_setAnchorAttribute(self, anchor)

    def getAnchorAttribute(self) -> "char const *":
        r"""getAnchorAttribute(ScXMLTransitionElt self) -> char const *"""
        return _coin.ScXMLTransitionElt_getAnchorAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLTransitionElt self) -> SbBool"""
        return _coin.ScXMLTransitionElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLTransitionElt self, ScXMLElt rhs)"""
        return _coin.ScXMLTransitionElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLTransitionElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLTransitionElt_search(self, attrname, attrvalue)

    def isConditionLess(self) -> "SbBool":
        r"""isConditionLess(ScXMLTransitionElt self) -> SbBool"""
        return _coin.ScXMLTransitionElt_isConditionLess(self)

    def isTargetLess(self) -> "SbBool":
        r"""isTargetLess(ScXMLTransitionElt self) -> SbBool"""
        return _coin.ScXMLTransitionElt_isTargetLess(self)

    def isSelfReferencing(self) -> "SbBool":
        r"""isSelfReferencing(ScXMLTransitionElt self) -> SbBool"""
        return _coin.ScXMLTransitionElt_isSelfReferencing(self)

    def isEventMatch(self, event: "ScXMLEvent") -> "SbBool":
        r"""isEventMatch(ScXMLTransitionElt self, ScXMLEvent event) -> SbBool"""
        return _coin.ScXMLTransitionElt_isEventMatch(self, event)

    def evaluateCondition(self, statemachine: "ScXMLStateMachine") -> "SbBool":
        r"""evaluateCondition(ScXMLTransitionElt self, ScXMLStateMachine statemachine) -> SbBool"""
        return _coin.ScXMLTransitionElt_evaluateCondition(self, statemachine)

    def getNumExecutables(self) -> "int":
        r"""getNumExecutables(ScXMLTransitionElt self) -> int"""
        return _coin.ScXMLTransitionElt_getNumExecutables(self)

    def getExecutable(self, idx: "int") -> "ScXMLExecutableElt *":
        r"""getExecutable(ScXMLTransitionElt self, int idx) -> ScXMLExecutableElt"""
        return _coin.ScXMLTransitionElt_getExecutable(self, idx)

    def addExecutable(self, executable: "ScXMLExecutableElt") -> "void":
        r"""addExecutable(ScXMLTransitionElt self, ScXMLExecutableElt executable)"""
        return _coin.ScXMLTransitionElt_addExecutable(self, executable)

    def removeExecutable(self, executable: "ScXMLExecutableElt") -> "void":
        r"""removeExecutable(ScXMLTransitionElt self, ScXMLExecutableElt executable)"""
        return _coin.ScXMLTransitionElt_removeExecutable(self, executable)

    def clearAllExecutables(self) -> "void":
        r"""clearAllExecutables(ScXMLTransitionElt self)"""
        return _coin.ScXMLTransitionElt_clearAllExecutables(self)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLTransitionElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLTransitionElt_execute(self, statemachine)

# Register ScXMLTransitionElt in _coin:
_coin.ScXMLTransitionElt_swigregister(ScXMLTransitionElt)

def ScXMLTransitionElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLTransitionElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLTransitionElt_getElementReader()

def ScXMLTransitionElt_getClassTypeId() -> "SoType":
    r"""ScXMLTransitionElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLTransitionElt_getClassTypeId()

def ScXMLTransitionElt_createInstance() -> "void *":
    r"""ScXMLTransitionElt_createInstance() -> void *"""
    return _coin.ScXMLTransitionElt_createInstance()

def ScXMLTransitionElt_initClass() -> "void":
    r"""ScXMLTransitionElt_initClass()"""
    return _coin.ScXMLTransitionElt_initClass()

def ScXMLTransitionElt_cleanClass() -> "void":
    r"""ScXMLTransitionElt_cleanClass()"""
    return _coin.ScXMLTransitionElt_cleanClass()

class ScXMLValidateElt(ScXMLExecutableElt):
    r"""Proxy of C++ ScXMLValidateElt class."""

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

    @staticmethod
    def getElementReader() -> "ScXMLEltReader *":
        r"""getElementReader() -> ScXMLEltReader"""
        return _coin.ScXMLValidateElt_getElementReader()

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLValidateElt_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLValidateElt self) -> SoType"""
        return _coin.ScXMLValidateElt_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLValidateElt_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLValidateElt_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLValidateElt_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLValidateElt self) -> ScXMLValidateElt"""
        _coin.ScXMLValidateElt_swiginit(self, _coin.new_ScXMLValidateElt())
    __swig_destroy__ = _coin.delete_ScXMLValidateElt

    def setLocationAttribute(self, location: "char const *") -> "void":
        r"""setLocationAttribute(ScXMLValidateElt self, char const * location)"""
        return _coin.ScXMLValidateElt_setLocationAttribute(self, location)

    def getLocationAttribute(self) -> "char const *":
        r"""getLocationAttribute(ScXMLValidateElt self) -> char const *"""
        return _coin.ScXMLValidateElt_getLocationAttribute(self)

    def setSchemaAttribute(self, schema: "char const *") -> "void":
        r"""setSchemaAttribute(ScXMLValidateElt self, char const * schema)"""
        return _coin.ScXMLValidateElt_setSchemaAttribute(self, schema)

    def getSchemaAttribute(self) -> "char const *":
        r"""getSchemaAttribute(ScXMLValidateElt self) -> char const *"""
        return _coin.ScXMLValidateElt_getSchemaAttribute(self)

    def handleXMLAttributes(self) -> "SbBool":
        r"""handleXMLAttributes(ScXMLValidateElt self) -> SbBool"""
        return _coin.ScXMLValidateElt_handleXMLAttributes(self)

    def copyContents(self, rhs: "ScXMLElt") -> "void":
        r"""copyContents(ScXMLValidateElt self, ScXMLElt rhs)"""
        return _coin.ScXMLValidateElt_copyContents(self, rhs)

    def search(self, attrname: "char const *", attrvalue: "char const *") -> "ScXMLElt const *":
        r"""search(ScXMLValidateElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"""
        return _coin.ScXMLValidateElt_search(self, attrname, attrvalue)

    def execute(self, statemachine: "ScXMLStateMachine") -> "void":
        r"""execute(ScXMLValidateElt self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLValidateElt_execute(self, statemachine)

# Register ScXMLValidateElt in _coin:
_coin.ScXMLValidateElt_swigregister(ScXMLValidateElt)

def ScXMLValidateElt_getElementReader() -> "ScXMLEltReader *":
    r"""ScXMLValidateElt_getElementReader() -> ScXMLEltReader"""
    return _coin.ScXMLValidateElt_getElementReader()

def ScXMLValidateElt_getClassTypeId() -> "SoType":
    r"""ScXMLValidateElt_getClassTypeId() -> SoType"""
    return _coin.ScXMLValidateElt_getClassTypeId()

def ScXMLValidateElt_createInstance() -> "void *":
    r"""ScXMLValidateElt_createInstance() -> void *"""
    return _coin.ScXMLValidateElt_createInstance()

def ScXMLValidateElt_initClass() -> "void":
    r"""ScXMLValidateElt_initClass()"""
    return _coin.ScXMLValidateElt_initClass()

def ScXMLValidateElt_cleanClass() -> "void":
    r"""ScXMLValidateElt_cleanClass()"""
    return _coin.ScXMLValidateElt_cleanClass()

class ScXMLXPathEvaluator(ScXMLEvaluator):
    r"""Proxy of C++ ScXMLXPathEvaluator class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLXPathEvaluator_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(ScXMLXPathEvaluator self) -> SoType"""
        return _coin.ScXMLXPathEvaluator_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.ScXMLXPathEvaluator_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.ScXMLXPathEvaluator_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.ScXMLXPathEvaluator_cleanClass()

    def __init__(self):
        r"""__init__(ScXMLXPathEvaluator self) -> ScXMLXPathEvaluator"""
        _coin.ScXMLXPathEvaluator_swiginit(self, _coin.new_ScXMLXPathEvaluator())
    __swig_destroy__ = _coin.delete_ScXMLXPathEvaluator

    def evaluate(self, expression: "char const *") -> "ScXMLDataObj *":
        r"""evaluate(ScXMLXPathEvaluator self, char const * expression) -> ScXMLDataObj"""
        return _coin.ScXMLXPathEvaluator_evaluate(self, expression)

    def setAtLocation(self, location: "char const *", obj: "ScXMLDataObj") -> "SbBool":
        r"""setAtLocation(ScXMLXPathEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"""
        return _coin.ScXMLXPathEvaluator_setAtLocation(self, location, obj)

    def locate(self, location: "char const *") -> "ScXMLDataObj *":
        r"""locate(ScXMLXPathEvaluator self, char const * location) -> ScXMLDataObj"""
        return _coin.ScXMLXPathEvaluator_locate(self, location)

# Register ScXMLXPathEvaluator in _coin:
_coin.ScXMLXPathEvaluator_swigregister(ScXMLXPathEvaluator)

def ScXMLXPathEvaluator_getClassTypeId() -> "SoType":
    r"""ScXMLXPathEvaluator_getClassTypeId() -> SoType"""
    return _coin.ScXMLXPathEvaluator_getClassTypeId()

def ScXMLXPathEvaluator_createInstance() -> "void *":
    r"""ScXMLXPathEvaluator_createInstance() -> void *"""
    return _coin.ScXMLXPathEvaluator_createInstance()

def ScXMLXPathEvaluator_initClass() -> "void":
    r"""ScXMLXPathEvaluator_initClass()"""
    return _coin.ScXMLXPathEvaluator_initClass()

def ScXMLXPathEvaluator_cleanClass() -> "void":
    r"""ScXMLXPathEvaluator_cleanClass()"""
    return _coin.ScXMLXPathEvaluator_cleanClass()

class SoScXMLEvent(ScXMLEvent):
    r"""Proxy of C++ SoScXMLEvent class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLEvent_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLEvent self) -> SoType"""
        return _coin.SoScXMLEvent_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLEvent_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLEvent_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLEvent_cleanClass()

    def __init__(self):
        r"""__init__(SoScXMLEvent self) -> SoScXMLEvent"""
        _coin.SoScXMLEvent_swiginit(self, _coin.new_SoScXMLEvent())
    __swig_destroy__ = _coin.delete_SoScXMLEvent

    def setSoEvent(self, soevent: "SoEvent") -> "void":
        r"""setSoEvent(SoScXMLEvent self, SoEvent soevent)"""
        return _coin.SoScXMLEvent_setSoEvent(self, soevent)

    def getSoEvent(self) -> "SoEvent const *":
        r"""getSoEvent(SoScXMLEvent self) -> SoEvent"""
        return _coin.SoScXMLEvent_getSoEvent(self)

    def setUpIdentifier(self) -> "void":
        r"""setUpIdentifier(SoScXMLEvent self)"""
        return _coin.SoScXMLEvent_setUpIdentifier(self)

    def copyContents(self, rhs: "ScXMLEvent") -> "void":
        r"""copyContents(SoScXMLEvent self, ScXMLEvent rhs)"""
        return _coin.SoScXMLEvent_copyContents(self, rhs)

# Register SoScXMLEvent in _coin:
_coin.SoScXMLEvent_swigregister(SoScXMLEvent)

def SoScXMLEvent_getClassTypeId() -> "SoType":
    r"""SoScXMLEvent_getClassTypeId() -> SoType"""
    return _coin.SoScXMLEvent_getClassTypeId()

def SoScXMLEvent_createInstance() -> "void *":
    r"""SoScXMLEvent_createInstance() -> void *"""
    return _coin.SoScXMLEvent_createInstance()

def SoScXMLEvent_initClass() -> "void":
    r"""SoScXMLEvent_initClass()"""
    return _coin.SoScXMLEvent_initClass()

def SoScXMLEvent_cleanClass() -> "void":
    r"""SoScXMLEvent_cleanClass()"""
    return _coin.SoScXMLEvent_cleanClass()

class SoScXMLStateMachine(ScXMLStateMachine):
    r"""Proxy of C++ SoScXMLStateMachine class."""

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

    @staticmethod
    def getClassTypeId() -> "SoType":
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLStateMachine_getClassTypeId()

    def getTypeId(self) -> "SoType":
        r"""getTypeId(SoScXMLStateMachine self) -> SoType"""
        return _coin.SoScXMLStateMachine_getTypeId(self)

    @staticmethod
    def createInstance() -> "void *":
        r"""createInstance() -> void *"""
        return _coin.SoScXMLStateMachine_createInstance()

    @staticmethod
    def initClass() -> "void":
        r"""initClass()"""
        return _coin.SoScXMLStateMachine_initClass()

    @staticmethod
    def cleanClass() -> "void":
        r"""cleanClass()"""
        return _coin.SoScXMLStateMachine_cleanClass()

    def __init__(self):
        r"""__init__(SoScXMLStateMachine self) -> SoScXMLStateMachine"""
        _coin.SoScXMLStateMachine_swiginit(self, _coin.new_SoScXMLStateMachine())
    __swig_destroy__ = _coin.delete_SoScXMLStateMachine

    def setSceneGraphRoot(self, root: "SoNode") -> "void":
        r"""setSceneGraphRoot(SoScXMLStateMachine self, SoNode root)"""
        return _coin.SoScXMLStateMachine_setSceneGraphRoot(self, root)

    def getSceneGraphRoot(self) -> "SoNode *":
        r"""getSceneGraphRoot(SoScXMLStateMachine self) -> SoNode"""
        return _coin.SoScXMLStateMachine_getSceneGraphRoot(self)

    def setActiveCamera(self, camera: "SoCamera") -> "void":
        r"""setActiveCamera(SoScXMLStateMachine self, SoCamera camera)"""
        return _coin.SoScXMLStateMachine_setActiveCamera(self, camera)

    def getActiveCamera(self) -> "SoCamera *":
        r"""getActiveCamera(SoScXMLStateMachine self) -> SoCamera"""
        return _coin.SoScXMLStateMachine_getActiveCamera(self)

    def setViewportRegion(self, vp: "SbViewportRegion") -> "void":
        r"""setViewportRegion(SoScXMLStateMachine self, SbViewportRegion vp)"""
        return _coin.SoScXMLStateMachine_setViewportRegion(self, vp)

    def getViewportRegion(self) -> "SbViewportRegion const &":
        r"""getViewportRegion(SoScXMLStateMachine self) -> SbViewportRegion"""
        return _coin.SoScXMLStateMachine_getViewportRegion(self)

    def preGLRender(self) -> "void":
        r"""preGLRender(SoScXMLStateMachine self)"""
        return _coin.SoScXMLStateMachine_preGLRender(self)

    def postGLRender(self) -> "void":
        r"""postGLRender(SoScXMLStateMachine self)"""
        return _coin.SoScXMLStateMachine_postGLRender(self)

    def processSoEvent(self, event: "SoEvent") -> "SbBool":
        r"""processSoEvent(SoScXMLStateMachine self, SoEvent event) -> SbBool"""
        return _coin.SoScXMLStateMachine_processSoEvent(self, event)

    def getVariable(self, key: "char const *") -> "char const *":
        r"""getVariable(SoScXMLStateMachine self, char const * key) -> char const *"""
        return _coin.SoScXMLStateMachine_getVariable(self, key)

# Register SoScXMLStateMachine in _coin:
_coin.SoScXMLStateMachine_swigregister(SoScXMLStateMachine)

def SoScXMLStateMachine_getClassTypeId() -> "SoType":
    r"""SoScXMLStateMachine_getClassTypeId() -> SoType"""
    return _coin.SoScXMLStateMachine_getClassTypeId()

def SoScXMLStateMachine_createInstance() -> "void *":
    r"""SoScXMLStateMachine_createInstance() -> void *"""
    return _coin.SoScXMLStateMachine_createInstance()

def SoScXMLStateMachine_initClass() -> "void":
    r"""SoScXMLStateMachine_initClass()"""
    return _coin.SoScXMLStateMachine_initClass()

def SoScXMLStateMachine_cleanClass() -> "void":
    r"""SoScXMLStateMachine_cleanClass()"""
    return _coin.SoScXMLStateMachine_cleanClass()


for x in list(locals()):
  value = locals()[x]
  try:
    if isinstance(value, type) and issubclass(value, SoFieldContainer):
      for name in list(value.__dict__):
        val = value.__dict__[name]
        if isinstance(val, property):
          delattr(value, name)
  except NameError:
# value == SoSearchAction_duringSearchAll ???
    pass



