###############################################

# X3D Package for Python x3d.py

# generator: X3duomToX3dPythonPackage.xslt
# X3DUOM:    X3dUnifiedObjectModel-4.0.xml

_DEBUG = True       # options True False

###############################################

# Utility Functions

def metaDiagnostics(self, headElement=None):
    """
    Utility function to return any meta info, hint, warning, error, TODO values in this model
    """
    if  headElement is None:
        headElement = self
    if  isinstance(headElement, X3D):
        headElement = headElement.head
    # print (type(headElement)) # diagnostic
    if  not isinstance(headElement, head):
        return
    result = "meta "
    for each in headElement.children:
        if isinstance(each, meta) and each.name in ('info', 'hint', 'warning', 'error', 'TODO'):
            result += each.name.strip() + ': ' + each.content.strip()
            if  result.endswith('.') or result.endswith(','):
                result += ' '
            else:
                result += ', '
    if  result != "meta".strip():
        return result.rstrip(', ').strip()

###############################################

# Field Validation Functions

# Type-specific functions to check for valid values, throw exception if illegal value is found


def isValidSFBool(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, bool):
        raise RuntimeError(str(value) + ' is not a valid bool value (True or False) for SFBool')
    return True

def isValidMFBool(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFBool')
    return True

def isValidSFColor(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFColor')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFColor element ' + str(each) + ' is not a valid float')
        if (each < 0) or (each > 1):
            raise RuntimeError('SFColor' + str(value) + ' has value ' + str(each) + ' out of range [0..1] and is not a valid SFColor')
    if tupleCount != 3:
        raise RuntimeError('SFColor ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 3')
    return True

def isValidMFColor(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFColor')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFColor element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFColor element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
            if (element < 0) or (element > 1):
                raise RuntimeError('MFColor' + str(value) + ' has value ' + str(element) + ' out of range [0..1] and is not a valid MFColor')
    return True

def isValidSFColorRGBA(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFColorRGBA')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFColorRGBA element ' + str(each) + ' is not a valid float')
        if (each < 0) or (each > 1):
            raise RuntimeError('SFColorRGBA' + str(value) + ' has value ' + str(each) + ' out of range [0..1] and is not a valid SFColorRGBA')
    if tupleCount != 4:
        raise RuntimeError('SFColorRGBA ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 4')
    return True

def isValidMFColorRGBA(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFColorRGBA')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFColorRGBA element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFColorRGBA element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
            if (element < 0) or (element > 1):
                raise RuntimeError('MFColorRGBA' + str(value) + ' has value ' + str(element) + ' out of range [0..1] and is not a valid MFColorRGBA')
    return True

def isValidSFDouble(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, float) and not isinstance(value, int):
        raise RuntimeError(str(value) + ' is not a valid float value for SFDouble')
    return True

def isValidMFDouble(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFDouble')
    return True

def isValidSFFloat(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, float) and not isinstance(value, int):
        raise RuntimeError(str(value) + ' is not a valid float value for SFFloat')
    return True

def isValidMFFloat(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFFloat')
    return True

def isValidSFImage(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, float) and not isinstance(value, int):
        raise RuntimeError(str(value) + ' is not a valid float value for SFImage')
    return True

def isValidMFImage(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFImage')
    return True

def isValidSFInt32(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, int):
        raise RuntimeError(str(value) + ' is not a valid int value for SFInt32')
    return True

def isValidMFInt32(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFInt32')
    return True

def isValidSFMatrix3d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFMatrix3d')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFMatrix3d element ' + str(each) + ' is not a valid float')
    if tupleCount != 9:
        raise RuntimeError('SFMatrix3d ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 9')
    return True

def isValidMFMatrix3d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFMatrix3d')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFMatrix3d element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFMatrix3d element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFMatrix3f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFMatrix3f')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFMatrix3f element ' + str(each) + ' is not a valid float')
    if tupleCount != 9:
        raise RuntimeError('SFMatrix3f ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 9')
    return True

def isValidMFMatrix3f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFMatrix3f')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFMatrix3f element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFMatrix3f element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFMatrix4d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFMatrix4d')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFMatrix4d element ' + str(each) + ' is not a valid float')
    if tupleCount != 16:
        raise RuntimeError('SFMatrix4d ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 16')
    return True

def isValidMFMatrix4d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFMatrix4d')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFMatrix4d element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFMatrix4d element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFMatrix4f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFMatrix4f')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFMatrix4f element ' + str(each) + ' is not a valid float')
    if tupleCount != 16:
        raise RuntimeError('SFMatrix4f ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 16')
    return True

def isValidMFMatrix4f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFMatrix4f')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFMatrix4f element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFMatrix4f element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFNode(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, object):
        raise RuntimeError(str(value) + ' is not a valid object value for SFNode')
    return True

def isValidMFNode(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list of X3D objects for MFNode')
    for each in value:
        if not isinstance(each, _X3DNode) and not isinstance(each, _X3DStatement):
            raise RuntimeError(str(value) + ' element ' + str(each) + ' is not a valid _X3DNode or _X3DStatement for MFNode')

    return True

def isValidSFRotation(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFRotation')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFRotation element ' + str(each) + ' is not a valid float')
    if tupleCount != 4:
        raise RuntimeError('SFRotation ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 4')
    return True

def isValidMFRotation(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFRotation')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFRotation element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFRotation element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFString(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, str):
        raise RuntimeError(str(value) + ' is not a valid str value for SFString')
    return True

def isValidMFString(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFString')
    return True

def isValidSFTime(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, ):
        raise RuntimeError(str(value) + ' is not a valid  value for SFTime')
    return True

def isValidMFTime(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFTime')
    return True

def isValidSFVec2d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFVec2d')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFVec2d element ' + str(each) + ' is not a valid float')
    if tupleCount != 2:
        raise RuntimeError('SFVec2d ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 2')
    return True

def isValidMFVec2d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFVec2d')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFVec2d element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFVec2d element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFVec2f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFVec2f')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFVec2f element ' + str(each) + ' is not a valid float')
    if tupleCount != 2:
        raise RuntimeError('SFVec2f ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 2')
    return True

def isValidMFVec2f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFVec2f')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFVec2f element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFVec2f element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFVec3d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFVec3d')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFVec3d element ' + str(each) + ' is not a valid float')
    if tupleCount != 3:
        raise RuntimeError('SFVec3d ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 3')
    return True

def isValidMFVec3d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFVec3d')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFVec3d element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFVec3d element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFVec3f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFVec3f')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFVec3f element ' + str(each) + ' is not a valid float')
    if tupleCount != 3:
        raise RuntimeError('SFVec3f ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 3')
    return True

def isValidMFVec3f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFVec3f')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFVec3f element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFVec3f element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFVec4d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFVec4d')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFVec4d element ' + str(each) + ' is not a valid float')
    if tupleCount != 4:
        raise RuntimeError('SFVec4d ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 4')
    return True

def isValidMFVec4d(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFVec4d')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFVec4d element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFVec4d element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

def isValidSFVec4f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, tuple):
        raise RuntimeError(str(value) + ' is not a valid Python tuple for SFVec4f')
    tupleCount = 0
    for each in value:
        tupleCount += 1
        if not isinstance(each, float) and not isinstance(each, int):
            raise RuntimeError('SFVec4f element ' + str(each) + ' is not a valid float')
    if tupleCount != 4:
        raise RuntimeError('SFVec4f ' + str(value) + ' has ' + str(tupleCount) + ' elements instead of 4')
    return True

def isValidMFVec4f(value):
    """
    Utility function to determine type validity of a value
    """
    if not isinstance(value, list):
        raise RuntimeError(str(value) + ' is not a valid Python list for MFVec4f')
    _index = 0
    for each in value:
        if not isinstance(each, tuple):
            raise RuntimeError('MFVec4f element #' + str(_index) + ' with value ' + str(each) + ' is not a valid tuple')
        _index += 1
        for element in each:
            if not isinstance(element, float) and not isinstance(element, int):
                raise RuntimeError('MFVec4f element #' + str(_index) + ' tuple ' + str(each) + ' has value=' + str(element) + ' that is not a valid float')
    return True

###############################################

# Field Types

class _X3DField(object):
    """
    All X3D fields implement _X3DField abstract type.
    """
    __name__ = '_X3DField'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html'
    def __repl__(self):
        # if _DEBUG: print ('debug: type(self.value)=' + str(type(self.value)))
        if  self.__name__ == 'MFNode' or isinstance(self.value, list):
            # isinstance(self.value, MFNode): not working, what got passed in was not an MFNode object apparently
            result = '['
            for each in self.value:
                result += str(each) + ', '
                # if _DEBUG: print ('debug: str(each)=' + str(each))
            return result.rstrip(', ') + ']'
        else:
            return str(self.value)
    def __str__(self):
        return self.__repl__()

def isX3DField(value):
    """
    Determine whether object is an instance of _X3DField.
    """
    return isinstance(value, _X3DField)

class SFBool(_X3DField):
    """
    SFBool is a logical type with possible values (True|False).
    """
    __name__ = 'SFBool'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFBoolAndMFBool'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFBool'
    DEFAULT_VALUE = True
    regex = r'\s*(true|false)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        if  value in ('true', 'True'):
            value = True
        elif value in ('false', 'False'):
            value = False
        self.__value = value
        isValidSFBool(value)

class MFBool(_X3DField):
    """
    MFBool is an array of Boolean values.
    """
    __name__ = 'MFBool'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFBoolAndMFBool'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFBool'
    DEFAULT_VALUE = list()
    regex = r'\s*((true|false)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        index = 0
        newValue = value
        for each in newValue:
#           print('each=' + str(each)) # debug
            if  each in ('true', 'True'):
                value[index] = True
            elif each in ('false', 'False'):
                value[index] = False
            if not isinstance(value[index], bool):
                raise RuntimeError('MFBool value[' + str(index) + '] = ' + str(each) + ' = ' + str(value[index]) + ' is not a valid Python bool')
            index += 1
        self.__value = value
        isValidMFBool(value)

class SFColor(_X3DField):
    """
    The SFColor field specifies one RGB (red-green-blue) color triple.
    """
    __name__ = 'SFColor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFColorAndMFColor'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFColor'
    DEFAULT_VALUE = (0, 0, 0)
    regex = r'(\s)*(([+]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)(\s)+){2}([+]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)(\s)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFColor(value)

class MFColor(_X3DField):
    """
    MFColor specifies zero or more SFColor RGB triples.
    """
    __name__ = 'MFColor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFColorAndMFColor'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFColor'
    DEFAULT_VALUE = (list())
    regex = r'(\s)*((([+-]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)(\s)+){2}([+-]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFColor(value)

class SFColorRGBA(_X3DField):
    """
    The SFColorRGBA field specifies one RGBA (red-green-blue-alpha) color 4-tuple.
    """
    __name__ = 'SFColorRGBA'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFColorRGBAAndMFColorRGBA'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFColorRGBA'
    DEFAULT_VALUE = (0, 0, 0, 0)
    regex = r'(\s)*(([+-]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)(\s)+){3}([+-]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)(\s)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFColorRGBA(value)

class MFColorRGBA(_X3DField):
    """
    MFColorRGBA specifies zero or more SFColorRGBA 4-tuples.
    """
    __name__ = 'MFColorRGBA'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFColorRGBAAndMFColorRGBA'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFColorRGBA'
    DEFAULT_VALUE = (list())
    regex = r'(\s)*((([+-]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)(\s)+){3}([+-]?((0(\.[0-9]*)?|\.[0-9]+)|1(\.0*)?)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFColorRGBA(value)

class SFDouble(_X3DField):
    """
    SFDouble is a double-precision floating-point type.
    """
    __name__ = 'SFDouble'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFDoubleAndMFDouble'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFDouble'
    DEFAULT_VALUE = 0.0
    regex = r'(\s)*([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)(\s)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFDouble(value)

class MFDouble(_X3DField):
    """
    MFDouble is an array of Double values, meaning a double-precision floating-point array type.
    """
    __name__ = 'MFDouble'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFDoubleAndMFDouble'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFDouble'
    DEFAULT_VALUE = list()
    regex = r'(\s)*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFDouble(value)

class SFFloat(_X3DField):
    """
    SFFloat is a single-precision floating-point type.
    """
    __name__ = 'SFFloat'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFFloatAndMFFloat'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFFloat'
    DEFAULT_VALUE = 0.0
    regex = r'(\s)*([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)(\s)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFFloat(value)

class MFFloat(_X3DField):
    """
    MFFloat is an array of SFFloat values, meaning a single-precision floating-point array type.
    """
    __name__ = 'MFFloat'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFFloatAndMFFloat'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFFloat'
    DEFAULT_VALUE = list()
    regex = r'(\s)*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFFloat(value)

class SFImage(_X3DField):
    """
    The SFImage field specifies a single uncompressed 2-dimensional pixel image.
    """
    __name__ = 'SFImage'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFImageAndMFImage'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFImage'
    DEFAULT_VALUE = [0, 0, 0]
    regex = r'\s*([+]?(0|[1-9][0-9]*)([Ee][+]?[0-9]+)?\s+){2}[+]?[0-4](\s+(0x[0-9a-fA-F]{1,16}|[+]?(0|[1-9][0-9]*)([Ee][+]?[0-9]+)?))*\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFImage(value)

class MFImage(_X3DField):
    """
    MFImage is an array of SFImage values.
    """
    __name__ = 'MFImage'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFImageAndMFImage'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFImage'
    DEFAULT_VALUE = list()
    regex = r'\s*(([+]?(0|[1-9][0-9]*)([Ee][+]?[0-9]+)?\s+){2}[+]?[0-4](\s+(0x[0-9a-fA-F]{1,16}|[+]?(0|[1-9][0-9]*)([Ee][+]?[0-9]+)?))*\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFImage(value)

class SFInt32(_X3DField):
    """
    An SFInt32 field specifies one 32-bit signed integer.
    """
    __name__ = 'SFInt32'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFInt32AndMFInt32'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFInt32'
    DEFAULT_VALUE = 0
    regex = r'(\s)*[+-]?(0|[1-9][0-9]*)([Ee][+-]?[0-9]+)?(\s)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFInt32(value)

class MFInt32(_X3DField):
    """
    An MFInt32 field defines an array of 32-bit signed integers.
    """
    __name__ = 'MFInt32'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFInt32AndMFInt32'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFInt32'
    DEFAULT_VALUE = list()
    regex = r'(\s)*([+-]?(0|[1-9][0-9]*)([Ee][+-]?[0-9]+)?\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFInt32(value)

class SFMatrix3d(_X3DField):
    """
    SFMatrix3d specifies a 3x3 matrix of double-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'SFMatrix3d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix3dAndMFMatrix3d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFMatrix3d'
    DEFAULT_VALUE = (1, 0, 0, 0, 1, 0, 0, 0, 1)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){8}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFMatrix3d(value)

class MFMatrix3d(_X3DField):
    """
    MFMatrix3d specifies zero or more 3x3 matrices of double-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'MFMatrix3d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix3dAndMFMatrix3d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFMatrix3d'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){8}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFMatrix3d(value)

class SFMatrix3f(_X3DField):
    """
    SFMatrix3f specifies a 3x3 matrix of single-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'SFMatrix3f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix3fAndMFMatrix3f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFMatrix3f'
    DEFAULT_VALUE = (1, 0, 0, 0, 1, 0, 0, 0, 1)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){8}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFMatrix3f(value)

class MFMatrix3f(_X3DField):
    """
    MFMatrix3f specifies zero or more 3x3 matrices of single-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'MFMatrix3f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix3fAndMFMatrix3f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFMatrix3f'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){8}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFMatrix3f(value)

class SFMatrix4d(_X3DField):
    """
    SFMatrix4d specifies a 4x4 matrix of double-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'SFMatrix4d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix4dAndMFMatrix4d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFMatrix4d'
    DEFAULT_VALUE = (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){15}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFMatrix4d(value)

class MFMatrix4d(_X3DField):
    """
    MFMatrix4d specifies zero or more 4x4 matrices of double-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'MFMatrix4d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix4dAndMFMatrix4d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFMatrix4d'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){15}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFMatrix4d(value)

class SFMatrix4f(_X3DField):
    """
    SFMatrix4f specifies a 4x4 matrix of single-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'SFMatrix4f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix4fAndMFMatrix4f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFMatrix4f'
    DEFAULT_VALUE = (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){15}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFMatrix4f(value)

class MFMatrix4f(_X3DField):
    """
    MFMatrix4f specifies zero or more 4x4 matrices of single-precision floating point numbers, organized in row-major fashion.
    """
    __name__ = 'MFMatrix4f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFMatrix4fAndMFMatrix4f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFMatrix4f'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){15}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFMatrix4f(value)

class SFNode(_X3DField):
    """
    The SFNode field specifies an X3D node; the default empty value of an uninitialized SFNode field is sometimes described as NULL.
    """
    __name__ = 'SFNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFNodeAndMFNode'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFNode'
    DEFAULT_VALUE = None
    FIELD_DECLARATIONS = [('value', 'None', 'SFNode', 'inputOutput')]
    regex = r'' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFNode(value)

class MFNode(_X3DField):
    """
    The MFNode field specifies zero or more nodes; the default value of an MFNode field is the empty list.
    """
    __name__ = 'MFNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFNodeAndMFNode'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFNode'
    DEFAULT_VALUE = list()
    FIELD_DECLARATIONS = [('value', None, 'MFNode', 'inputOutput')]
    regex = r'' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFNode(value)
    def getValue(self): # workaround string-getter utility method, since regular repl function not handling properly
        result = '['
        for each in self.value:
            result += str(each) + ', '
        return result.rstrip(', ') + ']'

class SFRotation(_X3DField):
    """
    SFRotation is an axis-angle 4-tuple, indicating X-Y-Z direction axis plus angle orientation about that axis.
    """
    __name__ = 'SFRotation'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFRotationAndMFRotation'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFRotation'
    DEFAULT_VALUE = (0, 0, 1, 0)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){3}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFRotation(value)

class MFRotation(_X3DField):
    """
    MFRotation is an array of SFRotation values.
    """
    __name__ = 'MFRotation'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFRotationAndMFRotation'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFRotation'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){3}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFRotation(value)

class SFString(_X3DField):
    """
    SFString defines a single string encoded with the UTF-8 universal character set.
    """
    __name__ = 'SFString'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFStringAndMFString'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFString'
    DEFAULT_VALUE = ''
    regex = r'(\s|\S)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFString(value)

class MFString(_X3DField):
    """
    MFString is an array of SFString values, each "quoted" and separated by whitespace.
    """
    __name__ = 'MFString'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFStringAndMFString'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFString'
    DEFAULT_VALUE = list()
    regex = r'(\s|\S)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFString(value)

class SFTime(_X3DField):
    """
    The SFTime field specifies a single time value.
    """
    __name__ = 'SFTime'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFTimeAndMFTime'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFTime'
    DEFAULT_VALUE = -1.0
    regex = r'(\s)*([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)(\s)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFTime(value)

class MFTime(_X3DField):
    """
    MFTime is an array of SFTime values.
    """
    __name__ = 'MFTime'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFTimeAndMFTime'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFTime'
    DEFAULT_VALUE = list()
    regex = r'(\s)*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFTime(value)

class SFVec2d(_X3DField):
    """
    SFVec2d is a 2-tuple pair of SFDouble values.
    """
    __name__ = 'SFVec2d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec2dAndMFVec2d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFVec2d'
    DEFAULT_VALUE = (0.0, 0.0)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){1}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFVec2d(value)

class MFVec2d(_X3DField):
    """
    MFVec2d is an array of SFVec2d values.
    """
    __name__ = 'MFVec2d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec2dAndMFVec2d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFVec2d'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){1}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFVec2d(value)

class SFVec2f(_X3DField):
    """
    SFVec2f is a 2-tuple pair of SFFloat values.
    """
    __name__ = 'SFVec2f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec2fAndMFVec2f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFVec2f'
    DEFAULT_VALUE = (0.0, 0.0)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){1}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFVec2f(value)

class MFVec2f(_X3DField):
    """
    MFVec2f is an array of SFVec2f values.
    """
    __name__ = 'MFVec2f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec2fAndMFVec2f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFVec2f'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){1}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFVec2f(value)

class SFVec3d(_X3DField):
    """
    SFVec3d is a 3-tuple triplet of SFDouble values.
    """
    __name__ = 'SFVec3d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec3dAndMFVec3d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFVec3d'
    DEFAULT_VALUE = (0.0, 0.0, 0.0)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){2}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFVec3d(value)

class MFVec3d(_X3DField):
    """
    MFVec3d is an array of SFVec3d values.
    """
    __name__ = 'MFVec3d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec3dAndMFVec3d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFVec3d'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){2}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFVec3d(value)

class SFVec3f(_X3DField):
    """
    SFVec3f is a 3-tuple triplet of SFFloat values.
    """
    __name__ = 'SFVec3f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec3fAndMFVec3f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFVec3f'
    DEFAULT_VALUE = (0.0, 0.0, 0.0)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){2}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFVec3f(value)

class MFVec3f(_X3DField):
    """
    MFVec3f is an array of SFVec3f values.
    """
    __name__ = 'MFVec3f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec3fAndMFVec3f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFVec3f'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){2}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFVec3f(value)

class SFVec4d(_X3DField):
    """
    SFVec4d is a 4-tuple set of double-precision floating-point values, specifying a 3D homogeneous vector.
    """
    __name__ = 'SFVec4d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec4dAndMFVec4d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFVec4d'
    DEFAULT_VALUE = (0.0, 0.0, 0.0, 0.0)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){3}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFVec4d(value)

class MFVec4d(_X3DField):
    """
    MFVec4d is zero or more SFVec4d values.
    """
    __name__ = 'MFVec4d'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec4dAndMFVec4d'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFVec4d'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){3}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFVec4d(value)

class SFVec4f(_X3DField):
    """
    SFVec4f is a 4-tuple set of single-precision floating-point values, specifying a 3D homogeneous vector.
    """
    __name__ = 'SFVec4f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec4fAndMFVec4f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SFVec4f'
    DEFAULT_VALUE = (0.0, 0.0, 0.0, 0.0)
    regex = r'\s*(([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){3}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidSFVec4f(value)

class MFVec4f(_X3DField):
    """
    MFVec4f is zero or more SFVec4f values.
    """
    __name__ = 'MFVec4f'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/fieldsDef.html#SFVec4fAndMFVec4f'
    tooltipUrl = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MFVec4f'
    DEFAULT_VALUE = (list())
    regex = r'\s*((([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s+){3}([+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([Ee][+-]?[0-9]+)?)\s*,?\s*)*' # XML regex has lower-case true, false
    def __init__(self, value=None):
        self.value = value
    @property # - - - - - - - - - - - - -
    def value(self):
        return self.__value
    @value.setter
    def value(self, value=None):
        if  value is None:
            value = self.DEFAULT_VALUE
        self.__value = value
        isValidMFVec4f(value)

###############################################

# Abstract Node Types

# Note that these package-internal class names are preceded by an underscore _ character since X3D authors are not expected to use them

class _X3DNode(object):
    """
    All instantiable nodes implement X3DNode, which corresponds to SFNode in the X3D specification.
    """
    __name__ = '_X3DNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#X3DNode'
    def __init__(self, DEF="", USE="", class_="", metadata=None, IS=None):
        self.DEF = DEF
        self.USE = USE
        self.class_ = class_
        self.IS = IS
        self.metadata = metadata
        # if _DEBUG: print ('... in X3DNode __init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        @property # - - - - - - - - - - - - -
        def DEF(self):
            return self.__DEF
        @DEF.setter
        def DEF(self, DEF=None):
            if  DEF is None:
                DEF = SFString.DEFAULT_VALUE
            isValidSFString(DEF)
            self.__DEF = DEF
        @property # - - - - - - - - - - - - -
        def USE(self):
            return self.__USE
        @USE.setter
        def USE(self, USE=None):
            if  USE is None:
                USE = SFString.DEFAULT_VALUE
            isValidSFString(USE)
            self.__USE = USE
        @property # - - - - - - - - - - - - -
        def class_(self):
            return self.__class_
        @class_.setter
        def class_(self, class_=None):
            if  class_ is None:
                class_ = SFString.DEFAULT_VALUE
            isValidSFString(class_)
            self.__class_ = class_
        @property # - - - - - - - - - - - - -
        def IS(self):
            return self.__IS
        @IS.setter
        def IS(self, IS=None):
            if  IS is None:
                IS = SFNode.DEFAULT_VALUE
            isValidSFNode(IS)
            if not isinstance(IS, object):
                raise RuntimeError(str(IS) + ' does not have a valid node type object')
            self.__IS = IS
        @property # - - - - - - - - - - - - -
        def metadata(self):
            return self.__metadata
        @metadata.setter
        def metadata(self, metadata=None):
            if  metadata is None:
                metadata = SFNode.DEFAULT_VALUE
            isValidSFNode(metadata)
            if not isinstance(metadata, object):
                raise RuntimeError(str(metadata) + ' does not have a valid node type object')
            self.__metadata = metadata
    def __repl__(self):
        result = self.__name__ + '('
        # TODO put DEF first, matching canonical form
        for each in self.FIELD_DECLARATIONS:
            # if _DEBUG: print(self.__name__ + ' for each in self.FIELD_DECLARATIONS: each=' + str(each))
            name = each[0]
            default = each[1]
            type = each[2]
            accessType = each[3]
            value = getattr(self, name)
            # if _DEBUG: print ('gettattr(self, ' + str(name) + ') value="' + str(value) + '" for FIELD_DECLARATIONS ' + str(each) + ')')
            if value != default:
                # consider whether indentation is useful; probably not
                # print ("\n\t")
                if  isinstance(value, list): # avoid TypeError if value is not iterable
                    result += str(name) + '=['
                    for each in value:
                        result += str(each) + ', '
                        # if _DEBUG: print ('debug: str(each)=' + str(each))
                    result = result.rstrip(', ')
                    result += '],'
                elif isinstance(value, str) and "'" in value:
                    result += str(name) + '=' + '"' + str(value) + '"' + ','
                elif isinstance(value, str) and value != default:
                    result += str(name) + '=' + "'" + str(value) + "'" + ','
                elif value != default:
                    result += str(name) + '='       + str(value)       + ','
                # elif _DEBUG:
                #   result += str(name) + '=' + "'" + str(value) + "'" + ','
        return result.strip().rstrip(',').rstrip(', ') + ')'
    def __str__(self):
        return self.__repl__().strip() # X3DNode

class _X3DChildNode(_X3DNode):
    """
    A node that implements X3DChildNode is one of the legal children for a X3DGroupingNode parent.
    """
    __name__ = '_X3DChildNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#X3DChildNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DChildNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTimeDependentNode(_X3DChildNode):
    """
    Base type from which all time-dependent nodes are derived.
    """
    __name__ = '_X3DTimeDependentNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/time.html#X3DTimeDependentNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTimeDependentNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DGeometryNode(_X3DNode):
    """
    Geometry nodes produce renderable geometry and are contained by a Shape node.
    """
    __name__ = '_X3DGeometryNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#X3DGeometryNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DGeometryNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DParametricGeometryNode(_X3DGeometryNode):
    """
    Base type for all geometry node types that are created parametrically and use control points to describe the final shape of the surface.
    """
    __name__ = '_X3DParametricGeometryNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#X3DParametricGeometryNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DParametricGeometryNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DAppearanceChildNode(_X3DNode):
    """
    Nodes of this type can be used as child nodes for Appearance.
    """
    __name__ = '_X3DAppearanceChildNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#X3DAppearanceChildNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DAppearanceChildNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTextureNode(_X3DAppearanceChildNode):
    """
    Base type for all nodes which specify sources for texture images.
    """
    __name__ = '_X3DTextureNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#X3DTextureNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTextureNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DSensorNode(_X3DChildNode):
    """
    Base type for all sensors.
    """
    __name__ = '_X3DSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#X3DSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DPointingDeviceSensorNode(_X3DSensorNode):
    """
    Base type for all pointing device sensors.
    """
    __name__ = '_X3DPointingDeviceSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/pointingsensor.html#X3DPointingDeviceSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DPointingDeviceSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DVolumeRenderStyleNode(_X3DNode):
    """
    The X3DVolumeRenderStyleNode abstract node type is the base type for all node types that specify a specific visual rendering style to be used when rendering volume data.
    """
    __name__ = '_X3DVolumeRenderStyleNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#X3DVolumeRenderStyleNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DVolumeRenderStyleNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DGeometricPropertyNode(_X3DNode):
    """
    Base type for all geometric property node types.
    """
    __name__ = '_X3DGeometricPropertyNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#X3DGeometricPropertyNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DGeometricPropertyNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DFollowerNode(_X3DChildNode):
    """
    X3DFollowerNode is the abstract base class for all nodes in the Followers component.
    """
    __name__ = '_X3DFollowerNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#X3DFollowerNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DFollowerNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DBindableNode(_X3DChildNode):
    """
    Bindable nodes implement the binding stack, so that only one of each node type is active at a given time.
    """
    __name__ = '_X3DBindableNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#X3DBindableNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DBindableNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DAppearanceNode(_X3DNode):
    """
    Base type for all Appearance nodes.
    """
    __name__ = '_X3DAppearanceNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#X3DAppearanceNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DAppearanceNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DBackgroundNode(_X3DBindableNode):
    """
    Abstract type from which all backgrounds inherit, also defining a background binding stack.
    """
    __name__ = '_X3DBackgroundNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/enveffects.html#X3DBackgroundNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DBackgroundNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DChaserNode(_X3DFollowerNode):
    """
    The X3DChaserNode abstract node type calculates the output on value_changed as a finite impulse response (FIR) based on the events received on set_destination field.
    """
    __name__ = '_X3DChaserNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#X3DChaserNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DChaserNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DColorNode(_X3DGeometricPropertyNode):
    """
    Base type for color specifications in X3D.
    """
    __name__ = '_X3DColorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#X3DColorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DColorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DComposableVolumeRenderStyleNode(_X3DVolumeRenderStyleNode):
    """
    The X3DComposableVolumeRenderStyleNode abstract node type is the base type for all node types that allow rendering styles to be sequentially composed together to form a single renderable output.
    """
    __name__ = '_X3DComposableVolumeRenderStyleNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#X3DComposableVolumeRenderStyleNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DComposableVolumeRenderStyleNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DComposedGeometryNode(_X3DGeometryNode):
    """
    Composed geometry nodes produce renderable geometry, can contain Color Coordinate Normal TextureCoordinate, and are contained by a Shape node.
    """
    __name__ = '_X3DComposedGeometryNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#X3DComposedGeometryNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DComposedGeometryNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DCoordinateNode(_X3DGeometricPropertyNode):
    """
    Base type for all coordinate node types in X3D.
    """
    __name__ = '_X3DCoordinateNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#X3DCoordinateNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DCoordinateNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DDamperNode(_X3DFollowerNode):
    """
    The X3DDamperNode abstract node type creates an IIR response that approaches the destination value according to the shape of the e-function only asymptotically but very quickly.
    """
    __name__ = '_X3DDamperNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#X3DDamperNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DDamperNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DDragSensorNode(_X3DPointingDeviceSensorNode):
    """
    Base type for all drag-style pointing device sensors.
    """
    __name__ = '_X3DDragSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/pointingsensor.html#X3DDragSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DDragSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DEnvironmentalSensorNode(_X3DSensorNode):
    """
    Base type for the environmental sensor nodes ProximitySensor, TransformSensor and VisibilitySensor.
    """
    __name__ = '_X3DEnvironmentalSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/envsensor.html#X3DEnvironmentalSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DEnvironmentalSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DEnvironmentTextureNode(_X3DTextureNode):
    """
    Base type for all nodes that specify cubic environment map sources for texture images.
    """
    __name__ = '_X3DEnvironmentTextureNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/env_texture.html#X3DEnvironmentTextureNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DEnvironmentTextureNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DFontStyleNode(_X3DNode):
    """
    Base type for all font style nodes.
    """
    __name__ = '_X3DFontStyleNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/text.html#X3DFontStyleNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DFontStyleNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DGroupingNode(_X3DChildNode):
    """
    Grouping nodes can contain other nodes as children, thus making up the backbone of a scene graph.
    """
    __name__ = '_X3DGroupingNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/group.html#X3DGroupingNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DGroupingNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DInfoNode(_X3DChildNode):
    """
    Base type for all nodes that contain only information without visual semantics.
    """
    __name__ = '_X3DInfoNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/group.html#X3DInfoNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DInfoNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DInterpolatorNode(_X3DChildNode):
    """
    Interpolator nodes are designed for linear keyframed animation. Interpolators are driven by an input key ranging [0..1] and produce corresponding piecewise-linear output functions.
    """
    __name__ = '_X3DInterpolatorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#X3DInterpolatorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DInterpolatorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DKeyDeviceSensorNode(_X3DSensorNode):
    """
    Base type for all sensor node types that operate using key devices.
    """
    __name__ = '_X3DKeyDeviceSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/keyboard.html#X3DKeyDeviceSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DKeyDeviceSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DLayerNode(_X3DNode):
    """
    The X3DLayerNode abstract node type is the base node type for layer nodes.
    """
    __name__ = '_X3DLayerNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layering.html#X3DLayerNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DLayerNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DLayoutNode(_X3DChildNode):
    """
    X3DLayoutNode is the base node type for layout nodes.
    """
    __name__ = '_X3DLayoutNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layout.html#X3DLayoutNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DLayoutNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DLightNode(_X3DChildNode):
    """
    Light nodes provide illumination for rendering geometry in the scene. Implementing nodes must include a global field with type SFBool and accessType inputOutput.
    """
    __name__ = '_X3DLightNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/lighting.html#X3DLightNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DLightNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DMaterialNode(_X3DAppearanceChildNode):
    """
    Base type for all Material nodes.
    """
    __name__ = '_X3DMaterialNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#X3DMaterialNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DMaterialNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DNBodyCollidableNode(_X3DChildNode):
    """
    The X3DNBodyCollidableNode abstract node type represents objects that act as the interface between the rigid body physics, collision geometry proxy, and renderable objects in the scene graph hierarchy.
    """
    __name__ = '_X3DNBodyCollidableNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#X3DNBodyCollidableNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DNBodyCollidableNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DNBodyCollisionSpaceNode(_X3DNode):
    """
    The X3DNBodyCollisionSpaceNode abstract node type represents objects that act as a self-contained spatial collection of objects that can interact through collision detection routines.
    """
    __name__ = '_X3DNBodyCollisionSpaceNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#X3DNBodyCollisionSpaceNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DNBodyCollisionSpaceNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DNetworkSensorNode(_X3DSensorNode):
    """
    Base typefor all sensors that generate events based on network activity.
    """
    __name__ = '_X3DNetworkSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/networking.html#X3DNetworkSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DNetworkSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DNormalNode(_X3DGeometricPropertyNode):
    """
    Base type for all normal node types in X3D.
    """
    __name__ = '_X3DNormalNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#X3DNormalNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DNormalNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DNurbsControlCurveNode(_X3DNode):
    """
    Base type for all nodes that provide control curve information in 2D space.
    """
    __name__ = '_X3DNurbsControlCurveNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#X3DNurbsControlCurveNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DNurbsControlCurveNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DNurbsSurfaceGeometryNode(_X3DParametricGeometryNode):
    """
    Abstract geometry type for all types of NURBS surfaces.
    """
    __name__ = '_X3DNurbsSurfaceGeometryNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#X3DNurbsSurfaceGeometryNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DNurbsSurfaceGeometryNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DParticleEmitterNode(_X3DNode):
    """
    The X3DParticleEmitterNode abstract type represents any node that is an emitter of particles.
    """
    __name__ = '_X3DParticleEmitterNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#X3DParticleEmitterNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DParticleEmitterNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DParticlePhysicsModelNode(_X3DNode):
    """
    The X3DParticlePhysicsModelNode abstract type represents any node that applies a form of constraints on the particles after they have been generated.
    """
    __name__ = '_X3DParticlePhysicsModelNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#X3DParticlePhysicsModelNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DParticlePhysicsModelNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DPickSensorNode(_X3DSensorNode):
    """
    The X3DPickSensorNode abstract node type is the base node type that represents the lowest common denominator of picking capabilities.
    """
    __name__ = '_X3DPickSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/picking.html#X3DPickSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DPickSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DProductStructureChildNode(_X3DChildNode):
    """
    Base type marking nodes that are valid product structure children for the CADGeometry component.
    """
    __name__ = '_X3DProductStructureChildNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/CADGeometry.html#X3DProductStructureChildNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DProductStructureChildNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DPrototypeInstance(_X3DNode):
    """
    Base type for all prototype instances. Note that direct children nodes are disallowed, instead let fieldValue with type SFNode/MFNode contain them. Current practice is that, if desired, prototype authors must explicitly add the metadata SFNode field in the ProtoInterface.
    """
    __name__ = '_X3DPrototypeInstance'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#X3DPrototypeInstance'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DPrototypeInstance __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DRigidJointNode(_X3DNode):
    """
    The X3DRigidJointNode abstract node type is the base type for all joint types.
    """
    __name__ = '_X3DRigidJointNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#X3DRigidJointNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DRigidJointNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DScriptNode(_X3DChildNode):
    """
    Base type for scripting nodes (but not shader nodes).
    """
    __name__ = '_X3DScriptNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/scripting.html#X3DScriptNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DScriptNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DSequencerNode(_X3DChildNode):
    """
    Base type from which all Sequencers are derived.
    """
    __name__ = '_X3DSequencerNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#X3DSequencerNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DSequencerNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DShaderNode(_X3DAppearanceChildNode):
    """
    Base type for all nodes that specify a programmable shader.
    """
    __name__ = '_X3DShaderNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#X3DShaderNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DShaderNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DShapeNode(_X3DChildNode):
    """
    Base type for all Shape nodes.
    """
    __name__ = '_X3DShapeNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#X3DShapeNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DShapeNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DSoundNode(_X3DChildNode):
    """
    Base type for all sound nodes.
    """
    __name__ = '_X3DSoundNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/sound.html#X3DSoundNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DSoundNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DSoundSourceNode(_X3DTimeDependentNode):
    """
    Nodes implementing X3DSoundSourceNode are allowed as children of Sound node.
    """
    __name__ = '_X3DSoundSourceNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/sound.html#X3DSoundSourceNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DSoundSourceNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTexture2DNode(_X3DTextureNode):
    """
    Base type for all nodes which specify 2D sources for texture images.
    """
    __name__ = '_X3DTexture2DNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#X3DTexture2DNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTexture2DNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTexture3DNode(_X3DTextureNode):
    """
    Base type for all nodes that specify 3D sources for texture images.
    """
    __name__ = '_X3DTexture3DNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#X3DTexture3DNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTexture3DNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTextureCoordinateNode(_X3DGeometricPropertyNode):
    """
    Base type for all nodes which specify texture coordinates.
    """
    __name__ = '_X3DTextureCoordinateNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#X3DTextureCoordinateNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTextureCoordinateNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTextureTransformNode(_X3DAppearanceChildNode):
    """
    Base type for all nodes which specify a transformation of texture coordinates.
    """
    __name__ = '_X3DTextureTransformNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#X3DTextureTransformNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTextureTransformNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTouchSensorNode(_X3DPointingDeviceSensorNode):
    """
    Base type for all touch-style pointing device sensors.
    """
    __name__ = '_X3DTouchSensorNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/pointingsensor.html#X3DTouchSensorNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTouchSensorNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DTriggerNode(_X3DChildNode):
    """
    Base type from which all trigger nodes are derived.
    """
    __name__ = '_X3DTriggerNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#X3DTriggerNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DTriggerNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DVertexAttributeNode(_X3DGeometricPropertyNode):
    """
    Base type for all nodes that specify per-vertex attribute information to the shader.
    """
    __name__ = '_X3DVertexAttributeNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#X3DVertexAttributeNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DVertexAttributeNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DViewpointNode(_X3DBindableNode):
    """
    Node type X3DViewpointNode defines a specific location in the local coordinate system from which the user may view the scene, and also defines a viewpoint binding stack.
    """
    __name__ = '_X3DViewpointNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#X3DViewpointNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DViewpointNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DViewportNode(_X3DGroupingNode):
    """
    The X3DViewportNode abstract node type is the base node type for viewport nodes.
    """
    __name__ = '_X3DViewportNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layering.html#X3DViewportNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DViewportNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DVolumeDataNode(_X3DChildNode):
    """
    The X3DVolumeDataNode abstract node type is the base type for all node types that describe volumetric data to be rendered.
    """
    __name__ = '_X3DVolumeDataNode'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#X3DVolumeDataNode'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractNodeType X3DVolumeDataNode __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

###############################################

# Abstract Object Types

# Note that these package-internal class names are preceded by an underscore _ character since X3D authors are not expected to use them

class _X3DBoundedObject(_X3DNode):
    """
    X3DBoundedObject indicates that bounding box values can be provided (or computed) to encompass this node and any children.
    """
    __name__ = '_X3DBoundedObject'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/group.html#X3DBoundedObject'

class _X3DFogObject(_X3DNode):
    """
    Abstract type describing a node that influences the lighting equation through the use of fog semantics.
    """
    __name__ = '_X3DFogObject'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/enveffects.html#X3DFogOjbect'

class _X3DMetadataObject(_X3DNode):
    """
    Each node inheriting the X3DMetadataObject interface contains a single array of strictly typed values: MFBool, MFInt32, MFFloat, MFDouble, MFString, or MFNode, the latter having children that are all Metadata nodes.
    """
    __name__ = '_X3DMetadataObject'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#X3DMetadataObject'
    def __init__(self, DEF, USE, class_, IS, metadata):
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        # if _DEBUG: print ('... in AbstractObjectType X3DMetadataObject __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')

class _X3DPickableObject(_X3DNode):
    """
    The X3DPickableObject abstract object type marks a node as being capable of having customized picking performed on its contents or children.
    """
    __name__ = '_X3DPickableObject'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/picking.html#X3DPickableObject'

class _X3DProgrammableShaderObject(_X3DNode):
    """
    Base type for all nodes that specify arbitrary fields for interfacing with per-object attribute values.
    """
    __name__ = '_X3DProgrammableShaderObject'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#X3DProgrammableShaderObject'

class _X3DUrlObject(_X3DNode):
    """
    X3DUrlObject indicates that a node has content loaded from a Uniform Resource Locator (URL) and can be tracked via a LoadSensor. Such child nodes have containerField='watchList' to indicate their relationship to the parent LoadSensor node.
    """
    __name__ = '_X3DUrlObject'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/networking.html#X3DUrlObject'

###############################################

# Statements

class _X3DStatement(object):
    """
    All X3D statements implement _X3DStatement abstract type.
    """
    __name__ = '_X3DStatement'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#AbstractX3DStructure'
    def __repl__(self):
        result = self.__name__ + '('
        # if _DEBUG: print(self.__name__ + ' self.FIELD_DECLARATIONS: ' + str(self.FIELD_DECLARATIONS))
        for each in self.FIELD_DECLARATIONS:
            # if _DEBUG: print(self.__name__ + ' for each in self.FIELD_DECLARATIONS: each=' + str(each))
            name = each[0]
            default = each[1]
            type = each[2]
            accessType = each[3]
            value = getattr(self, name)
            # if _DEBUG: print ('gettattr(self, ' + str(name) + ') value="' + str(value) + '" for FIELD_DECLARATIONS ' + str(each) + ')')
            if value != default:
                # TODO consider whether indentation is useful
                #     print ("\n\t")
                if  isinstance(value, list): # avoid TypeError if value is not iterable
                    result += str(name) + '=['
                    for each in value:
                        result += str(each) + ', '
                        # if _DEBUG: print ('debug: str(each)=' + str(each))
                    result = result.rstrip(', ')
                    result += '],'
                elif isinstance(value, str) and "'" in value:
                    result += str(name) + '=' + '"' + str(value) + '"' + ','
                elif isinstance(value, str) and value != default:
                    result += str(name) + '=' + "'" + str(value) + "'" + ','
                elif value != default:
                    result += str(name) + '='       + str(value)       + ','
                # elif _DEBUG:
                #   result += str(name) + '=' + "'" + str(value) + "'" + ','
        return result.strip().rstrip(',').rstrip(', ') + ')'
    def __str__(self):
        return self.__repl__().strip() # _X3DStatement

def isX3DStatement(value):
    return isinstance(value, _X3DStatement)

class component(_X3DStatement):
    """
    Functional summary: each added component statement indicates needed scene functionality support above the given X3D profile.
    """
    __name__ = 'component'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/concepts.html#Components'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#component'
    FIELD_DECLARATIONS = [('level', 1, 'SFInt32', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput')]
    def __init__(self,
                 level=1,
                 name=''):
        self.level = level
        self.name = name
        @property # - - - - - - - - - - - - -
        def level(self):
            return self.__level
        @level.setter
        def level(self, level=None):
            if  level is None:
                level = SFInt32.DEFAULT_VALUE
            isValidSFInt32(level)
            self.__level = level
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name

class connect(_X3DStatement):
    """
    Functional summary: connect statements define event-routing connections between node fields defined inside a ProtoBody declaration back to corresponding ProtoInterface fields.
    """
    __name__ = 'connect'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#IS_ConnectStatementSyntax'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#connect'
    FIELD_DECLARATIONS = [('nodeField', '', 'SFString', 'inputOutput'),
                          ('protoField', '', 'SFString', 'inputOutput')]
    def __init__(self,
                 nodeField='',
                 protoField=''):
        self.nodeField = nodeField
        self.protoField = protoField
        @property # - - - - - - - - - - - - -
        def nodeField(self):
            return self.__nodeField
        @nodeField.setter
        def nodeField(self, nodeField=None):
            if  nodeField is None:
                nodeField = SFString.DEFAULT_VALUE
            isValidSFString(nodeField)
            self.__nodeField = nodeField
        @property # - - - - - - - - - - - - -
        def protoField(self):
            return self.__protoField
        @protoField.setter
        def protoField(self, protoField=None):
            if  protoField is None:
                protoField = SFString.DEFAULT_VALUE
            isValidSFString(protoField)
            self.__protoField = protoField

class EXPORT(_X3DStatement):
    """
    Functional summary: EXPORT exposes a local node for ROUTE passing of event values when the current Scene is included via Inline by a parent external world. These connections allow event values to be exchanged via ROUTE statements between a parent model and a child Inline model.
    """
    __name__ = 'EXPORT'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/concepts.html#EXPORTSemantics'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#EXPORT'
    FIELD_DECLARATIONS = [('AS', '', 'SFString', 'inputOutput'),
                          ('localDEF', '', 'SFString', 'inputOutput')]
    def __init__(self,
                 AS='',
                 localDEF=''):
        self.AS = AS
        self.localDEF = localDEF
        @property # - - - - - - - - - - - - -
        def AS(self):
            return self.__AS
        @AS.setter
        def AS(self, AS=None):
            if  AS is None:
                AS = SFString.DEFAULT_VALUE
            isValidSFString(AS)
            self.__AS = AS
        @property # - - - - - - - - - - - - -
        def localDEF(self):
            return self.__localDEF
        @localDEF.setter
        def localDEF(self, localDEF=None):
            if  localDEF is None:
                localDEF = SFString.DEFAULT_VALUE
            isValidSFString(localDEF)
            self.__localDEF = localDEF

class ExternProtoDeclare(_X3DStatement):
    """
    ExternProtoDeclare refers to a ProtoDeclare node declaration provided in another file. ExternProtoDeclare interfaces are defined by field statements (and without IS/connect statements).
    """
    __name__ = 'ExternProtoDeclare'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/concepts.html#Externalprototypesemantics'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ExternProtoDeclare'
    FIELD_DECLARATIONS = [('appinfo', '', 'SFString', 'inputOutput'),
                          ('documentation', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('field', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 appinfo='',
                 documentation='',
                 name='',
                 url=list(),
                 field=list()):
        self.appinfo = appinfo
        self.documentation = documentation
        self.name = name
        self.url = url
        self.field = field
        @property # - - - - - - - - - - - - -
        def appinfo(self):
            return self.__appinfo
        @appinfo.setter
        def appinfo(self, appinfo=None):
            if  appinfo is None:
                appinfo = SFString.DEFAULT_VALUE
            isValidSFString(appinfo)
            self.__appinfo = appinfo
        @property # - - - - - - - - - - - - -
        def documentation(self):
            return self.__documentation
        @documentation.setter
        def documentation(self, documentation=None):
            if  documentation is None:
                documentation = SFString.DEFAULT_VALUE
            isValidSFString(documentation)
            self.__documentation = documentation
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def field(self):
            return self.__field
        @field.setter
        def field(self, field=None):
            if  field is None:
                field = MFNode.DEFAULT_VALUE
            isValidMFNode(field)
            self.__field = field

class field(_X3DStatement):
    """
    Functional summary: a field statement defines an interface attribute or node. Each field statement can contain either attribute-value or node content.
    """
    __name__ = 'field'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#NodeAndFieldStatementSyntax'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#field'
    FIELD_DECLARATIONS = [('accessType', '', 'SFString', 'inputOutput'),
                          ('appinfo', '', 'SFString', 'inputOutput'),
                          ('documentation', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('type', '', 'SFString', 'inputOutput'),
                          ('value', '', 'SFString', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 accessType='',
                 appinfo='',
                 documentation='',
                 name='',
                 type='',
                 value='',
                 children=list()):
        self.accessType = accessType
        self.appinfo = appinfo
        self.documentation = documentation
        self.name = name
        self.type = type
        self.value = value
        self.children = children
        @property # - - - - - - - - - - - - -
        def accessType(self):
            return self.__accessType
        @accessType.setter
        def accessType(self, accessType=None):
            if  accessType is None:
                accessType = SFString.DEFAULT_VALUE
            isValidSFString(accessType)
            self.__accessType = accessType
        @property # - - - - - - - - - - - - -
        def appinfo(self):
            return self.__appinfo
        @appinfo.setter
        def appinfo(self, appinfo=None):
            if  appinfo is None:
                appinfo = SFString.DEFAULT_VALUE
            isValidSFString(appinfo)
            self.__appinfo = appinfo
        @property # - - - - - - - - - - - - -
        def documentation(self):
            return self.__documentation
        @documentation.setter
        def documentation(self, documentation=None):
            if  documentation is None:
                documentation = SFString.DEFAULT_VALUE
            isValidSFString(documentation)
            self.__documentation = documentation
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def type(self):
            return self.__type
        @type.setter
        def type(self, type=None):
            if  type is None:
                type = SFString.DEFAULT_VALUE
            isValidSFString(type)
            self.__type = type
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = SFString.DEFAULT_VALUE
            isValidSFString(value)
            self.__value = value
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class fieldValue(_X3DStatement):
    """
    Functional summary: a fieldValue statement re-initializes the default value of a field in a ProtoInstance. Each fieldValue statement can contain either attribute-value or node content.
    """
    __name__ = 'fieldValue'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#ProtoInstanceAndFieldValueStatement'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#fieldValue'
    FIELD_DECLARATIONS = [('name', '', 'SFString', 'inputOutput'),
                          ('value', '', 'SFString', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 name='',
                 value='',
                 children=list()):
        self.name = name
        self.value = value
        self.children = children
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = SFString.DEFAULT_VALUE
            isValidSFString(value)
            self.__value = value
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class head(_X3DStatement):
    """
    Functional summary: each X3D scene includes a head statement that can contain component, unit and meta statements.
    """
    __name__ = 'head'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#Header'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#head'
    FIELD_DECLARATIONS = [('children', None, 'MFNode', 'inputOutput')]
    def __init__(self, children=None):
        self.children = children
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class IMPORT(_X3DStatement):
    """
    Functional summary: IMPORT provides ROUTE access to a node that has a corresponding EXPORT statement within an Inline scene. These connections allow event values to be exchanged via ROUTE statements between a parent model and a child Inline model.
    """
    __name__ = 'IMPORT'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/concepts.html#IMPORTSemantics'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IMPORT'
    FIELD_DECLARATIONS = [('AS', '', 'SFString', 'inputOutput'),
                          ('importedDEF', '', 'SFString', 'inputOutput'),
                          ('inlineDEF', '', 'SFString', 'inputOutput')]
    def __init__(self,
                 AS='',
                 importedDEF='',
                 inlineDEF=''):
        self.AS = AS
        self.importedDEF = importedDEF
        self.inlineDEF = inlineDEF
        @property # - - - - - - - - - - - - -
        def AS(self):
            return self.__AS
        @AS.setter
        def AS(self, AS=None):
            if  AS is None:
                AS = SFString.DEFAULT_VALUE
            isValidSFString(AS)
            self.__AS = AS
        @property # - - - - - - - - - - - - -
        def importedDEF(self):
            return self.__importedDEF
        @importedDEF.setter
        def importedDEF(self, importedDEF=None):
            if  importedDEF is None:
                importedDEF = SFString.DEFAULT_VALUE
            isValidSFString(importedDEF)
            self.__importedDEF = importedDEF
        @property # - - - - - - - - - - - - -
        def inlineDEF(self):
            return self.__inlineDEF
        @inlineDEF.setter
        def inlineDEF(self, inlineDEF=None):
            if  inlineDEF is None:
                inlineDEF = SFString.DEFAULT_VALUE
            isValidSFString(inlineDEF)
            self.__inlineDEF = inlineDEF

class IS(_X3DStatement):
    """
    Functional summary: the IS statement connects node fields defined inside a ProtoBody declaration back to corresponding ProtoInterface fields. IS/connect statements can be added if the parent node is within a ProtoBody and connect statements define correspondences between prototype fields and built-in node fields.
    """
    __name__ = 'IS'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/concepts.html#PROTOdefinitionsemantics'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IS'
    FIELD_DECLARATIONS = [('connect', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 connect=list()):
        self.connect = connect
        @property # - - - - - - - - - - - - -
        def connect(self):
            return self.__connect
        @connect.setter
        def connect(self, connect=None):
            if  connect is None:
                connect = MFNode.DEFAULT_VALUE
            isValidMFNode(connect)
            self.__connect = connect

class meta(_X3DStatement):
    """
    Functional summary: the meta statement provides metadata information about a scene, where name and content attributes provide attribute=value metadata pairs.
    """
    __name__ = 'meta'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#Header'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#meta'
    FIELD_DECLARATIONS = [('content', '', 'SFString', 'inputOutput'),
                          ('dir', '', 'SFString', 'inputOutput'),
                          ('httpequiv', '', 'SFString', 'inputOutput'),
                          ('lang', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('scheme', '', 'SFString', 'inputOutput')]
    def __init__(self,
                 content='',
                 dir='',
                 httpequiv='',
                 lang='',
                 name='',
                 scheme=''):
        self.content = content
        self.dir = dir
        self.httpequiv = httpequiv
        self.lang = lang
        self.name = name
        self.scheme = scheme
        @property # - - - - - - - - - - - - -
        def content(self):
            return self.__content
        @content.setter
        def content(self, content=None):
            if  content is None:
                content = SFString.DEFAULT_VALUE
            isValidSFString(content)
            self.__content = content
        @property # - - - - - - - - - - - - -
        def dir(self):
            return self.__dir
        @dir.setter
        def dir(self, dir=None):
            if  dir is None:
                dir = SFString.DEFAULT_VALUE
            isValidSFString(dir)
            self.__dir = dir
        @property # - - - - - - - - - - - - -
        def httpequiv(self):
            return self.__httpequiv
        @httpequiv.setter
        def httpequiv(self, httpequiv=None):
            if  httpequiv is None:
                httpequiv = SFString.DEFAULT_VALUE
            isValidSFString(httpequiv)
            self.__httpequiv = httpequiv
        @property # - - - - - - - - - - - - -
        def lang(self):
            return self.__lang
        @lang.setter
        def lang(self, lang=None):
            if  lang is None:
                lang = SFString.DEFAULT_VALUE
            isValidSFString(lang)
            self.__lang = lang
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def scheme(self):
            return self.__scheme
        @scheme.setter
        def scheme(self, scheme=None):
            if  scheme is None:
                scheme = SFString.DEFAULT_VALUE
            isValidSFString(scheme)
            self.__scheme = scheme

class ProtoBody(_X3DStatement):
    """
    ProtoBody contains the definition nodes for new Prototype nodes.
    """
    __name__ = 'ProtoBody'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#PrototypeAndFieldDeclarationSyntax'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ProtoBody'
    FIELD_DECLARATIONS = [('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 children=list()):
        self.children = children
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class ProtoDeclare(_X3DStatement):
    """
    ProtoDeclare defines new Prototype nodes. Nested ProtoDeclares and ProtoInstances are allowed by the specification.
    """
    __name__ = 'ProtoDeclare'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#PrototypeAndFieldDeclarationSyntax'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ProtoDeclare'
    FIELD_DECLARATIONS = [('appinfo', '', 'SFString', 'inputOutput'),
                          ('documentation', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('ProtoBody', None, 'SFNode', 'inputOutput'),
                          ('ProtoInterface', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 appinfo='',
                 documentation='',
                 name='',
                 ProtoBody=None,
                 ProtoInterface=None):
        self.appinfo = appinfo
        self.documentation = documentation
        self.name = name
        self.ProtoBody = ProtoBody
        self.ProtoInterface = ProtoInterface
        @property # - - - - - - - - - - - - -
        def appinfo(self):
            return self.__appinfo
        @appinfo.setter
        def appinfo(self, appinfo=None):
            if  appinfo is None:
                appinfo = SFString.DEFAULT_VALUE
            isValidSFString(appinfo)
            self.__appinfo = appinfo
        @property # - - - - - - - - - - - - -
        def documentation(self):
            return self.__documentation
        @documentation.setter
        def documentation(self, documentation=None):
            if  documentation is None:
                documentation = SFString.DEFAULT_VALUE
            isValidSFString(documentation)
            self.__documentation = documentation
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def ProtoBody(self):
            return self.__ProtoBody
        @ProtoBody.setter
        def ProtoBody(self, ProtoBody=None):
            if  ProtoBody is None:
                ProtoBody = SFNode.DEFAULT_VALUE
            isValidSFNode(ProtoBody)
            if not isinstance(ProtoBody, object):
                raise RuntimeError(str(ProtoBody) + ' does not have a valid node type object')
            self.__ProtoBody = ProtoBody
        @property # - - - - - - - - - - - - -
        def ProtoInterface(self):
            return self.__ProtoInterface
        @ProtoInterface.setter
        def ProtoInterface(self, ProtoInterface=None):
            if  ProtoInterface is None:
                ProtoInterface = SFNode.DEFAULT_VALUE
            isValidSFNode(ProtoInterface)
            if not isinstance(ProtoInterface, object):
                raise RuntimeError(str(ProtoInterface) + ' does not have a valid node type object')
            self.__ProtoInterface = ProtoInterface

class ProtoInterface(_X3DStatement):
    """
    ProtoInterface defines fields for new Prototype nodes.
    """
    __name__ = 'ProtoInterface'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#PrototypeAndFieldDeclarationSyntax'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ProtoInterface'
    FIELD_DECLARATIONS = [('field', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 field=list()):
        self.field = field
        @property # - - - - - - - - - - - - -
        def field(self):
            return self.__field
        @field.setter
        def field(self, field=None):
            if  field is None:
                field = MFNode.DEFAULT_VALUE
            isValidMFNode(field)
            self.__field = field

class ROUTE(_X3DStatement):
    """
    ROUTE connects output fields of event-producing nodes to input fields of event-consuming nodes.
    """
    __name__ = 'ROUTE'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/concepts.html#ModifyingObjectsRoutes'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ROUTE'
    FIELD_DECLARATIONS = [('fromField', '', 'SFString', 'inputOutput'),
                          ('fromNode', '', 'SFString', 'inputOutput'),
                          ('toField', '', 'SFString', 'inputOutput'),
                          ('toNode', '', 'SFString', 'inputOutput')]
    def __init__(self,
                 fromField='',
                 fromNode='',
                 toField='',
                 toNode=''):
        self.fromField = fromField
        self.fromNode = fromNode
        self.toField = toField
        self.toNode = toNode
        @property # - - - - - - - - - - - - -
        def fromField(self):
            return self.__fromField
        @fromField.setter
        def fromField(self, fromField=None):
            if  fromField is None:
                fromField = SFString.DEFAULT_VALUE
            isValidSFString(fromField)
            self.__fromField = fromField
        @property # - - - - - - - - - - - - -
        def fromNode(self):
            return self.__fromNode
        @fromNode.setter
        def fromNode(self, fromNode=None):
            if  fromNode is None:
                fromNode = SFString.DEFAULT_VALUE
            isValidSFString(fromNode)
            self.__fromNode = fromNode
        @property # - - - - - - - - - - - - -
        def toField(self):
            return self.__toField
        @toField.setter
        def toField(self, toField=None):
            if  toField is None:
                toField = SFString.DEFAULT_VALUE
            isValidSFString(toField)
            self.__toField = toField
        @property # - - - - - - - - - - - - -
        def toNode(self):
            return self.__toNode
        @toNode.setter
        def toNode(self, toNode=None):
            if  toNode is None:
                toNode = SFString.DEFAULT_VALUE
            isValidSFString(toNode)
            self.__toNode = toNode

class Scene(_X3DStatement):
    """
    Scene is the implicit root node of the X3D scene graph.
    """
    __name__ = 'Scene'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#Header'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Scene'
    FIELD_DECLARATIONS = [('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 children=list()):
        self.children = children
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class unit(_X3DStatement):
    """
    Functional summary: unit statement defines data-conversion factors for typed values defined in a scene.
    """
    __name__ = 'unit'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#UNITStatement'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#unit'
    FIELD_DECLARATIONS = [('category', '', 'SFString', 'initializeOnly'),
                          ('conversionFactor', 1.0, 'SFDouble', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput')]
    def __init__(self,
                 category='',
                 conversionFactor=1.0,
                 name=''):
        self.category = category
        self.conversionFactor = conversionFactor
        self.name = name
        @property # - - - - - - - - - - - - -
        def category(self):
            return self.__category
        @category.setter
        def category(self, category=None):
            if  category is None:
                category = SFString.DEFAULT_VALUE
            isValidSFString(category)
            self.__category = category
        @property # - - - - - - - - - - - - -
        def conversionFactor(self):
            return self.__conversionFactor
        @conversionFactor.setter
        def conversionFactor(self, conversionFactor=None):
            if  conversionFactor is None:
                conversionFactor = SFDouble.DEFAULT_VALUE
            isValidSFDouble(conversionFactor)
            self.__conversionFactor = conversionFactor
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name

class X3D(_X3DNode):
    """
    X3D is the root node for an Extensible 3D (X3D) Graphics model.
    """
    __name__ = 'X3D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#Header'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#X3D'
    FIELD_DECLARATIONS = [('profile', 'Immersive', 'SFString', 'inputOutput'),
                          ('version', '3.3', 'SFString', 'inputOutput'),
                          ('head', None, 'SFNode', 'inputOutput'),
                          ('Scene', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 profile='Immersive',
                 version='3.3',
                 head=None,
                 Scene=None):
        self.profile = profile
        self.version = version
        self.head = head
        self.Scene = Scene
        @property # - - - - - - - - - - - - -
        def profile(self):
            return self.__profile
        @profile.setter
        def profile(self, profile=None):
            if  profile is None:
                profile = SFString.DEFAULT_VALUE
            isValidSFString(profile)
            self.__profile = profile
        @property # - - - - - - - - - - - - -
        def version(self):
            return self.__version
        @version.setter
        def version(self, version=None):
            if  version is None:
                version = SFString.DEFAULT_VALUE
            isValidSFString(version)
            self.__version = version
        @property # - - - - - - - - - - - - -
        def head(self):
            return self.__head
        @head.setter
        def head(self, head=None):
            if  head is None:
                head = SFNode.DEFAULT_VALUE
            isValidSFNode(head)
            if not isinstance(head, object):
                raise RuntimeError(str(head) + ' does not have a valid node type object')
            self.__head = head
        @property # - - - - - - - - - - - - -
        def Scene(self):
            return self.__Scene
        @Scene.setter
        def Scene(self, Scene=None):
            if  Scene is None:
                Scene = SFNode.DEFAULT_VALUE
            isValidSFNode(Scene)
            if not isinstance(Scene, object):
                raise RuntimeError(str(Scene) + ' does not have a valid node type object')
            self.__Scene = Scene

###############################################

# Concrete Nodes

def isX3DNode(value):
    return isinstance(value, _X3DNode)

class Anchor(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'Anchor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/networking.html#Anchor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Anchor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('parameter', list(), 'MFString', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 description='',
                 parameter=list(),
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Anchor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.description = description
        self.parameter = parameter
        self.url = url
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def parameter(self):
            return self.__parameter
        @parameter.setter
        def parameter(self, parameter=None):
            if  parameter is None:
                parameter = MFString.DEFAULT_VALUE
            isValidMFString(parameter)
            self.__parameter = parameter
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class Appearance(_X3DAppearanceNode):
    """
    X3D element
    """
    __name__ = 'Appearance'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#Appearance'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Appearance'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('fillProperties', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('lineProperties', None, 'SFNode', 'inputOutput'),
                          ('material', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('pointProperties', None, 'SFNode', 'inputOutput'),
                          ('texture', None, 'SFNode', 'inputOutput'),
                          ('textureTransform', None, 'SFNode', 'inputOutput'),
                          ('shaders', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 fillProperties=None,
                 IS=None,
                 lineProperties=None,
                 material=None,
                 metadata=None,
                 pointProperties=None,
                 texture=None,
                 textureTransform=None,
                 shaders=list()):
        # if _DEBUG: print ('... in ConcreteNode Appearance __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.fillProperties = fillProperties
        self.lineProperties = lineProperties
        self.material = material
        self.pointProperties = pointProperties
        self.texture = texture
        self.textureTransform = textureTransform
        self.shaders = shaders
        @property # - - - - - - - - - - - - -
        def fillProperties(self):
            return self.__fillProperties
        @fillProperties.setter
        def fillProperties(self, fillProperties=None):
            if  fillProperties is None:
                fillProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(fillProperties)
            if not isinstance(fillProperties, object):
                raise RuntimeError(str(fillProperties) + ' does not have a valid node type object')
            self.__fillProperties = fillProperties
        @property # - - - - - - - - - - - - -
        def lineProperties(self):
            return self.__lineProperties
        @lineProperties.setter
        def lineProperties(self, lineProperties=None):
            if  lineProperties is None:
                lineProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(lineProperties)
            if not isinstance(lineProperties, object):
                raise RuntimeError(str(lineProperties) + ' does not have a valid node type object')
            self.__lineProperties = lineProperties
        @property # - - - - - - - - - - - - -
        def material(self):
            return self.__material
        @material.setter
        def material(self, material=None):
            if  material is None:
                material = SFNode.DEFAULT_VALUE
            isValidSFNode(material)
            if not isinstance(material, object):
                raise RuntimeError(str(material) + ' does not have a valid node type object')
            self.__material = material
        @property # - - - - - - - - - - - - -
        def pointProperties(self):
            return self.__pointProperties
        @pointProperties.setter
        def pointProperties(self, pointProperties=None):
            if  pointProperties is None:
                pointProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(pointProperties)
            if not isinstance(pointProperties, object):
                raise RuntimeError(str(pointProperties) + ' does not have a valid node type object')
            self.__pointProperties = pointProperties
        @property # - - - - - - - - - - - - -
        def texture(self):
            return self.__texture
        @texture.setter
        def texture(self, texture=None):
            if  texture is None:
                texture = SFNode.DEFAULT_VALUE
            isValidSFNode(texture)
            if not isinstance(texture, object):
                raise RuntimeError(str(texture) + ' does not have a valid node type object')
            self.__texture = texture
        @property # - - - - - - - - - - - - -
        def textureTransform(self):
            return self.__textureTransform
        @textureTransform.setter
        def textureTransform(self, textureTransform=None):
            if  textureTransform is None:
                textureTransform = SFNode.DEFAULT_VALUE
            isValidSFNode(textureTransform)
            if not isinstance(textureTransform, object):
                raise RuntimeError(str(textureTransform) + ' does not have a valid node type object')
            self.__textureTransform = textureTransform
        @property # - - - - - - - - - - - - -
        def shaders(self):
            return self.__shaders
        @shaders.setter
        def shaders(self, shaders=None):
            if  shaders is None:
                shaders = MFNode.DEFAULT_VALUE
            isValidMFNode(shaders)
            self.__shaders = shaders

class Arc2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Arc2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#Arc2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Arc2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('endAngle', 1.570796, 'SFFloat', 'initializeOnly'),
                          ('radius', 1, 'SFFloat', 'initializeOnly'),
                          ('startAngle', 0, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 endAngle=1.570796,
                 radius=1,
                 startAngle=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Arc2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.endAngle = endAngle
        self.radius = radius
        self.startAngle = startAngle
        @property # - - - - - - - - - - - - -
        def endAngle(self):
            return self.__endAngle
        @endAngle.setter
        def endAngle(self, endAngle=None):
            if  endAngle is None:
                endAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(endAngle)
            self.__endAngle = endAngle
        @property # - - - - - - - - - - - - -
        def radius(self):
            return self.__radius
        @radius.setter
        def radius(self, radius=None):
            if  radius is None:
                radius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(radius)
            self.__radius = radius
        @property # - - - - - - - - - - - - -
        def startAngle(self):
            return self.__startAngle
        @startAngle.setter
        def startAngle(self, startAngle=None):
            if  startAngle is None:
                startAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(startAngle)
            self.__startAngle = startAngle

class ArcClose2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'ArcClose2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#ArcClose2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ArcClose2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('closureType', 'PIE', 'SFString', 'initializeOnly'),
                          ('endAngle', 1.570796, 'SFFloat', 'initializeOnly'),
                          ('radius', 1, 'SFFloat', 'initializeOnly'),
                          ('solid', False, 'SFBool', 'initializeOnly'),
                          ('startAngle', 0, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 closureType='PIE',
                 endAngle=1.570796,
                 radius=1,
                 solid=False,
                 startAngle=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ArcClose2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.closureType = closureType
        self.endAngle = endAngle
        self.radius = radius
        self.solid = solid
        self.startAngle = startAngle
        @property # - - - - - - - - - - - - -
        def closureType(self):
            return self.__closureType
        @closureType.setter
        def closureType(self, closureType=None):
            if  closureType is None:
                closureType = SFString.DEFAULT_VALUE
            isValidSFString(closureType)
            self.__closureType = closureType
        @property # - - - - - - - - - - - - -
        def endAngle(self):
            return self.__endAngle
        @endAngle.setter
        def endAngle(self, endAngle=None):
            if  endAngle is None:
                endAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(endAngle)
            self.__endAngle = endAngle
        @property # - - - - - - - - - - - - -
        def radius(self):
            return self.__radius
        @radius.setter
        def radius(self, radius=None):
            if  radius is None:
                radius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(radius)
            self.__radius = radius
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def startAngle(self):
            return self.__startAngle
        @startAngle.setter
        def startAngle(self, startAngle=None):
            if  startAngle is None:
                startAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(startAngle)
            self.__startAngle = startAngle

class AudioClip(_X3DSoundSourceNode):
    """
    X3D element
    """
    __name__ = 'AudioClip'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/sound.html#AudioClip'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#AudioClip'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('loop', False, 'SFBool', 'inputOutput'),
                          ('pauseTime', 0, 'SFTime', 'inputOutput'),
                          ('pitch', 1.0, 'SFFloat', 'inputOutput'),
                          ('resumeTime', 0, 'SFTime', 'inputOutput'),
                          ('startTime', 0, 'SFTime', 'inputOutput'),
                          ('stopTime', 0, 'SFTime', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 description='',
                 loop=False,
                 pauseTime=0,
                 pitch=1.0,
                 resumeTime=0,
                 startTime=0,
                 stopTime=0,
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode AudioClip __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.description = description
        self.loop = loop
        self.pauseTime = pauseTime
        self.pitch = pitch
        self.resumeTime = resumeTime
        self.startTime = startTime
        self.stopTime = stopTime
        self.url = url
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def loop(self):
            return self.__loop
        @loop.setter
        def loop(self, loop=None):
            if  loop is None:
                loop = SFBool.DEFAULT_VALUE
            isValidSFBool(loop)
            self.__loop = loop
        @property # - - - - - - - - - - - - -
        def pauseTime(self):
            return self.__pauseTime
        @pauseTime.setter
        def pauseTime(self, pauseTime=None):
            if  pauseTime is None:
                pauseTime = SFTime.DEFAULT_VALUE
            isValidSFTime(pauseTime)
            self.__pauseTime = pauseTime
        @property # - - - - - - - - - - - - -
        def pitch(self):
            return self.__pitch
        @pitch.setter
        def pitch(self, pitch=None):
            if  pitch is None:
                pitch = SFFloat.DEFAULT_VALUE
            isValidSFFloat(pitch)
            self.__pitch = pitch
        @property # - - - - - - - - - - - - -
        def resumeTime(self):
            return self.__resumeTime
        @resumeTime.setter
        def resumeTime(self, resumeTime=None):
            if  resumeTime is None:
                resumeTime = SFTime.DEFAULT_VALUE
            isValidSFTime(resumeTime)
            self.__resumeTime = resumeTime
        @property # - - - - - - - - - - - - -
        def startTime(self):
            return self.__startTime
        @startTime.setter
        def startTime(self, startTime=None):
            if  startTime is None:
                startTime = SFTime.DEFAULT_VALUE
            isValidSFTime(startTime)
            self.__startTime = startTime
        @property # - - - - - - - - - - - - -
        def stopTime(self):
            return self.__stopTime
        @stopTime.setter
        def stopTime(self, stopTime=None):
            if  stopTime is None:
                stopTime = SFTime.DEFAULT_VALUE
            isValidSFTime(stopTime)
            self.__stopTime = stopTime
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url

class Background(_X3DBackgroundNode):
    """
    X3D element
    """
    __name__ = 'Background'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/enveffects.html#Background'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Background'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('backUrl', list(), 'MFString', 'inputOutput'),
                          ('bottomUrl', list(), 'MFString', 'inputOutput'),
                          ('frontUrl', list(), 'MFString', 'inputOutput'),
                          ('groundAngle', list(), 'MFFloat', 'inputOutput'),
                          ('groundColor', (list()), 'MFColor', 'inputOutput'),
                          ('leftUrl', list(), 'MFString', 'inputOutput'),
                          ('rightUrl', list(), 'MFString', 'inputOutput'),
                          ('skyAngle', list(), 'MFFloat', 'inputOutput'),
                          ('skyColor', [0, 0, 0], 'MFColor', 'inputOutput'),
                          ('topUrl', list(), 'MFString', 'inputOutput'),
                          ('transparency', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 backUrl=list(),
                 bottomUrl=list(),
                 frontUrl=list(),
                 groundAngle=list(),
                 groundColor=(list()),
                 leftUrl=list(),
                 rightUrl=list(),
                 skyAngle=list(),
                 skyColor=[0, 0, 0],
                 topUrl=list(),
                 transparency=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Background __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.backUrl = backUrl
        self.bottomUrl = bottomUrl
        self.frontUrl = frontUrl
        self.groundAngle = groundAngle
        self.groundColor = groundColor
        self.leftUrl = leftUrl
        self.rightUrl = rightUrl
        self.skyAngle = skyAngle
        self.skyColor = skyColor
        self.topUrl = topUrl
        self.transparency = transparency
        @property # - - - - - - - - - - - - -
        def backUrl(self):
            return self.__backUrl
        @backUrl.setter
        def backUrl(self, backUrl=None):
            if  backUrl is None:
                backUrl = MFString.DEFAULT_VALUE
            isValidMFString(backUrl)
            self.__backUrl = backUrl
        @property # - - - - - - - - - - - - -
        def bottomUrl(self):
            return self.__bottomUrl
        @bottomUrl.setter
        def bottomUrl(self, bottomUrl=None):
            if  bottomUrl is None:
                bottomUrl = MFString.DEFAULT_VALUE
            isValidMFString(bottomUrl)
            self.__bottomUrl = bottomUrl
        @property # - - - - - - - - - - - - -
        def frontUrl(self):
            return self.__frontUrl
        @frontUrl.setter
        def frontUrl(self, frontUrl=None):
            if  frontUrl is None:
                frontUrl = MFString.DEFAULT_VALUE
            isValidMFString(frontUrl)
            self.__frontUrl = frontUrl
        @property # - - - - - - - - - - - - -
        def groundAngle(self):
            return self.__groundAngle
        @groundAngle.setter
        def groundAngle(self, groundAngle=None):
            if  groundAngle is None:
                groundAngle = MFFloat.DEFAULT_VALUE
            isValidMFFloat(groundAngle)
            self.__groundAngle = groundAngle
        @property # - - - - - - - - - - - - -
        def groundColor(self):
            return self.__groundColor
        @groundColor.setter
        def groundColor(self, groundColor=None):
            if  groundColor is None:
                groundColor = MFColor.DEFAULT_VALUE
            isValidMFColor(groundColor)
            self.__groundColor = groundColor
        @property # - - - - - - - - - - - - -
        def leftUrl(self):
            return self.__leftUrl
        @leftUrl.setter
        def leftUrl(self, leftUrl=None):
            if  leftUrl is None:
                leftUrl = MFString.DEFAULT_VALUE
            isValidMFString(leftUrl)
            self.__leftUrl = leftUrl
        @property # - - - - - - - - - - - - -
        def rightUrl(self):
            return self.__rightUrl
        @rightUrl.setter
        def rightUrl(self, rightUrl=None):
            if  rightUrl is None:
                rightUrl = MFString.DEFAULT_VALUE
            isValidMFString(rightUrl)
            self.__rightUrl = rightUrl
        @property # - - - - - - - - - - - - -
        def skyAngle(self):
            return self.__skyAngle
        @skyAngle.setter
        def skyAngle(self, skyAngle=None):
            if  skyAngle is None:
                skyAngle = MFFloat.DEFAULT_VALUE
            isValidMFFloat(skyAngle)
            self.__skyAngle = skyAngle
        @property # - - - - - - - - - - - - -
        def skyColor(self):
            return self.__skyColor
        @skyColor.setter
        def skyColor(self, skyColor=None):
            if  skyColor is None:
                skyColor = MFColor.DEFAULT_VALUE
            isValidMFColor(skyColor)
            self.__skyColor = skyColor
        @property # - - - - - - - - - - - - -
        def topUrl(self):
            return self.__topUrl
        @topUrl.setter
        def topUrl(self, topUrl=None):
            if  topUrl is None:
                topUrl = MFString.DEFAULT_VALUE
            isValidMFString(topUrl)
            self.__topUrl = topUrl
        @property # - - - - - - - - - - - - -
        def transparency(self):
            return self.__transparency
        @transparency.setter
        def transparency(self, transparency=None):
            if  transparency is None:
                transparency = SFFloat.DEFAULT_VALUE
            isValidSFFloat(transparency)
            self.__transparency = transparency

class BallJoint(_X3DRigidJointNode):
    """
    BallJoint represents an unconstrained joint between two bodies that pivot about a common anchor point.
    """
    __name__ = 'BallJoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#BallJoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BallJoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('anchorPoint', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('forceOutput', ["NONE"], 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('body1', None, 'SFNode', 'inputOutput'),
                          ('body2', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 anchorPoint=(0, 0, 0),
                 forceOutput=["NONE"],
                 USE='',
                 class_='',
                 body1=None,
                 body2=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode BallJoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.anchorPoint = anchorPoint
        self.forceOutput = forceOutput
        self.body1 = body1
        self.body2 = body2
        @property # - - - - - - - - - - - - -
        def anchorPoint(self):
            return self.__anchorPoint
        @anchorPoint.setter
        def anchorPoint(self, anchorPoint=None):
            if  anchorPoint is None:
                anchorPoint = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(anchorPoint)
            self.__anchorPoint = anchorPoint
        @property # - - - - - - - - - - - - -
        def forceOutput(self):
            return self.__forceOutput
        @forceOutput.setter
        def forceOutput(self, forceOutput=None):
            if  forceOutput is None:
                forceOutput = MFString.DEFAULT_VALUE
            isValidMFString(forceOutput)
            self.__forceOutput = forceOutput
        @property # - - - - - - - - - - - - -
        def body1(self):
            return self.__body1
        @body1.setter
        def body1(self, body1=None):
            if  body1 is None:
                body1 = SFNode.DEFAULT_VALUE
            isValidSFNode(body1)
            if not isinstance(body1, object):
                raise RuntimeError(str(body1) + ' does not have a valid node type object')
            self.__body1 = body1
        @property # - - - - - - - - - - - - -
        def body2(self):
            return self.__body2
        @body2.setter
        def body2(self, body2=None):
            if  body2 is None:
                body2 = SFNode.DEFAULT_VALUE
            isValidSFNode(body2)
            if not isinstance(body2, object):
                raise RuntimeError(str(body2) + ' does not have a valid node type object')
            self.__body2 = body2

class Billboard(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'Billboard'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#Billboard'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Billboard'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('axisOfRotation', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 axisOfRotation=(0, 1, 0),
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Billboard __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.axisOfRotation = axisOfRotation
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.children = children
        @property # - - - - - - - - - - - - -
        def axisOfRotation(self):
            return self.__axisOfRotation
        @axisOfRotation.setter
        def axisOfRotation(self, axisOfRotation=None):
            if  axisOfRotation is None:
                axisOfRotation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(axisOfRotation)
            self.__axisOfRotation = axisOfRotation
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class BlendedVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'BlendedVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#BlendedVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BlendedVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('weightConstant1', 0.5, 'SFFloat', 'inputOutput'),
                          ('weightConstant2', 0.5, 'SFFloat', 'inputOutput'),
                          ('weightFunction1', 'CONSTANT', 'SFString', 'inputOutput'),
                          ('weightFunction2', 'CONSTANT', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('renderStyle', None, 'SFNode', 'inputOutput'),
                          ('voxels', None, 'SFNode', 'inputOutput'),
                          ('weightTransferFunction1', None, 'SFNode', 'inputOutput'),
                          ('weightTransferFunction2', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 weightConstant1=0.5,
                 weightConstant2=0.5,
                 weightFunction1='CONSTANT',
                 weightFunction2='CONSTANT',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 renderStyle=None,
                 voxels=None,
                 weightTransferFunction1=None,
                 weightTransferFunction2=None):
        # if _DEBUG: print ('... in ConcreteNode BlendedVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.weightConstant1 = weightConstant1
        self.weightConstant2 = weightConstant2
        self.weightFunction1 = weightFunction1
        self.weightFunction2 = weightFunction2
        self.renderStyle = renderStyle
        self.voxels = voxels
        self.weightTransferFunction1 = weightTransferFunction1
        self.weightTransferFunction2 = weightTransferFunction2
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def weightConstant1(self):
            return self.__weightConstant1
        @weightConstant1.setter
        def weightConstant1(self, weightConstant1=None):
            if  weightConstant1 is None:
                weightConstant1 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(weightConstant1)
            self.__weightConstant1 = weightConstant1
        @property # - - - - - - - - - - - - -
        def weightConstant2(self):
            return self.__weightConstant2
        @weightConstant2.setter
        def weightConstant2(self, weightConstant2=None):
            if  weightConstant2 is None:
                weightConstant2 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(weightConstant2)
            self.__weightConstant2 = weightConstant2
        @property # - - - - - - - - - - - - -
        def weightFunction1(self):
            return self.__weightFunction1
        @weightFunction1.setter
        def weightFunction1(self, weightFunction1=None):
            if  weightFunction1 is None:
                weightFunction1 = SFString.DEFAULT_VALUE
            isValidSFString(weightFunction1)
            self.__weightFunction1 = weightFunction1
        @property # - - - - - - - - - - - - -
        def weightFunction2(self):
            return self.__weightFunction2
        @weightFunction2.setter
        def weightFunction2(self, weightFunction2=None):
            if  weightFunction2 is None:
                weightFunction2 = SFString.DEFAULT_VALUE
            isValidSFString(weightFunction2)
            self.__weightFunction2 = weightFunction2
        @property # - - - - - - - - - - - - -
        def renderStyle(self):
            return self.__renderStyle
        @renderStyle.setter
        def renderStyle(self, renderStyle=None):
            if  renderStyle is None:
                renderStyle = SFNode.DEFAULT_VALUE
            isValidSFNode(renderStyle)
            if not isinstance(renderStyle, object):
                raise RuntimeError(str(renderStyle) + ' does not have a valid node type object')
            self.__renderStyle = renderStyle
        @property # - - - - - - - - - - - - -
        def voxels(self):
            return self.__voxels
        @voxels.setter
        def voxels(self, voxels=None):
            if  voxels is None:
                voxels = SFNode.DEFAULT_VALUE
            isValidSFNode(voxels)
            if not isinstance(voxels, object):
                raise RuntimeError(str(voxels) + ' does not have a valid node type object')
            self.__voxels = voxels
        @property # - - - - - - - - - - - - -
        def weightTransferFunction1(self):
            return self.__weightTransferFunction1
        @weightTransferFunction1.setter
        def weightTransferFunction1(self, weightTransferFunction1=None):
            if  weightTransferFunction1 is None:
                weightTransferFunction1 = SFNode.DEFAULT_VALUE
            isValidSFNode(weightTransferFunction1)
            if not isinstance(weightTransferFunction1, object):
                raise RuntimeError(str(weightTransferFunction1) + ' does not have a valid node type object')
            self.__weightTransferFunction1 = weightTransferFunction1
        @property # - - - - - - - - - - - - -
        def weightTransferFunction2(self):
            return self.__weightTransferFunction2
        @weightTransferFunction2.setter
        def weightTransferFunction2(self, weightTransferFunction2=None):
            if  weightTransferFunction2 is None:
                weightTransferFunction2 = SFNode.DEFAULT_VALUE
            isValidSFNode(weightTransferFunction2)
            if not isinstance(weightTransferFunction2, object):
                raise RuntimeError(str(weightTransferFunction2) + ' does not have a valid node type object')
            self.__weightTransferFunction2 = weightTransferFunction2

class BooleanFilter(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'BooleanFilter'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#BooleanFilter'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BooleanFilter'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode BooleanFilter __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only

class BooleanSequencer(_X3DSequencerNode):
    """
    X3D element
    """
    __name__ = 'BooleanSequencer'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#BooleanSequencer'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BooleanSequencer'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', list(), 'MFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode BooleanSequencer __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFBool.DEFAULT_VALUE
            isValidMFBool(keyValue)
            self.__keyValue = keyValue

class BooleanToggle(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'BooleanToggle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#BooleanToggle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BooleanToggle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('toggle', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 toggle=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode BooleanToggle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.toggle = toggle
        @property # - - - - - - - - - - - - -
        def toggle(self):
            return self.__toggle
        @toggle.setter
        def toggle(self, toggle=None):
            if  toggle is None:
                toggle = SFBool.DEFAULT_VALUE
            isValidSFBool(toggle)
            self.__toggle = toggle

class BooleanTrigger(_X3DTriggerNode):
    """
    X3D element
    """
    __name__ = 'BooleanTrigger'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#BooleanTrigger'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BooleanTrigger'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode BooleanTrigger __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only

class BoundaryEnhancementVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'BoundaryEnhancementVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#BoundaryEnhancementVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BoundaryEnhancementVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('boundaryOpacity', 0.9, 'SFFloat', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('opacityFactor', 2, 'SFFloat', 'inputOutput'),
                          ('retainedOpacity', 0.2, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 boundaryOpacity=0.9,
                 enabled=True,
                 opacityFactor=2,
                 retainedOpacity=0.2,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode BoundaryEnhancementVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.boundaryOpacity = boundaryOpacity
        self.enabled = enabled
        self.opacityFactor = opacityFactor
        self.retainedOpacity = retainedOpacity
        @property # - - - - - - - - - - - - -
        def boundaryOpacity(self):
            return self.__boundaryOpacity
        @boundaryOpacity.setter
        def boundaryOpacity(self, boundaryOpacity=None):
            if  boundaryOpacity is None:
                boundaryOpacity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(boundaryOpacity)
            self.__boundaryOpacity = boundaryOpacity
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def opacityFactor(self):
            return self.__opacityFactor
        @opacityFactor.setter
        def opacityFactor(self, opacityFactor=None):
            if  opacityFactor is None:
                opacityFactor = SFFloat.DEFAULT_VALUE
            isValidSFFloat(opacityFactor)
            self.__opacityFactor = opacityFactor
        @property # - - - - - - - - - - - - -
        def retainedOpacity(self):
            return self.__retainedOpacity
        @retainedOpacity.setter
        def retainedOpacity(self, retainedOpacity=None):
            if  retainedOpacity is None:
                retainedOpacity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(retainedOpacity)
            self.__retainedOpacity = retainedOpacity

class BoundedPhysicsModel(_X3DParticlePhysicsModelNode):
    """
    X3D element
    """
    __name__ = 'BoundedPhysicsModel'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#BoundedPhysicsModel'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#BoundedPhysicsModel'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geometry', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 USE='',
                 class_='',
                 geometry=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode BoundedPhysicsModel __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.geometry = geometry
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def geometry(self):
            return self.__geometry
        @geometry.setter
        def geometry(self, geometry=None):
            if  geometry is None:
                geometry = SFNode.DEFAULT_VALUE
            isValidSFNode(geometry)
            if not isinstance(geometry, object):
                raise RuntimeError(str(geometry) + ' does not have a valid node type object')
            self.__geometry = geometry

class Box(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Box'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry3D.html#Box'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Box'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('size', (2, 2, 2), 'SFVec3f', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 size=(2, 2, 2),
                 solid=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Box __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.size = size
        self.solid = solid
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid

class CADAssembly(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'CADAssembly'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/CADGeometry.html#CADAssembly'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CADAssembly'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 name='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode CADAssembly __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.name = name
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class CADFace(_X3DProductStructureChildNode):
    """
    X3D element
    """
    __name__ = 'CADFace'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/CADGeometry.html#CADFace'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CADFace'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('shape', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 name='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 shape=None):
        # if _DEBUG: print ('... in ConcreteNode CADFace __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.name = name
        self.shape = shape
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def shape(self):
            return self.__shape
        @shape.setter
        def shape(self, shape=None):
            if  shape is None:
                shape = SFNode.DEFAULT_VALUE
            isValidSFNode(shape)
            if not isinstance(shape, object):
                raise RuntimeError(str(shape) + ' does not have a valid node type object')
            self.__shape = shape

class CADLayer(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'CADLayer'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/CADGeometry.html#CADLayer'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CADLayer'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('visible', list(), 'MFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 name='',
                 visible=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode CADLayer __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.name = name
        self.visible = visible
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def visible(self):
            return self.__visible
        @visible.setter
        def visible(self, visible=None):
            if  visible is None:
                visible = MFBool.DEFAULT_VALUE
            isValidMFBool(visible)
            self.__visible = visible
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class CADPart(_X3DProductStructureChildNode):
    """
    X3D element
    """
    __name__ = 'CADPart'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/CADGeometry.html#CADPart'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CADPart'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('scaleOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 name='',
                 rotation=(0, 0, 1, 0),
                 scale=(1, 1, 1),
                 scaleOrientation=(0, 0, 1, 0),
                 translation=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode CADPart __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.name = name
        self.rotation = rotation
        self.scale = scale
        self.scaleOrientation = scaleOrientation
        self.translation = translation
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def scaleOrientation(self):
            return self.__scaleOrientation
        @scaleOrientation.setter
        def scaleOrientation(self, scaleOrientation=None):
            if  scaleOrientation is None:
                scaleOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(scaleOrientation)
            self.__scaleOrientation = scaleOrientation
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class CartoonVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'CartoonVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#CartoonVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CartoonVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('colorSteps', 4, 'SFInt32', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('orthogonalColor', (1, 1, 1, 1), 'SFColorRGBA', 'inputOutput'),
                          ('parallelColor', (0, 0, 0, 1), 'SFColorRGBA', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('surfaceNormals', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 colorSteps=4,
                 enabled=True,
                 orthogonalColor=(1, 1, 1, 1),
                 parallelColor=(0, 0, 0, 1),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 surfaceNormals=None):
        # if _DEBUG: print ('... in ConcreteNode CartoonVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.colorSteps = colorSteps
        self.enabled = enabled
        self.orthogonalColor = orthogonalColor
        self.parallelColor = parallelColor
        self.surfaceNormals = surfaceNormals
        @property # - - - - - - - - - - - - -
        def colorSteps(self):
            return self.__colorSteps
        @colorSteps.setter
        def colorSteps(self, colorSteps=None):
            if  colorSteps is None:
                colorSteps = SFInt32.DEFAULT_VALUE
            isValidSFInt32(colorSteps)
            self.__colorSteps = colorSteps
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def orthogonalColor(self):
            return self.__orthogonalColor
        @orthogonalColor.setter
        def orthogonalColor(self, orthogonalColor=None):
            if  orthogonalColor is None:
                orthogonalColor = SFColorRGBA.DEFAULT_VALUE
            isValidSFColorRGBA(orthogonalColor)
            self.__orthogonalColor = orthogonalColor
        @property # - - - - - - - - - - - - -
        def parallelColor(self):
            return self.__parallelColor
        @parallelColor.setter
        def parallelColor(self, parallelColor=None):
            if  parallelColor is None:
                parallelColor = SFColorRGBA.DEFAULT_VALUE
            isValidSFColorRGBA(parallelColor)
            self.__parallelColor = parallelColor
        @property # - - - - - - - - - - - - -
        def surfaceNormals(self):
            return self.__surfaceNormals
        @surfaceNormals.setter
        def surfaceNormals(self, surfaceNormals=None):
            if  surfaceNormals is None:
                surfaceNormals = SFNode.DEFAULT_VALUE
            isValidSFNode(surfaceNormals)
            if not isinstance(surfaceNormals, object):
                raise RuntimeError(str(surfaceNormals) + ' does not have a valid node type object')
            self.__surfaceNormals = surfaceNormals

class Circle2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Circle2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#Circle2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Circle2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('radius', 1, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 radius=1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Circle2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.radius = radius
        @property # - - - - - - - - - - - - -
        def radius(self):
            return self.__radius
        @radius.setter
        def radius(self, radius=None):
            if  radius is None:
                radius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(radius)
            self.__radius = radius

class ClipPlane(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'ClipPlane'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#ClipPlane'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ClipPlane'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('plane', (0, 1, 0, 0), 'SFVec4f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 plane=(0, 1, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ClipPlane __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.plane = plane
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def plane(self):
            return self.__plane
        @plane.setter
        def plane(self, plane=None):
            if  plane is None:
                plane = SFVec4f.DEFAULT_VALUE
            isValidSFVec4f(plane)
            self.__plane = plane

class CollidableOffset(_X3DNBodyCollidableNode):
    """
    CollidableOffset repositions geometry relative to center of owning body.
    """
    __name__ = 'CollidableOffset'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#CollidableOffset'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CollidableOffset'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('collidable', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 enabled=True,
                 rotation=(0, 0, 1, 0),
                 translation=(0, 0, 0),
                 USE='',
                 class_='',
                 collidable=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CollidableOffset __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.enabled = enabled
        self.rotation = rotation
        self.translation = translation
        self.collidable = collidable
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def collidable(self):
            return self.__collidable
        @collidable.setter
        def collidable(self, collidable=None):
            if  collidable is None:
                collidable = SFNode.DEFAULT_VALUE
            isValidSFNode(collidable)
            if not isinstance(collidable, object):
                raise RuntimeError(str(collidable) + ' does not have a valid node type object')
            self.__collidable = collidable

class CollidableShape(_X3DNBodyCollidableNode):
    """
    CollidableShape connects the collision detection system, the rigid body model, and the renderable scene graph.
    """
    __name__ = 'CollidableShape'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#CollidableShape'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CollidableShape'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('shape', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 enabled=True,
                 rotation=(0, 0, 1, 0),
                 translation=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 shape=None):
        # if _DEBUG: print ('... in ConcreteNode CollidableShape __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.enabled = enabled
        self.rotation = rotation
        self.translation = translation
        self.shape = shape
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def shape(self):
            return self.__shape
        @shape.setter
        def shape(self, shape=None):
            if  shape is None:
                shape = SFNode.DEFAULT_VALUE
            isValidSFNode(shape)
            if not isinstance(shape, object):
                raise RuntimeError(str(shape) + ' does not have a valid node type object')
            self.__shape = shape

class Collision(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'Collision'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#Collision'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Collision'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('proxy', None, 'SFNode', 'initializeOnly'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 enabled=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 proxy=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Collision __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.enabled = enabled
        self.proxy = proxy
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def proxy(self):
            return self.__proxy
        @proxy.setter
        def proxy(self, proxy=None):
            if  proxy is None:
                proxy = SFNode.DEFAULT_VALUE
            isValidSFNode(proxy)
            if not isinstance(proxy, object):
                raise RuntimeError(str(proxy) + ' does not have a valid node type object')
            self.__proxy = proxy
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class CollisionCollection(_X3DNode):
    """
    CollisionCollection holds a collection of objects that can be managed as a single entity for resolution of inter-object collisions.
    """
    __name__ = 'CollisionCollection'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#CollisionCollection'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CollisionCollection'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('appliedParameters', ["BOUNCE"], 'MFString', 'inputOutput'),
                          ('bounce', 0, 'SFFloat', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('frictionCoefficients', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('minBounceSpeed', 0.1, 'SFFloat', 'inputOutput'),
                          ('slipFactors', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('softnessConstantForceMix', 0.0001, 'SFFloat', 'inputOutput'),
                          ('softnessErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('surfaceSpeed', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('collidables', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 appliedParameters=["BOUNCE"],
                 bounce=0,
                 enabled=True,
                 frictionCoefficients=(0, 0),
                 minBounceSpeed=0.1,
                 slipFactors=(0, 0),
                 softnessConstantForceMix=0.0001,
                 softnessErrorCorrection=0.8,
                 surfaceSpeed=(0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 collidables=list()):
        # if _DEBUG: print ('... in ConcreteNode CollisionCollection __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.appliedParameters = appliedParameters
        self.bounce = bounce
        self.enabled = enabled
        self.frictionCoefficients = frictionCoefficients
        self.minBounceSpeed = minBounceSpeed
        self.slipFactors = slipFactors
        self.softnessConstantForceMix = softnessConstantForceMix
        self.softnessErrorCorrection = softnessErrorCorrection
        self.surfaceSpeed = surfaceSpeed
        self.collidables = collidables
        @property # - - - - - - - - - - - - -
        def appliedParameters(self):
            return self.__appliedParameters
        @appliedParameters.setter
        def appliedParameters(self, appliedParameters=None):
            if  appliedParameters is None:
                appliedParameters = MFString.DEFAULT_VALUE
            isValidMFString(appliedParameters)
            self.__appliedParameters = appliedParameters
        @property # - - - - - - - - - - - - -
        def bounce(self):
            return self.__bounce
        @bounce.setter
        def bounce(self, bounce=None):
            if  bounce is None:
                bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(bounce)
            self.__bounce = bounce
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def frictionCoefficients(self):
            return self.__frictionCoefficients
        @frictionCoefficients.setter
        def frictionCoefficients(self, frictionCoefficients=None):
            if  frictionCoefficients is None:
                frictionCoefficients = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(frictionCoefficients)
            self.__frictionCoefficients = frictionCoefficients
        @property # - - - - - - - - - - - - -
        def minBounceSpeed(self):
            return self.__minBounceSpeed
        @minBounceSpeed.setter
        def minBounceSpeed(self, minBounceSpeed=None):
            if  minBounceSpeed is None:
                minBounceSpeed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minBounceSpeed)
            self.__minBounceSpeed = minBounceSpeed
        @property # - - - - - - - - - - - - -
        def slipFactors(self):
            return self.__slipFactors
        @slipFactors.setter
        def slipFactors(self, slipFactors=None):
            if  slipFactors is None:
                slipFactors = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(slipFactors)
            self.__slipFactors = slipFactors
        @property # - - - - - - - - - - - - -
        def softnessConstantForceMix(self):
            return self.__softnessConstantForceMix
        @softnessConstantForceMix.setter
        def softnessConstantForceMix(self, softnessConstantForceMix=None):
            if  softnessConstantForceMix is None:
                softnessConstantForceMix = SFFloat.DEFAULT_VALUE
            isValidSFFloat(softnessConstantForceMix)
            self.__softnessConstantForceMix = softnessConstantForceMix
        @property # - - - - - - - - - - - - -
        def softnessErrorCorrection(self):
            return self.__softnessErrorCorrection
        @softnessErrorCorrection.setter
        def softnessErrorCorrection(self, softnessErrorCorrection=None):
            if  softnessErrorCorrection is None:
                softnessErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(softnessErrorCorrection)
            self.__softnessErrorCorrection = softnessErrorCorrection
        @property # - - - - - - - - - - - - -
        def surfaceSpeed(self):
            return self.__surfaceSpeed
        @surfaceSpeed.setter
        def surfaceSpeed(self, surfaceSpeed=None):
            if  surfaceSpeed is None:
                surfaceSpeed = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(surfaceSpeed)
            self.__surfaceSpeed = surfaceSpeed
        @property # - - - - - - - - - - - - -
        def collidables(self):
            return self.__collidables
        @collidables.setter
        def collidables(self, collidables=None):
            if  collidables is None:
                collidables = MFNode.DEFAULT_VALUE
            isValidMFNode(collidables)
            self.__collidables = collidables

class CollisionSensor(_X3DSensorNode):
    """
    CollisionSensor generates collision-detection events.
    """
    __name__ = 'CollisionSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#CollisionSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CollisionSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('collider', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 USE='',
                 class_='',
                 collider=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CollisionSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.collider = collider
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def collider(self):
            return self.__collider
        @collider.setter
        def collider(self, collider=None):
            if  collider is None:
                collider = SFNode.DEFAULT_VALUE
            isValidSFNode(collider)
            if not isinstance(collider, object):
                raise RuntimeError(str(collider) + ' does not have a valid node type object')
            self.__collider = collider

class CollisionSpace(_X3DNBodyCollisionSpaceNode):
    """
    CollisionSpace holds collection of objects considered together for resolution of inter-object collisions.
    """
    __name__ = 'CollisionSpace'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#CollisionSpace'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CollisionSpace'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('useGeometry', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('collidables', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 enabled=True,
                 useGeometry=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 collidables=list()):
        # if _DEBUG: print ('... in ConcreteNode CollisionSpace __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.enabled = enabled
        self.useGeometry = useGeometry
        self.collidables = collidables
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def useGeometry(self):
            return self.__useGeometry
        @useGeometry.setter
        def useGeometry(self, useGeometry=None):
            if  useGeometry is None:
                useGeometry = SFBool.DEFAULT_VALUE
            isValidSFBool(useGeometry)
            self.__useGeometry = useGeometry
        @property # - - - - - - - - - - - - -
        def collidables(self):
            return self.__collidables
        @collidables.setter
        def collidables(self, collidables=None):
            if  collidables is None:
                collidables = MFNode.DEFAULT_VALUE
            isValidMFNode(collidables)
            self.__collidables = collidables

class Color(_X3DColorNode):
    """
    X3D element
    """
    __name__ = 'Color'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#Color'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Color'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('color', (list()), 'MFColor', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 color=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Color __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.color = color
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = MFColor.DEFAULT_VALUE
            isValidMFColor(color)
            self.__color = color

class ColorChaser(_X3DChaserNode):
    """
    X3D element
    """
    __name__ = 'ColorChaser'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#ColorChaser'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ColorChaser'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('duration', 1, 'SFTime', 'initializeOnly'),
                          ('initialDestination', (0.8, 0.8, 0.8), 'SFColor', 'initializeOnly'),
                          ('initialValue', (0.8, 0.8, 0.8), 'SFColor', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 duration=1,
                 initialDestination=(0.8, 0.8, 0.8),
                 initialValue=(0.8, 0.8, 0.8),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ColorChaser __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.duration = duration
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def duration(self):
            return self.__duration
        @duration.setter
        def duration(self, duration=None):
            if  duration is None:
                duration = SFTime.DEFAULT_VALUE
            isValidSFTime(duration)
            self.__duration = duration
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFColor.DEFAULT_VALUE
            isValidSFColor(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFColor.DEFAULT_VALUE
            isValidSFColor(initialValue)
            self.__initialValue = initialValue

class ColorDamper(_X3DDamperNode):
    """
    X3D element
    """
    __name__ = 'ColorDamper'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#ColorDamper'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ColorDamper'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('initialDestination', (0.8, 0.8, 0.8), 'SFColor', 'initializeOnly'),
                          ('initialValue', (0.8, 0.8, 0.8), 'SFColor', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tau', 0.3, 'SFTime', 'inputOutput'),
                          ('tolerance', -1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 initialDestination=(0.8, 0.8, 0.8),
                 initialValue=(0.8, 0.8, 0.8),
                 order=3,
                 tau=0.3,
                 tolerance=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ColorDamper __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        self.order = order
        self.tau = tau
        self.tolerance = tolerance
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFColor.DEFAULT_VALUE
            isValidSFColor(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFColor.DEFAULT_VALUE
            isValidSFColor(initialValue)
            self.__initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tau(self):
            return self.__tau
        @tau.setter
        def tau(self, tau=None):
            if  tau is None:
                tau = SFTime.DEFAULT_VALUE
            isValidSFTime(tau)
            self.__tau = tau
        @property # - - - - - - - - - - - - -
        def tolerance(self):
            return self.__tolerance
        @tolerance.setter
        def tolerance(self, tolerance=None):
            if  tolerance is None:
                tolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tolerance)
            self.__tolerance = tolerance

class ColorInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'ColorInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#ColorInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ColorInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFColor', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ColorInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFColor.DEFAULT_VALUE
            isValidMFColor(keyValue)
            self.__keyValue = keyValue

class ColorRGBA(_X3DColorNode):
    """
    X3D element
    """
    __name__ = 'ColorRGBA'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#ColorRGBA'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ColorRGBA'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('color', (list()), 'MFColorRGBA', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 color=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ColorRGBA __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.color = color
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = MFColorRGBA.DEFAULT_VALUE
            isValidMFColorRGBA(color)
            self.__color = color

class ComposedCubeMapTexture(_X3DEnvironmentTextureNode):
    """
    X3D element
    """
    __name__ = 'ComposedCubeMapTexture'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/env_texture.html#ComposedCubeMapTexture'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ComposedCubeMapTexture'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('back', None, 'SFNode', 'inputOutput'),
                          ('bottom', None, 'SFNode', 'inputOutput'),
                          ('front', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('left', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('right', None, 'SFNode', 'inputOutput'),
                          ('top', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 back=None,
                 bottom=None,
                 front=None,
                 IS=None,
                 left=None,
                 metadata=None,
                 right=None,
                 top=None):
        # if _DEBUG: print ('... in ConcreteNode ComposedCubeMapTexture __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.back = back
        self.bottom = bottom
        self.front = front
        self.left = left
        self.right = right
        self.top = top
        @property # - - - - - - - - - - - - -
        def back(self):
            return self.__back
        @back.setter
        def back(self, back=None):
            if  back is None:
                back = SFNode.DEFAULT_VALUE
            isValidSFNode(back)
            if not isinstance(back, object):
                raise RuntimeError(str(back) + ' does not have a valid node type object')
            self.__back = back
        @property # - - - - - - - - - - - - -
        def bottom(self):
            return self.__bottom
        @bottom.setter
        def bottom(self, bottom=None):
            if  bottom is None:
                bottom = SFNode.DEFAULT_VALUE
            isValidSFNode(bottom)
            if not isinstance(bottom, object):
                raise RuntimeError(str(bottom) + ' does not have a valid node type object')
            self.__bottom = bottom
        @property # - - - - - - - - - - - - -
        def front(self):
            return self.__front
        @front.setter
        def front(self, front=None):
            if  front is None:
                front = SFNode.DEFAULT_VALUE
            isValidSFNode(front)
            if not isinstance(front, object):
                raise RuntimeError(str(front) + ' does not have a valid node type object')
            self.__front = front
        @property # - - - - - - - - - - - - -
        def left(self):
            return self.__left
        @left.setter
        def left(self, left=None):
            if  left is None:
                left = SFNode.DEFAULT_VALUE
            isValidSFNode(left)
            if not isinstance(left, object):
                raise RuntimeError(str(left) + ' does not have a valid node type object')
            self.__left = left
        @property # - - - - - - - - - - - - -
        def right(self):
            return self.__right
        @right.setter
        def right(self, right=None):
            if  right is None:
                right = SFNode.DEFAULT_VALUE
            isValidSFNode(right)
            if not isinstance(right, object):
                raise RuntimeError(str(right) + ' does not have a valid node type object')
            self.__right = right
        @property # - - - - - - - - - - - - -
        def top(self):
            return self.__top
        @top.setter
        def top(self, top=None):
            if  top is None:
                top = SFNode.DEFAULT_VALUE
            isValidSFNode(top)
            if not isinstance(top, object):
                raise RuntimeError(str(top) + ' does not have a valid node type object')
            self.__top = top

class ComposedShader(_X3DShaderNode):
    """
    ComposedShader can contain field declarations, but no CDATA section of plain-text source code, since programs are composed from child ShaderPart nodes.
    """
    __name__ = 'ComposedShader'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#ComposedShader'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ComposedShader'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('language', '', 'SFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('field', list(), 'MFNode', 'inputOutput'),
                          ('parts', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 language='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 field=list(),
                 parts=list()):
        # if _DEBUG: print ('... in ConcreteNode ComposedShader __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.language = language
        self.field = field
        self.parts = parts
        @property # - - - - - - - - - - - - -
        def language(self):
            return self.__language
        @language.setter
        def language(self, language=None):
            if  language is None:
                language = SFString.DEFAULT_VALUE
            isValidSFString(language)
            self.__language = language
        @property # - - - - - - - - - - - - -
        def field(self):
            return self.__field
        @field.setter
        def field(self, field=None):
            if  field is None:
                field = MFNode.DEFAULT_VALUE
            isValidMFNode(field)
            self.__field = field
        @property # - - - - - - - - - - - - -
        def parts(self):
            return self.__parts
        @parts.setter
        def parts(self, parts=None):
            if  parts is None:
                parts = MFNode.DEFAULT_VALUE
            isValidMFNode(parts)
            self.__parts = parts

class ComposedTexture3D(_X3DTexture3DNode):
    """
    X3D element
    """
    __name__ = 'ComposedTexture3D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#ComposedTexture3D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ComposedTexture3D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('repeatR', False, 'SFBool', 'initializeOnly'),
                          ('repeatS', False, 'SFBool', 'initializeOnly'),
                          ('repeatT', False, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly'),
                          ('texture', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 repeatR=False,
                 repeatS=False,
                 repeatT=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None,
                 texture=list()):
        # if _DEBUG: print ('... in ConcreteNode ComposedTexture3D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.repeatR = repeatR
        self.repeatS = repeatS
        self.repeatT = repeatT
        self.textureProperties = textureProperties
        self.texture = texture
        @property # - - - - - - - - - - - - -
        def repeatR(self):
            return self.__repeatR
        @repeatR.setter
        def repeatR(self, repeatR=None):
            if  repeatR is None:
                repeatR = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatR)
            self.__repeatR = repeatR
        @property # - - - - - - - - - - - - -
        def repeatS(self):
            return self.__repeatS
        @repeatS.setter
        def repeatS(self, repeatS=None):
            if  repeatS is None:
                repeatS = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatS)
            self.__repeatS = repeatS
        @property # - - - - - - - - - - - - -
        def repeatT(self):
            return self.__repeatT
        @repeatT.setter
        def repeatT(self, repeatT=None):
            if  repeatT is None:
                repeatT = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatT)
            self.__repeatT = repeatT
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def texture(self):
            return self.__texture
        @texture.setter
        def texture(self, texture=None):
            if  texture is None:
                texture = MFNode.DEFAULT_VALUE
            isValidMFNode(texture)
            self.__texture = texture

class ComposedVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'ComposedVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#ComposedVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ComposedVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('renderStyle', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 renderStyle=list()):
        # if _DEBUG: print ('... in ConcreteNode ComposedVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.renderStyle = renderStyle
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def renderStyle(self):
            return self.__renderStyle
        @renderStyle.setter
        def renderStyle(self, renderStyle=None):
            if  renderStyle is None:
                renderStyle = MFNode.DEFAULT_VALUE
            isValidMFNode(renderStyle)
            self.__renderStyle = renderStyle

class Cone(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Cone'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry3D.html#Cone'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Cone'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bottom', True, 'SFBool', 'initializeOnly'),
                          ('bottomRadius', 1, 'SFFloat', 'initializeOnly'),
                          ('height', 2, 'SFFloat', 'initializeOnly'),
                          ('side', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bottom=True,
                 bottomRadius=1,
                 height=2,
                 side=True,
                 solid=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Cone __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bottom = bottom
        self.bottomRadius = bottomRadius
        self.height = height
        self.side = side
        self.solid = solid
        @property # - - - - - - - - - - - - -
        def bottom(self):
            return self.__bottom
        @bottom.setter
        def bottom(self, bottom=None):
            if  bottom is None:
                bottom = SFBool.DEFAULT_VALUE
            isValidSFBool(bottom)
            self.__bottom = bottom
        @property # - - - - - - - - - - - - -
        def bottomRadius(self):
            return self.__bottomRadius
        @bottomRadius.setter
        def bottomRadius(self, bottomRadius=None):
            if  bottomRadius is None:
                bottomRadius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(bottomRadius)
            self.__bottomRadius = bottomRadius
        @property # - - - - - - - - - - - - -
        def height(self):
            return self.__height
        @height.setter
        def height(self, height=None):
            if  height is None:
                height = SFFloat.DEFAULT_VALUE
            isValidSFFloat(height)
            self.__height = height
        @property # - - - - - - - - - - - - -
        def side(self):
            return self.__side
        @side.setter
        def side(self, side=None):
            if  side is None:
                side = SFBool.DEFAULT_VALUE
            isValidSFBool(side)
            self.__side = side
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid

class ConeEmitter(_X3DParticleEmitterNode):
    """
    X3D element
    """
    __name__ = 'ConeEmitter'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#ConeEmitter'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ConeEmitter'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('angle', 0.7854, 'SFFloat', 'inputOutput'),
                          ('direction', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('mass', 0, 'SFFloat', 'inputOutput'),
                          ('position', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('speed', 0, 'SFFloat', 'inputOutput'),
                          ('surfaceArea', 0, 'SFFloat', 'initializeOnly'),
                          ('variation', 0.25, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 angle=0.7854,
                 direction=(0, 1, 0),
                 mass=0,
                 position=(0, 0, 0),
                 speed=0,
                 surfaceArea=0,
                 variation=0.25,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ConeEmitter __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.angle = angle
        self.direction = direction
        self.mass = mass
        self.position = position
        self.speed = speed
        self.surfaceArea = surfaceArea
        self.variation = variation
        @property # - - - - - - - - - - - - -
        def angle(self):
            return self.__angle
        @angle.setter
        def angle(self, angle=None):
            if  angle is None:
                angle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(angle)
            self.__angle = angle
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def surfaceArea(self):
            return self.__surfaceArea
        @surfaceArea.setter
        def surfaceArea(self, surfaceArea=None):
            if  surfaceArea is None:
                surfaceArea = SFFloat.DEFAULT_VALUE
            isValidSFFloat(surfaceArea)
            self.__surfaceArea = surfaceArea
        @property # - - - - - - - - - - - - -
        def variation(self):
            return self.__variation
        @variation.setter
        def variation(self, variation=None):
            if  variation is None:
                variation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(variation)
            self.__variation = variation

class Contact(_X3DNode):
    """
    Contact nodes are produced as output events when two collidable objects or spaces make contact.
    """
    __name__ = 'Contact'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#Contact'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Contact'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('appliedParameters', ["BOUNCE"], 'MFString', 'inputOutput'),
                          ('bounce', 0, 'SFFloat', 'inputOutput'),
                          ('contactNormal', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('depth', 0, 'SFFloat', 'inputOutput'),
                          ('frictionCoefficients', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('frictionDirection', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('minBounceSpeed', 0, 'SFFloat', 'inputOutput'),
                          ('position', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('slipCoefficients', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('softnessConstantForceMix', 0.0001, 'SFFloat', 'inputOutput'),
                          ('softnessErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('surfaceSpeed', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('body1', None, 'SFNode', 'inputOutput'),
                          ('body2', None, 'SFNode', 'inputOutput'),
                          ('geometry1', None, 'SFNode', 'inputOutput'),
                          ('geometry2', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 appliedParameters=["BOUNCE"],
                 bounce=0,
                 contactNormal=(0, 1, 0),
                 depth=0,
                 frictionCoefficients=(0, 0),
                 frictionDirection=(0, 1, 0),
                 minBounceSpeed=0,
                 position=(0, 0, 0),
                 slipCoefficients=(0, 0),
                 softnessConstantForceMix=0.0001,
                 softnessErrorCorrection=0.8,
                 surfaceSpeed=(0, 0),
                 USE='',
                 class_='',
                 body1=None,
                 body2=None,
                 geometry1=None,
                 geometry2=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Contact __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.appliedParameters = appliedParameters
        self.bounce = bounce
        self.contactNormal = contactNormal
        self.depth = depth
        self.frictionCoefficients = frictionCoefficients
        self.frictionDirection = frictionDirection
        self.minBounceSpeed = minBounceSpeed
        self.position = position
        self.slipCoefficients = slipCoefficients
        self.softnessConstantForceMix = softnessConstantForceMix
        self.softnessErrorCorrection = softnessErrorCorrection
        self.surfaceSpeed = surfaceSpeed
        self.body1 = body1
        self.body2 = body2
        self.geometry1 = geometry1
        self.geometry2 = geometry2
        @property # - - - - - - - - - - - - -
        def appliedParameters(self):
            return self.__appliedParameters
        @appliedParameters.setter
        def appliedParameters(self, appliedParameters=None):
            if  appliedParameters is None:
                appliedParameters = MFString.DEFAULT_VALUE
            isValidMFString(appliedParameters)
            self.__appliedParameters = appliedParameters
        @property # - - - - - - - - - - - - -
        def bounce(self):
            return self.__bounce
        @bounce.setter
        def bounce(self, bounce=None):
            if  bounce is None:
                bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(bounce)
            self.__bounce = bounce
        @property # - - - - - - - - - - - - -
        def contactNormal(self):
            return self.__contactNormal
        @contactNormal.setter
        def contactNormal(self, contactNormal=None):
            if  contactNormal is None:
                contactNormal = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(contactNormal)
            self.__contactNormal = contactNormal
        @property # - - - - - - - - - - - - -
        def depth(self):
            return self.__depth
        @depth.setter
        def depth(self, depth=None):
            if  depth is None:
                depth = SFFloat.DEFAULT_VALUE
            isValidSFFloat(depth)
            self.__depth = depth
        @property # - - - - - - - - - - - - -
        def frictionCoefficients(self):
            return self.__frictionCoefficients
        @frictionCoefficients.setter
        def frictionCoefficients(self, frictionCoefficients=None):
            if  frictionCoefficients is None:
                frictionCoefficients = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(frictionCoefficients)
            self.__frictionCoefficients = frictionCoefficients
        @property # - - - - - - - - - - - - -
        def frictionDirection(self):
            return self.__frictionDirection
        @frictionDirection.setter
        def frictionDirection(self, frictionDirection=None):
            if  frictionDirection is None:
                frictionDirection = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(frictionDirection)
            self.__frictionDirection = frictionDirection
        @property # - - - - - - - - - - - - -
        def minBounceSpeed(self):
            return self.__minBounceSpeed
        @minBounceSpeed.setter
        def minBounceSpeed(self, minBounceSpeed=None):
            if  minBounceSpeed is None:
                minBounceSpeed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minBounceSpeed)
            self.__minBounceSpeed = minBounceSpeed
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def slipCoefficients(self):
            return self.__slipCoefficients
        @slipCoefficients.setter
        def slipCoefficients(self, slipCoefficients=None):
            if  slipCoefficients is None:
                slipCoefficients = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(slipCoefficients)
            self.__slipCoefficients = slipCoefficients
        @property # - - - - - - - - - - - - -
        def softnessConstantForceMix(self):
            return self.__softnessConstantForceMix
        @softnessConstantForceMix.setter
        def softnessConstantForceMix(self, softnessConstantForceMix=None):
            if  softnessConstantForceMix is None:
                softnessConstantForceMix = SFFloat.DEFAULT_VALUE
            isValidSFFloat(softnessConstantForceMix)
            self.__softnessConstantForceMix = softnessConstantForceMix
        @property # - - - - - - - - - - - - -
        def softnessErrorCorrection(self):
            return self.__softnessErrorCorrection
        @softnessErrorCorrection.setter
        def softnessErrorCorrection(self, softnessErrorCorrection=None):
            if  softnessErrorCorrection is None:
                softnessErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(softnessErrorCorrection)
            self.__softnessErrorCorrection = softnessErrorCorrection
        @property # - - - - - - - - - - - - -
        def surfaceSpeed(self):
            return self.__surfaceSpeed
        @surfaceSpeed.setter
        def surfaceSpeed(self, surfaceSpeed=None):
            if  surfaceSpeed is None:
                surfaceSpeed = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(surfaceSpeed)
            self.__surfaceSpeed = surfaceSpeed
        @property # - - - - - - - - - - - - -
        def body1(self):
            return self.__body1
        @body1.setter
        def body1(self, body1=None):
            if  body1 is None:
                body1 = SFNode.DEFAULT_VALUE
            isValidSFNode(body1)
            if not isinstance(body1, object):
                raise RuntimeError(str(body1) + ' does not have a valid node type object')
            self.__body1 = body1
        @property # - - - - - - - - - - - - -
        def body2(self):
            return self.__body2
        @body2.setter
        def body2(self, body2=None):
            if  body2 is None:
                body2 = SFNode.DEFAULT_VALUE
            isValidSFNode(body2)
            if not isinstance(body2, object):
                raise RuntimeError(str(body2) + ' does not have a valid node type object')
            self.__body2 = body2
        @property # - - - - - - - - - - - - -
        def geometry1(self):
            return self.__geometry1
        @geometry1.setter
        def geometry1(self, geometry1=None):
            if  geometry1 is None:
                geometry1 = SFNode.DEFAULT_VALUE
            isValidSFNode(geometry1)
            if not isinstance(geometry1, object):
                raise RuntimeError(str(geometry1) + ' does not have a valid node type object')
            self.__geometry1 = geometry1
        @property # - - - - - - - - - - - - -
        def geometry2(self):
            return self.__geometry2
        @geometry2.setter
        def geometry2(self, geometry2=None):
            if  geometry2 is None:
                geometry2 = SFNode.DEFAULT_VALUE
            isValidSFNode(geometry2)
            if not isinstance(geometry2, object):
                raise RuntimeError(str(geometry2) + ' does not have a valid node type object')
            self.__geometry2 = geometry2

class Contour2D(_X3DNode):
    """
    X3D element
    """
    __name__ = 'Contour2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#Contour2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Contour2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Contour2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.children = children
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class ContourPolyline2D(_X3DNurbsControlCurveNode):
    """
    X3D element
    """
    __name__ = 'ContourPolyline2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#ContourPolyline2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ContourPolyline2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('controlPoint', (list()), 'MFVec2d', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 controlPoint=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ContourPolyline2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = MFVec2d.DEFAULT_VALUE
            isValidMFVec2d(controlPoint)
            self.__controlPoint = controlPoint

class Coordinate(_X3DCoordinateNode):
    """
    X3D element
    """
    __name__ = 'Coordinate'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#Coordinate'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Coordinate'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('point', (list()), 'MFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 point=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Coordinate __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.point = point
        @property # - - - - - - - - - - - - -
        def point(self):
            return self.__point
        @point.setter
        def point(self, point=None):
            if  point is None:
                point = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(point)
            self.__point = point

class CoordinateChaser(_X3DChaserNode):
    """
    X3D element
    """
    __name__ = 'CoordinateChaser'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#CoordinateChaser'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CoordinateChaser'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('duration', 1, 'SFTime', 'initializeOnly'),
                          ('initialDestination', [0, 0, 0], 'MFVec3f', 'initializeOnly'),
                          ('initialValue', [0, 0, 0], 'MFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 duration=1,
                 initialDestination=[0, 0, 0],
                 initialValue=[0, 0, 0],
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CoordinateChaser __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.duration = duration
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def duration(self):
            return self.__duration
        @duration.setter
        def duration(self, duration=None):
            if  duration is None:
                duration = SFTime.DEFAULT_VALUE
            isValidSFTime(duration)
            self.__duration = duration
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(initialValue)
            self.__initialValue = initialValue

class CoordinateDamper(_X3DDamperNode):
    """
    X3D element
    """
    __name__ = 'CoordinateDamper'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#CoordinateDamper'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CoordinateDamper'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('initialDestination', [0, 0, 0], 'MFVec3f', 'initializeOnly'),
                          ('initialValue', [0, 0, 0], 'MFVec3f', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tau', 0.3, 'SFTime', 'inputOutput'),
                          ('tolerance', -1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 initialDestination=[0, 0, 0],
                 initialValue=[0, 0, 0],
                 order=3,
                 tau=0.3,
                 tolerance=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CoordinateDamper __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        self.order = order
        self.tau = tau
        self.tolerance = tolerance
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(initialValue)
            self.__initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tau(self):
            return self.__tau
        @tau.setter
        def tau(self, tau=None):
            if  tau is None:
                tau = SFTime.DEFAULT_VALUE
            isValidSFTime(tau)
            self.__tau = tau
        @property # - - - - - - - - - - - - -
        def tolerance(self):
            return self.__tolerance
        @tolerance.setter
        def tolerance(self, tolerance=None):
            if  tolerance is None:
                tolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tolerance)
            self.__tolerance = tolerance

class CoordinateDouble(_X3DCoordinateNode):
    """
    X3D element
    """
    __name__ = 'CoordinateDouble'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#CoordinateDouble'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CoordinateDouble'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('point', (list()), 'MFVec3d', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 point=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CoordinateDouble __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.point = point
        @property # - - - - - - - - - - - - -
        def point(self):
            return self.__point
        @point.setter
        def point(self, point=None):
            if  point is None:
                point = MFVec3d.DEFAULT_VALUE
            isValidMFVec3d(point)
            self.__point = point

class CoordinateInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'CoordinateInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#CoordinateInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CoordinateInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CoordinateInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(keyValue)
            self.__keyValue = keyValue

class CoordinateInterpolator2D(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'CoordinateInterpolator2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#CoordinateInterpolator2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CoordinateInterpolator2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CoordinateInterpolator2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(keyValue)
            self.__keyValue = keyValue

class Cylinder(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Cylinder'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry3D.html#Cylinder'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Cylinder'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bottom', True, 'SFBool', 'initializeOnly'),
                          ('height', 2, 'SFFloat', 'initializeOnly'),
                          ('radius', 1, 'SFFloat', 'initializeOnly'),
                          ('side', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('top', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bottom=True,
                 height=2,
                 radius=1,
                 side=True,
                 solid=True,
                 top=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Cylinder __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bottom = bottom
        self.height = height
        self.radius = radius
        self.side = side
        self.solid = solid
        self.top = top
        @property # - - - - - - - - - - - - -
        def bottom(self):
            return self.__bottom
        @bottom.setter
        def bottom(self, bottom=None):
            if  bottom is None:
                bottom = SFBool.DEFAULT_VALUE
            isValidSFBool(bottom)
            self.__bottom = bottom
        @property # - - - - - - - - - - - - -
        def height(self):
            return self.__height
        @height.setter
        def height(self, height=None):
            if  height is None:
                height = SFFloat.DEFAULT_VALUE
            isValidSFFloat(height)
            self.__height = height
        @property # - - - - - - - - - - - - -
        def radius(self):
            return self.__radius
        @radius.setter
        def radius(self, radius=None):
            if  radius is None:
                radius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(radius)
            self.__radius = radius
        @property # - - - - - - - - - - - - -
        def side(self):
            return self.__side
        @side.setter
        def side(self, side=None):
            if  side is None:
                side = SFBool.DEFAULT_VALUE
            isValidSFBool(side)
            self.__side = side
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def top(self):
            return self.__top
        @top.setter
        def top(self, top=None):
            if  top is None:
                top = SFBool.DEFAULT_VALUE
            isValidSFBool(top)
            self.__top = top

class CylinderSensor(_X3DDragSensorNode):
    """
    X3D element
    """
    __name__ = 'CylinderSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/pointingsensor.html#CylinderSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#CylinderSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('autoOffset', True, 'SFBool', 'inputOutput'),
                          ('axisRotation', (0, 1, 0, 0), 'SFRotation', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('diskAngle', 0.26179167, 'SFFloat', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('maxAngle', -1, 'SFFloat', 'inputOutput'),
                          ('minAngle', 0, 'SFFloat', 'inputOutput'),
                          ('offset', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 autoOffset=True,
                 axisRotation=(0, 1, 0, 0),
                 description='',
                 diskAngle=0.26179167,
                 enabled=True,
                 maxAngle=-1,
                 minAngle=0,
                 offset=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode CylinderSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.autoOffset = autoOffset
        self.axisRotation = axisRotation
        self.description = description
        self.diskAngle = diskAngle
        self.enabled = enabled
        self.maxAngle = maxAngle
        self.minAngle = minAngle
        self.offset = offset
        @property # - - - - - - - - - - - - -
        def autoOffset(self):
            return self.__autoOffset
        @autoOffset.setter
        def autoOffset(self, autoOffset=None):
            if  autoOffset is None:
                autoOffset = SFBool.DEFAULT_VALUE
            isValidSFBool(autoOffset)
            self.__autoOffset = autoOffset
        @property # - - - - - - - - - - - - -
        def axisRotation(self):
            return self.__axisRotation
        @axisRotation.setter
        def axisRotation(self, axisRotation=None):
            if  axisRotation is None:
                axisRotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(axisRotation)
            self.__axisRotation = axisRotation
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def diskAngle(self):
            return self.__diskAngle
        @diskAngle.setter
        def diskAngle(self, diskAngle=None):
            if  diskAngle is None:
                diskAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(diskAngle)
            self.__diskAngle = diskAngle
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def maxAngle(self):
            return self.__maxAngle
        @maxAngle.setter
        def maxAngle(self, maxAngle=None):
            if  maxAngle is None:
                maxAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxAngle)
            self.__maxAngle = maxAngle
        @property # - - - - - - - - - - - - -
        def minAngle(self):
            return self.__minAngle
        @minAngle.setter
        def minAngle(self, minAngle=None):
            if  minAngle is None:
                minAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minAngle)
            self.__minAngle = minAngle
        @property # - - - - - - - - - - - - -
        def offset(self):
            return self.__offset
        @offset.setter
        def offset(self, offset=None):
            if  offset is None:
                offset = SFFloat.DEFAULT_VALUE
            isValidSFFloat(offset)
            self.__offset = offset

class DirectionalLight(_X3DLightNode):
    """
    DirectionalLight might not be scoped by parent Group or Transform at levels 1 or 2.
    """
    __name__ = 'DirectionalLight'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/lighting.html#DirectionalLight'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#DirectionalLight'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ambientIntensity', 0, 'SFFloat', 'inputOutput'),
                          ('color', (1, 1, 1), 'SFColor', 'inputOutput'),
                          ('direction', (0, 0, -1), 'SFVec3f', 'inputOutput'),
                          ('global_', False, 'SFBool', 'inputOutput'),
                          ('intensity', 1, 'SFFloat', 'inputOutput'),
                          ('on', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ambientIntensity=0,
                 color=(1, 1, 1),
                 direction=(0, 0, -1),
                 global_=False,
                 intensity=1,
                 on=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode DirectionalLight __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ambientIntensity = ambientIntensity
        self.color = color
        self.direction = direction
        self.global_ = global_
        self.intensity = intensity
        self.on = on
        @property # - - - - - - - - - - - - -
        def ambientIntensity(self):
            return self.__ambientIntensity
        @ambientIntensity.setter
        def ambientIntensity(self, ambientIntensity=None):
            if  ambientIntensity is None:
                ambientIntensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(ambientIntensity)
            self.__ambientIntensity = ambientIntensity
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFColor.DEFAULT_VALUE
            isValidSFColor(color)
            self.__color = color
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def global_(self):
            return self.__global_
        @global_.setter
        def global_(self, global_=None):
            if  global_ is None:
                global_ = SFBool.DEFAULT_VALUE
            isValidSFBool(global_)
            self.__global_ = global_
        @property # - - - - - - - - - - - - -
        def intensity(self):
            return self.__intensity
        @intensity.setter
        def intensity(self, intensity=None):
            if  intensity is None:
                intensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(intensity)
            self.__intensity = intensity
        @property # - - - - - - - - - - - - -
        def on(self):
            return self.__on
        @on.setter
        def on(self, on=None):
            if  on is None:
                on = SFBool.DEFAULT_VALUE
            isValidSFBool(on)
            self.__on = on

class DISEntityManager(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'DISEntityManager'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/dis.html#DISEntityManager'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#DISEntityManager'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('address', 'localhost', 'SFString', 'inputOutput'),
                          ('applicationID', 0, 'SFInt32', 'inputOutput'),
                          ('port', 0, 'SFInt32', 'inputOutput'),
                          ('siteID', 0, 'SFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('mapping', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 address='localhost',
                 applicationID=0,
                 port=0,
                 siteID=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 mapping=list()):
        # if _DEBUG: print ('... in ConcreteNode DISEntityManager __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.address = address
        self.applicationID = applicationID
        self.port = port
        self.siteID = siteID
        self.mapping = mapping
        @property # - - - - - - - - - - - - -
        def address(self):
            return self.__address
        @address.setter
        def address(self, address=None):
            if  address is None:
                address = SFString.DEFAULT_VALUE
            isValidSFString(address)
            self.__address = address
        @property # - - - - - - - - - - - - -
        def applicationID(self):
            return self.__applicationID
        @applicationID.setter
        def applicationID(self, applicationID=None):
            if  applicationID is None:
                applicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(applicationID)
            self.__applicationID = applicationID
        @property # - - - - - - - - - - - - -
        def port(self):
            return self.__port
        @port.setter
        def port(self, port=None):
            if  port is None:
                port = SFInt32.DEFAULT_VALUE
            isValidSFInt32(port)
            self.__port = port
        @property # - - - - - - - - - - - - -
        def siteID(self):
            return self.__siteID
        @siteID.setter
        def siteID(self, siteID=None):
            if  siteID is None:
                siteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(siteID)
            self.__siteID = siteID
        @property # - - - - - - - - - - - - -
        def mapping(self):
            return self.__mapping
        @mapping.setter
        def mapping(self, mapping=None):
            if  mapping is None:
                mapping = MFNode.DEFAULT_VALUE
            isValidMFNode(mapping)
            self.__mapping = mapping

class DISEntityTypeMapping(_X3DInfoNode):
    """
    X3D element
    """
    __name__ = 'DISEntityTypeMapping'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/dis.html#DISEntityTypeMapping'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#DISEntityTypeMapping'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('category', 0, 'SFInt32', 'initializeOnly'),
                          ('country', 0, 'SFInt32', 'initializeOnly'),
                          ('domain', 0, 'SFInt32', 'initializeOnly'),
                          ('extra', 0, 'SFInt32', 'initializeOnly'),
                          ('kind', 0, 'SFInt32', 'initializeOnly'),
                          ('specific', 0, 'SFInt32', 'initializeOnly'),
                          ('subcategory', 0, 'SFInt32', 'initializeOnly'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 category=0,
                 country=0,
                 domain=0,
                 extra=0,
                 kind=0,
                 specific=0,
                 subcategory=0,
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode DISEntityTypeMapping __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.category = category
        self.country = country
        self.domain = domain
        self.extra = extra
        self.kind = kind
        self.specific = specific
        self.subcategory = subcategory
        self.url = url
        @property # - - - - - - - - - - - - -
        def category(self):
            return self.__category
        @category.setter
        def category(self, category=None):
            if  category is None:
                category = SFInt32.DEFAULT_VALUE
            isValidSFInt32(category)
            self.__category = category
        @property # - - - - - - - - - - - - -
        def country(self):
            return self.__country
        @country.setter
        def country(self, country=None):
            if  country is None:
                country = SFInt32.DEFAULT_VALUE
            isValidSFInt32(country)
            self.__country = country
        @property # - - - - - - - - - - - - -
        def domain(self):
            return self.__domain
        @domain.setter
        def domain(self, domain=None):
            if  domain is None:
                domain = SFInt32.DEFAULT_VALUE
            isValidSFInt32(domain)
            self.__domain = domain
        @property # - - - - - - - - - - - - -
        def extra(self):
            return self.__extra
        @extra.setter
        def extra(self, extra=None):
            if  extra is None:
                extra = SFInt32.DEFAULT_VALUE
            isValidSFInt32(extra)
            self.__extra = extra
        @property # - - - - - - - - - - - - -
        def kind(self):
            return self.__kind
        @kind.setter
        def kind(self, kind=None):
            if  kind is None:
                kind = SFInt32.DEFAULT_VALUE
            isValidSFInt32(kind)
            self.__kind = kind
        @property # - - - - - - - - - - - - -
        def specific(self):
            return self.__specific
        @specific.setter
        def specific(self, specific=None):
            if  specific is None:
                specific = SFInt32.DEFAULT_VALUE
            isValidSFInt32(specific)
            self.__specific = specific
        @property # - - - - - - - - - - - - -
        def subcategory(self):
            return self.__subcategory
        @subcategory.setter
        def subcategory(self, subcategory=None):
            if  subcategory is None:
                subcategory = SFInt32.DEFAULT_VALUE
            isValidSFInt32(subcategory)
            self.__subcategory = subcategory
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url

class Disk2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Disk2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#Disk2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Disk2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('innerRadius', 0, 'SFFloat', 'initializeOnly'),
                          ('outerRadius', 1, 'SFFloat', 'initializeOnly'),
                          ('solid', False, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 innerRadius=0,
                 outerRadius=1,
                 solid=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Disk2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.innerRadius = innerRadius
        self.outerRadius = outerRadius
        self.solid = solid
        @property # - - - - - - - - - - - - -
        def innerRadius(self):
            return self.__innerRadius
        @innerRadius.setter
        def innerRadius(self, innerRadius=None):
            if  innerRadius is None:
                innerRadius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(innerRadius)
            self.__innerRadius = innerRadius
        @property # - - - - - - - - - - - - -
        def outerRadius(self):
            return self.__outerRadius
        @outerRadius.setter
        def outerRadius(self, outerRadius=None):
            if  outerRadius is None:
                outerRadius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(outerRadius)
            self.__outerRadius = outerRadius
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid

class DoubleAxisHingeJoint(_X3DRigidJointNode):
    """
    DoubleAxisHingeJoint has two independent axes located around a common anchor point.
    """
    __name__ = 'DoubleAxisHingeJoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#DoubleAxisHingeJoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#DoubleAxisHingeJoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('anchorPoint', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('axis1', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('axis2', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('desiredAngularVelocity1', 0, 'SFFloat', 'inputOutput'),
                          ('desiredAngularVelocity2', 0, 'SFFloat', 'inputOutput'),
                          ('forceOutput', ["NONE"], 'MFString', 'inputOutput'),
                          ('maxAngle1', 3.141592653, 'SFFloat', 'inputOutput'),
                          ('maxTorque1', 0, 'SFFloat', 'inputOutput'),
                          ('maxTorque2', 0, 'SFFloat', 'inputOutput'),
                          ('minAngle1', -3.141592653, 'SFFloat', 'inputOutput'),
                          ('stop1Bounce', 0, 'SFFloat', 'inputOutput'),
                          ('stop1ConstantForceMix', 0.001, 'SFFloat', 'inputOutput'),
                          ('stop1ErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('suspensionErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('suspensionForce', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('body1', None, 'SFNode', 'inputOutput'),
                          ('body2', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 anchorPoint=(0, 0, 0),
                 axis1=(0, 0, 0),
                 axis2=(0, 0, 0),
                 desiredAngularVelocity1=0,
                 desiredAngularVelocity2=0,
                 forceOutput=["NONE"],
                 maxAngle1=3.141592653,
                 maxTorque1=0,
                 maxTorque2=0,
                 minAngle1=-3.141592653,
                 stop1Bounce=0,
                 stop1ConstantForceMix=0.001,
                 stop1ErrorCorrection=0.8,
                 suspensionErrorCorrection=0.8,
                 suspensionForce=0,
                 USE='',
                 class_='',
                 body1=None,
                 body2=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode DoubleAxisHingeJoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.anchorPoint = anchorPoint
        self.axis1 = axis1
        self.axis2 = axis2
        self.desiredAngularVelocity1 = desiredAngularVelocity1
        self.desiredAngularVelocity2 = desiredAngularVelocity2
        self.forceOutput = forceOutput
        self.maxAngle1 = maxAngle1
        self.maxTorque1 = maxTorque1
        self.maxTorque2 = maxTorque2
        self.minAngle1 = minAngle1
        self.stop1Bounce = stop1Bounce
        self.stop1ConstantForceMix = stop1ConstantForceMix
        self.stop1ErrorCorrection = stop1ErrorCorrection
        self.suspensionErrorCorrection = suspensionErrorCorrection
        self.suspensionForce = suspensionForce
        self.body1 = body1
        self.body2 = body2
        @property # - - - - - - - - - - - - -
        def anchorPoint(self):
            return self.__anchorPoint
        @anchorPoint.setter
        def anchorPoint(self, anchorPoint=None):
            if  anchorPoint is None:
                anchorPoint = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(anchorPoint)
            self.__anchorPoint = anchorPoint
        @property # - - - - - - - - - - - - -
        def axis1(self):
            return self.__axis1
        @axis1.setter
        def axis1(self, axis1=None):
            if  axis1 is None:
                axis1 = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(axis1)
            self.__axis1 = axis1
        @property # - - - - - - - - - - - - -
        def axis2(self):
            return self.__axis2
        @axis2.setter
        def axis2(self, axis2=None):
            if  axis2 is None:
                axis2 = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(axis2)
            self.__axis2 = axis2
        @property # - - - - - - - - - - - - -
        def desiredAngularVelocity1(self):
            return self.__desiredAngularVelocity1
        @desiredAngularVelocity1.setter
        def desiredAngularVelocity1(self, desiredAngularVelocity1=None):
            if  desiredAngularVelocity1 is None:
                desiredAngularVelocity1 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(desiredAngularVelocity1)
            self.__desiredAngularVelocity1 = desiredAngularVelocity1
        @property # - - - - - - - - - - - - -
        def desiredAngularVelocity2(self):
            return self.__desiredAngularVelocity2
        @desiredAngularVelocity2.setter
        def desiredAngularVelocity2(self, desiredAngularVelocity2=None):
            if  desiredAngularVelocity2 is None:
                desiredAngularVelocity2 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(desiredAngularVelocity2)
            self.__desiredAngularVelocity2 = desiredAngularVelocity2
        @property # - - - - - - - - - - - - -
        def forceOutput(self):
            return self.__forceOutput
        @forceOutput.setter
        def forceOutput(self, forceOutput=None):
            if  forceOutput is None:
                forceOutput = MFString.DEFAULT_VALUE
            isValidMFString(forceOutput)
            self.__forceOutput = forceOutput
        @property # - - - - - - - - - - - - -
        def maxAngle1(self):
            return self.__maxAngle1
        @maxAngle1.setter
        def maxAngle1(self, maxAngle1=None):
            if  maxAngle1 is None:
                maxAngle1 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxAngle1)
            self.__maxAngle1 = maxAngle1
        @property # - - - - - - - - - - - - -
        def maxTorque1(self):
            return self.__maxTorque1
        @maxTorque1.setter
        def maxTorque1(self, maxTorque1=None):
            if  maxTorque1 is None:
                maxTorque1 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxTorque1)
            self.__maxTorque1 = maxTorque1
        @property # - - - - - - - - - - - - -
        def maxTorque2(self):
            return self.__maxTorque2
        @maxTorque2.setter
        def maxTorque2(self, maxTorque2=None):
            if  maxTorque2 is None:
                maxTorque2 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxTorque2)
            self.__maxTorque2 = maxTorque2
        @property # - - - - - - - - - - - - -
        def minAngle1(self):
            return self.__minAngle1
        @minAngle1.setter
        def minAngle1(self, minAngle1=None):
            if  minAngle1 is None:
                minAngle1 = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minAngle1)
            self.__minAngle1 = minAngle1
        @property # - - - - - - - - - - - - -
        def stop1Bounce(self):
            return self.__stop1Bounce
        @stop1Bounce.setter
        def stop1Bounce(self, stop1Bounce=None):
            if  stop1Bounce is None:
                stop1Bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop1Bounce)
            self.__stop1Bounce = stop1Bounce
        @property # - - - - - - - - - - - - -
        def stop1ConstantForceMix(self):
            return self.__stop1ConstantForceMix
        @stop1ConstantForceMix.setter
        def stop1ConstantForceMix(self, stop1ConstantForceMix=None):
            if  stop1ConstantForceMix is None:
                stop1ConstantForceMix = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop1ConstantForceMix)
            self.__stop1ConstantForceMix = stop1ConstantForceMix
        @property # - - - - - - - - - - - - -
        def stop1ErrorCorrection(self):
            return self.__stop1ErrorCorrection
        @stop1ErrorCorrection.setter
        def stop1ErrorCorrection(self, stop1ErrorCorrection=None):
            if  stop1ErrorCorrection is None:
                stop1ErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop1ErrorCorrection)
            self.__stop1ErrorCorrection = stop1ErrorCorrection
        @property # - - - - - - - - - - - - -
        def suspensionErrorCorrection(self):
            return self.__suspensionErrorCorrection
        @suspensionErrorCorrection.setter
        def suspensionErrorCorrection(self, suspensionErrorCorrection=None):
            if  suspensionErrorCorrection is None:
                suspensionErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(suspensionErrorCorrection)
            self.__suspensionErrorCorrection = suspensionErrorCorrection
        @property # - - - - - - - - - - - - -
        def suspensionForce(self):
            return self.__suspensionForce
        @suspensionForce.setter
        def suspensionForce(self, suspensionForce=None):
            if  suspensionForce is None:
                suspensionForce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(suspensionForce)
            self.__suspensionForce = suspensionForce
        @property # - - - - - - - - - - - - -
        def body1(self):
            return self.__body1
        @body1.setter
        def body1(self, body1=None):
            if  body1 is None:
                body1 = SFNode.DEFAULT_VALUE
            isValidSFNode(body1)
            if not isinstance(body1, object):
                raise RuntimeError(str(body1) + ' does not have a valid node type object')
            self.__body1 = body1
        @property # - - - - - - - - - - - - -
        def body2(self):
            return self.__body2
        @body2.setter
        def body2(self, body2=None):
            if  body2 is None:
                body2 = SFNode.DEFAULT_VALUE
            isValidSFNode(body2)
            if not isinstance(body2, object):
                raise RuntimeError(str(body2) + ' does not have a valid node type object')
            self.__body2 = body2

class EaseInEaseOut(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'EaseInEaseOut'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#EaseInEaseOut'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#EaseInEaseOut'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('easeInEaseOut', (list()), 'MFVec2f', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 easeInEaseOut=(list()),
                 key=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode EaseInEaseOut __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.easeInEaseOut = easeInEaseOut
        self.key = key
        @property # - - - - - - - - - - - - -
        def easeInEaseOut(self):
            return self.__easeInEaseOut
        @easeInEaseOut.setter
        def easeInEaseOut(self, easeInEaseOut=None):
            if  easeInEaseOut is None:
                easeInEaseOut = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(easeInEaseOut)
            self.__easeInEaseOut = easeInEaseOut
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key

class EdgeEnhancementVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'EdgeEnhancementVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#EdgeEnhancementVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#EdgeEnhancementVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('edgeColor', (0, 0, 0, 1), 'SFColorRGBA', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('gradientThreshold', 0.4, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('surfaceNormals', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 edgeColor=(0, 0, 0, 1),
                 enabled=True,
                 gradientThreshold=0.4,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 surfaceNormals=None):
        # if _DEBUG: print ('... in ConcreteNode EdgeEnhancementVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.edgeColor = edgeColor
        self.enabled = enabled
        self.gradientThreshold = gradientThreshold
        self.surfaceNormals = surfaceNormals
        @property # - - - - - - - - - - - - -
        def edgeColor(self):
            return self.__edgeColor
        @edgeColor.setter
        def edgeColor(self, edgeColor=None):
            if  edgeColor is None:
                edgeColor = SFColorRGBA.DEFAULT_VALUE
            isValidSFColorRGBA(edgeColor)
            self.__edgeColor = edgeColor
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def gradientThreshold(self):
            return self.__gradientThreshold
        @gradientThreshold.setter
        def gradientThreshold(self, gradientThreshold=None):
            if  gradientThreshold is None:
                gradientThreshold = SFFloat.DEFAULT_VALUE
            isValidSFFloat(gradientThreshold)
            self.__gradientThreshold = gradientThreshold
        @property # - - - - - - - - - - - - -
        def surfaceNormals(self):
            return self.__surfaceNormals
        @surfaceNormals.setter
        def surfaceNormals(self, surfaceNormals=None):
            if  surfaceNormals is None:
                surfaceNormals = SFNode.DEFAULT_VALUE
            isValidSFNode(surfaceNormals)
            if not isinstance(surfaceNormals, object):
                raise RuntimeError(str(surfaceNormals) + ' does not have a valid node type object')
            self.__surfaceNormals = surfaceNormals

class ElevationGrid(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'ElevationGrid'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry3D.html#ElevationGrid'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ElevationGrid'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('creaseAngle', 0, 'SFFloat', 'initializeOnly'),
                          ('height', [0, 0, 0, 0], 'MFFloat', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('xDimension', 2, 'SFInt32', 'initializeOnly'),
                          ('xSpacing', 1.0, 'SFFloat', 'initializeOnly'),
                          ('zDimension', 2, 'SFInt32', 'initializeOnly'),
                          ('zSpacing', 1.0, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 creaseAngle=0,
                 height=[0, 0, 0, 0],
                 normalPerVertex=True,
                 solid=True,
                 xDimension=2,
                 xSpacing=1.0,
                 zDimension=2,
                 zSpacing=1.0,
                 USE='',
                 class_='',
                 color=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode ElevationGrid __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.creaseAngle = creaseAngle
        self.height = height
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.xDimension = xDimension
        self.xSpacing = xSpacing
        self.zDimension = zDimension
        self.zSpacing = zSpacing
        self.color = color
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def creaseAngle(self):
            return self.__creaseAngle
        @creaseAngle.setter
        def creaseAngle(self, creaseAngle=None):
            if  creaseAngle is None:
                creaseAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(creaseAngle)
            self.__creaseAngle = creaseAngle
        @property # - - - - - - - - - - - - -
        def height(self):
            return self.__height
        @height.setter
        def height(self, height=None):
            if  height is None:
                height = MFFloat.DEFAULT_VALUE
            isValidMFFloat(height)
            self.__height = height
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def xDimension(self):
            return self.__xDimension
        @xDimension.setter
        def xDimension(self, xDimension=None):
            if  xDimension is None:
                xDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(xDimension)
            self.__xDimension = xDimension
        @property # - - - - - - - - - - - - -
        def xSpacing(self):
            return self.__xSpacing
        @xSpacing.setter
        def xSpacing(self, xSpacing=None):
            if  xSpacing is None:
                xSpacing = SFFloat.DEFAULT_VALUE
            isValidSFFloat(xSpacing)
            self.__xSpacing = xSpacing
        @property # - - - - - - - - - - - - -
        def zDimension(self):
            return self.__zDimension
        @zDimension.setter
        def zDimension(self, zDimension=None):
            if  zDimension is None:
                zDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(zDimension)
            self.__zDimension = zDimension
        @property # - - - - - - - - - - - - -
        def zSpacing(self):
            return self.__zSpacing
        @zSpacing.setter
        def zSpacing(self, zSpacing=None):
            if  zSpacing is None:
                zSpacing = SFFloat.DEFAULT_VALUE
            isValidSFFloat(zSpacing)
            self.__zSpacing = zSpacing
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class EspduTransform(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'EspduTransform'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/dis.html#EspduTransform'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#EspduTransform'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('address', 'localhost', 'SFString', 'inputOutput'),
                          ('applicationID', 0, 'SFInt32', 'inputOutput'),
                          ('articulationParameterArray', list(), 'MFFloat', 'inputOutput'),
                          ('articulationParameterChangeIndicatorArray', list(), 'MFInt32', 'inputOutput'),
                          ('articulationParameterCount', 0, 'SFInt32', 'inputOutput'),
                          ('articulationParameterDesignatorArray', list(), 'MFInt32', 'inputOutput'),
                          ('articulationParameterIdPartAttachedToArray', list(), 'MFInt32', 'inputOutput'),
                          ('articulationParameterTypeArray', list(), 'MFInt32', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('collisionType', 0, 'SFInt32', 'inputOutput'),
                          ('deadReckoning', 0, 'SFInt32', 'inputOutput'),
                          ('detonationLocation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('detonationRelativeLocation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('detonationResult', 0, 'SFInt32', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('entityCategory', 0, 'SFInt32', 'inputOutput'),
                          ('entityCountry', 0, 'SFInt32', 'inputOutput'),
                          ('entityDomain', 0, 'SFInt32', 'inputOutput'),
                          ('entityExtra', 0, 'SFInt32', 'inputOutput'),
                          ('entityID', 0, 'SFInt32', 'inputOutput'),
                          ('entityKind', 0, 'SFInt32', 'inputOutput'),
                          ('entitySpecific', 0, 'SFInt32', 'inputOutput'),
                          ('entitySubcategory', 0, 'SFInt32', 'inputOutput'),
                          ('eventApplicationID', 0, 'SFInt32', 'inputOutput'),
                          ('eventEntityID', 0, 'SFInt32', 'inputOutput'),
                          ('eventNumber', 0, 'SFInt32', 'inputOutput'),
                          ('eventSiteID', 0, 'SFInt32', 'inputOutput'),
                          ('fired1', False, 'SFBool', 'inputOutput'),
                          ('fired2', False, 'SFBool', 'inputOutput'),
                          ('fireMissionIndex', 0, 'SFInt32', 'inputOutput'),
                          ('firingRange', 0, 'SFFloat', 'inputOutput'),
                          ('firingRate', 0, 'SFInt32', 'inputOutput'),
                          ('forceID', 0, 'SFInt32', 'inputOutput'),
                          ('fuse', 0, 'SFInt32', 'inputOutput'),
                          ('geoCoords', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('linearAcceleration', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('linearVelocity', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('marking', '', 'SFString', 'inputOutput'),
                          ('multicastRelayHost', '', 'SFString', 'inputOutput'),
                          ('multicastRelayPort', 0, 'SFInt32', 'inputOutput'),
                          ('munitionApplicationID', 0, 'SFInt32', 'inputOutput'),
                          ('munitionEndPoint', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('munitionEntityID', 0, 'SFInt32', 'inputOutput'),
                          ('munitionQuantity', 0, 'SFInt32', 'inputOutput'),
                          ('munitionSiteID', 0, 'SFInt32', 'inputOutput'),
                          ('munitionStartPoint', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('networkMode', 'standAlone', 'SFString', 'inputOutput'),
                          ('port', 0, 'SFInt32', 'inputOutput'),
                          ('readInterval', 0.1, 'SFTime', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('rtpHeaderExpected', False, 'SFBool', 'initializeOnly'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('scaleOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('siteID', 0, 'SFInt32', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('warhead', 0, 'SFInt32', 'inputOutput'),
                          ('writeInterval', 1.0, 'SFTime', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 address='localhost',
                 applicationID=0,
                 articulationParameterArray=list(),
                 articulationParameterChangeIndicatorArray=list(),
                 articulationParameterCount=0,
                 articulationParameterDesignatorArray=list(),
                 articulationParameterIdPartAttachedToArray=list(),
                 articulationParameterTypeArray=list(),
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 collisionType=0,
                 deadReckoning=0,
                 detonationLocation=(0, 0, 0),
                 detonationRelativeLocation=(0, 0, 0),
                 detonationResult=0,
                 enabled=True,
                 entityCategory=0,
                 entityCountry=0,
                 entityDomain=0,
                 entityExtra=0,
                 entityID=0,
                 entityKind=0,
                 entitySpecific=0,
                 entitySubcategory=0,
                 eventApplicationID=0,
                 eventEntityID=0,
                 eventNumber=0,
                 eventSiteID=0,
                 fired1=False,
                 fired2=False,
                 fireMissionIndex=0,
                 firingRange=0,
                 firingRate=0,
                 forceID=0,
                 fuse=0,
                 geoCoords=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 linearAcceleration=(0, 0, 0),
                 linearVelocity=(0, 0, 0),
                 marking='',
                 multicastRelayHost='',
                 multicastRelayPort=0,
                 munitionApplicationID=0,
                 munitionEndPoint=(0, 0, 0),
                 munitionEntityID=0,
                 munitionQuantity=0,
                 munitionSiteID=0,
                 munitionStartPoint=(0, 0, 0),
                 networkMode='standAlone',
                 port=0,
                 readInterval=0.1,
                 rotation=(0, 0, 1, 0),
                 rtpHeaderExpected=False,
                 scale=(1, 1, 1),
                 scaleOrientation=(0, 0, 1, 0),
                 siteID=0,
                 translation=(0, 0, 0),
                 warhead=0,
                 writeInterval=1.0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode EspduTransform __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.address = address
        self.applicationID = applicationID
        self.articulationParameterArray = articulationParameterArray
        self.articulationParameterChangeIndicatorArray = articulationParameterChangeIndicatorArray
        self.articulationParameterCount = articulationParameterCount
        self.articulationParameterDesignatorArray = articulationParameterDesignatorArray
        self.articulationParameterIdPartAttachedToArray = articulationParameterIdPartAttachedToArray
        self.articulationParameterTypeArray = articulationParameterTypeArray
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.collisionType = collisionType
        self.deadReckoning = deadReckoning
        self.detonationLocation = detonationLocation
        self.detonationRelativeLocation = detonationRelativeLocation
        self.detonationResult = detonationResult
        self.enabled = enabled
        self.entityCategory = entityCategory
        self.entityCountry = entityCountry
        self.entityDomain = entityDomain
        self.entityExtra = entityExtra
        self.entityID = entityID
        self.entityKind = entityKind
        self.entitySpecific = entitySpecific
        self.entitySubcategory = entitySubcategory
        self.eventApplicationID = eventApplicationID
        self.eventEntityID = eventEntityID
        self.eventNumber = eventNumber
        self.eventSiteID = eventSiteID
        self.fired1 = fired1
        self.fired2 = fired2
        self.fireMissionIndex = fireMissionIndex
        self.firingRange = firingRange
        self.firingRate = firingRate
        self.forceID = forceID
        self.fuse = fuse
        self.geoCoords = geoCoords
        self.geoSystem = geoSystem
        self.linearAcceleration = linearAcceleration
        self.linearVelocity = linearVelocity
        self.marking = marking
        self.multicastRelayHost = multicastRelayHost
        self.multicastRelayPort = multicastRelayPort
        self.munitionApplicationID = munitionApplicationID
        self.munitionEndPoint = munitionEndPoint
        self.munitionEntityID = munitionEntityID
        self.munitionQuantity = munitionQuantity
        self.munitionSiteID = munitionSiteID
        self.munitionStartPoint = munitionStartPoint
        self.networkMode = networkMode
        self.port = port
        self.readInterval = readInterval
        self.rotation = rotation
        self.rtpHeaderExpected = rtpHeaderExpected
        self.scale = scale
        self.scaleOrientation = scaleOrientation
        self.siteID = siteID
        self.translation = translation
        self.warhead = warhead
        self.writeInterval = writeInterval
        self.children = children
        @property # - - - - - - - - - - - - -
        def address(self):
            return self.__address
        @address.setter
        def address(self, address=None):
            if  address is None:
                address = SFString.DEFAULT_VALUE
            isValidSFString(address)
            self.__address = address
        @property # - - - - - - - - - - - - -
        def applicationID(self):
            return self.__applicationID
        @applicationID.setter
        def applicationID(self, applicationID=None):
            if  applicationID is None:
                applicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(applicationID)
            self.__applicationID = applicationID
        @property # - - - - - - - - - - - - -
        def articulationParameterArray(self):
            return self.__articulationParameterArray
        @articulationParameterArray.setter
        def articulationParameterArray(self, articulationParameterArray=None):
            if  articulationParameterArray is None:
                articulationParameterArray = MFFloat.DEFAULT_VALUE
            isValidMFFloat(articulationParameterArray)
            self.__articulationParameterArray = articulationParameterArray
        @property # - - - - - - - - - - - - -
        def articulationParameterChangeIndicatorArray(self):
            return self.__articulationParameterChangeIndicatorArray
        @articulationParameterChangeIndicatorArray.setter
        def articulationParameterChangeIndicatorArray(self, articulationParameterChangeIndicatorArray=None):
            if  articulationParameterChangeIndicatorArray is None:
                articulationParameterChangeIndicatorArray = MFInt32.DEFAULT_VALUE
            isValidMFInt32(articulationParameterChangeIndicatorArray)
            self.__articulationParameterChangeIndicatorArray = articulationParameterChangeIndicatorArray
        @property # - - - - - - - - - - - - -
        def articulationParameterCount(self):
            return self.__articulationParameterCount
        @articulationParameterCount.setter
        def articulationParameterCount(self, articulationParameterCount=None):
            if  articulationParameterCount is None:
                articulationParameterCount = SFInt32.DEFAULT_VALUE
            isValidSFInt32(articulationParameterCount)
            self.__articulationParameterCount = articulationParameterCount
        @property # - - - - - - - - - - - - -
        def articulationParameterDesignatorArray(self):
            return self.__articulationParameterDesignatorArray
        @articulationParameterDesignatorArray.setter
        def articulationParameterDesignatorArray(self, articulationParameterDesignatorArray=None):
            if  articulationParameterDesignatorArray is None:
                articulationParameterDesignatorArray = MFInt32.DEFAULT_VALUE
            isValidMFInt32(articulationParameterDesignatorArray)
            self.__articulationParameterDesignatorArray = articulationParameterDesignatorArray
        @property # - - - - - - - - - - - - -
        def articulationParameterIdPartAttachedToArray(self):
            return self.__articulationParameterIdPartAttachedToArray
        @articulationParameterIdPartAttachedToArray.setter
        def articulationParameterIdPartAttachedToArray(self, articulationParameterIdPartAttachedToArray=None):
            if  articulationParameterIdPartAttachedToArray is None:
                articulationParameterIdPartAttachedToArray = MFInt32.DEFAULT_VALUE
            isValidMFInt32(articulationParameterIdPartAttachedToArray)
            self.__articulationParameterIdPartAttachedToArray = articulationParameterIdPartAttachedToArray
        @property # - - - - - - - - - - - - -
        def articulationParameterTypeArray(self):
            return self.__articulationParameterTypeArray
        @articulationParameterTypeArray.setter
        def articulationParameterTypeArray(self, articulationParameterTypeArray=None):
            if  articulationParameterTypeArray is None:
                articulationParameterTypeArray = MFInt32.DEFAULT_VALUE
            isValidMFInt32(articulationParameterTypeArray)
            self.__articulationParameterTypeArray = articulationParameterTypeArray
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def collisionType(self):
            return self.__collisionType
        @collisionType.setter
        def collisionType(self, collisionType=None):
            if  collisionType is None:
                collisionType = SFInt32.DEFAULT_VALUE
            isValidSFInt32(collisionType)
            self.__collisionType = collisionType
        @property # - - - - - - - - - - - - -
        def deadReckoning(self):
            return self.__deadReckoning
        @deadReckoning.setter
        def deadReckoning(self, deadReckoning=None):
            if  deadReckoning is None:
                deadReckoning = SFInt32.DEFAULT_VALUE
            isValidSFInt32(deadReckoning)
            self.__deadReckoning = deadReckoning
        @property # - - - - - - - - - - - - -
        def detonationLocation(self):
            return self.__detonationLocation
        @detonationLocation.setter
        def detonationLocation(self, detonationLocation=None):
            if  detonationLocation is None:
                detonationLocation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(detonationLocation)
            self.__detonationLocation = detonationLocation
        @property # - - - - - - - - - - - - -
        def detonationRelativeLocation(self):
            return self.__detonationRelativeLocation
        @detonationRelativeLocation.setter
        def detonationRelativeLocation(self, detonationRelativeLocation=None):
            if  detonationRelativeLocation is None:
                detonationRelativeLocation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(detonationRelativeLocation)
            self.__detonationRelativeLocation = detonationRelativeLocation
        @property # - - - - - - - - - - - - -
        def detonationResult(self):
            return self.__detonationResult
        @detonationResult.setter
        def detonationResult(self, detonationResult=None):
            if  detonationResult is None:
                detonationResult = SFInt32.DEFAULT_VALUE
            isValidSFInt32(detonationResult)
            self.__detonationResult = detonationResult
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def entityCategory(self):
            return self.__entityCategory
        @entityCategory.setter
        def entityCategory(self, entityCategory=None):
            if  entityCategory is None:
                entityCategory = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityCategory)
            self.__entityCategory = entityCategory
        @property # - - - - - - - - - - - - -
        def entityCountry(self):
            return self.__entityCountry
        @entityCountry.setter
        def entityCountry(self, entityCountry=None):
            if  entityCountry is None:
                entityCountry = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityCountry)
            self.__entityCountry = entityCountry
        @property # - - - - - - - - - - - - -
        def entityDomain(self):
            return self.__entityDomain
        @entityDomain.setter
        def entityDomain(self, entityDomain=None):
            if  entityDomain is None:
                entityDomain = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityDomain)
            self.__entityDomain = entityDomain
        @property # - - - - - - - - - - - - -
        def entityExtra(self):
            return self.__entityExtra
        @entityExtra.setter
        def entityExtra(self, entityExtra=None):
            if  entityExtra is None:
                entityExtra = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityExtra)
            self.__entityExtra = entityExtra
        @property # - - - - - - - - - - - - -
        def entityID(self):
            return self.__entityID
        @entityID.setter
        def entityID(self, entityID=None):
            if  entityID is None:
                entityID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityID)
            self.__entityID = entityID
        @property # - - - - - - - - - - - - -
        def entityKind(self):
            return self.__entityKind
        @entityKind.setter
        def entityKind(self, entityKind=None):
            if  entityKind is None:
                entityKind = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityKind)
            self.__entityKind = entityKind
        @property # - - - - - - - - - - - - -
        def entitySpecific(self):
            return self.__entitySpecific
        @entitySpecific.setter
        def entitySpecific(self, entitySpecific=None):
            if  entitySpecific is None:
                entitySpecific = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entitySpecific)
            self.__entitySpecific = entitySpecific
        @property # - - - - - - - - - - - - -
        def entitySubcategory(self):
            return self.__entitySubcategory
        @entitySubcategory.setter
        def entitySubcategory(self, entitySubcategory=None):
            if  entitySubcategory is None:
                entitySubcategory = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entitySubcategory)
            self.__entitySubcategory = entitySubcategory
        @property # - - - - - - - - - - - - -
        def eventApplicationID(self):
            return self.__eventApplicationID
        @eventApplicationID.setter
        def eventApplicationID(self, eventApplicationID=None):
            if  eventApplicationID is None:
                eventApplicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(eventApplicationID)
            self.__eventApplicationID = eventApplicationID
        @property # - - - - - - - - - - - - -
        def eventEntityID(self):
            return self.__eventEntityID
        @eventEntityID.setter
        def eventEntityID(self, eventEntityID=None):
            if  eventEntityID is None:
                eventEntityID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(eventEntityID)
            self.__eventEntityID = eventEntityID
        @property # - - - - - - - - - - - - -
        def eventNumber(self):
            return self.__eventNumber
        @eventNumber.setter
        def eventNumber(self, eventNumber=None):
            if  eventNumber is None:
                eventNumber = SFInt32.DEFAULT_VALUE
            isValidSFInt32(eventNumber)
            self.__eventNumber = eventNumber
        @property # - - - - - - - - - - - - -
        def eventSiteID(self):
            return self.__eventSiteID
        @eventSiteID.setter
        def eventSiteID(self, eventSiteID=None):
            if  eventSiteID is None:
                eventSiteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(eventSiteID)
            self.__eventSiteID = eventSiteID
        @property # - - - - - - - - - - - - -
        def fired1(self):
            return self.__fired1
        @fired1.setter
        def fired1(self, fired1=None):
            if  fired1 is None:
                fired1 = SFBool.DEFAULT_VALUE
            isValidSFBool(fired1)
            self.__fired1 = fired1
        @property # - - - - - - - - - - - - -
        def fired2(self):
            return self.__fired2
        @fired2.setter
        def fired2(self, fired2=None):
            if  fired2 is None:
                fired2 = SFBool.DEFAULT_VALUE
            isValidSFBool(fired2)
            self.__fired2 = fired2
        @property # - - - - - - - - - - - - -
        def fireMissionIndex(self):
            return self.__fireMissionIndex
        @fireMissionIndex.setter
        def fireMissionIndex(self, fireMissionIndex=None):
            if  fireMissionIndex is None:
                fireMissionIndex = SFInt32.DEFAULT_VALUE
            isValidSFInt32(fireMissionIndex)
            self.__fireMissionIndex = fireMissionIndex
        @property # - - - - - - - - - - - - -
        def firingRange(self):
            return self.__firingRange
        @firingRange.setter
        def firingRange(self, firingRange=None):
            if  firingRange is None:
                firingRange = SFFloat.DEFAULT_VALUE
            isValidSFFloat(firingRange)
            self.__firingRange = firingRange
        @property # - - - - - - - - - - - - -
        def firingRate(self):
            return self.__firingRate
        @firingRate.setter
        def firingRate(self, firingRate=None):
            if  firingRate is None:
                firingRate = SFInt32.DEFAULT_VALUE
            isValidSFInt32(firingRate)
            self.__firingRate = firingRate
        @property # - - - - - - - - - - - - -
        def forceID(self):
            return self.__forceID
        @forceID.setter
        def forceID(self, forceID=None):
            if  forceID is None:
                forceID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(forceID)
            self.__forceID = forceID
        @property # - - - - - - - - - - - - -
        def fuse(self):
            return self.__fuse
        @fuse.setter
        def fuse(self, fuse=None):
            if  fuse is None:
                fuse = SFInt32.DEFAULT_VALUE
            isValidSFInt32(fuse)
            self.__fuse = fuse
        @property # - - - - - - - - - - - - -
        def geoCoords(self):
            return self.__geoCoords
        @geoCoords.setter
        def geoCoords(self, geoCoords=None):
            if  geoCoords is None:
                geoCoords = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCoords)
            self.__geoCoords = geoCoords
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def linearAcceleration(self):
            return self.__linearAcceleration
        @linearAcceleration.setter
        def linearAcceleration(self, linearAcceleration=None):
            if  linearAcceleration is None:
                linearAcceleration = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(linearAcceleration)
            self.__linearAcceleration = linearAcceleration
        @property # - - - - - - - - - - - - -
        def linearVelocity(self):
            return self.__linearVelocity
        @linearVelocity.setter
        def linearVelocity(self, linearVelocity=None):
            if  linearVelocity is None:
                linearVelocity = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(linearVelocity)
            self.__linearVelocity = linearVelocity
        @property # - - - - - - - - - - - - -
        def marking(self):
            return self.__marking
        @marking.setter
        def marking(self, marking=None):
            if  marking is None:
                marking = SFString.DEFAULT_VALUE
            isValidSFString(marking)
            self.__marking = marking
        @property # - - - - - - - - - - - - -
        def multicastRelayHost(self):
            return self.__multicastRelayHost
        @multicastRelayHost.setter
        def multicastRelayHost(self, multicastRelayHost=None):
            if  multicastRelayHost is None:
                multicastRelayHost = SFString.DEFAULT_VALUE
            isValidSFString(multicastRelayHost)
            self.__multicastRelayHost = multicastRelayHost
        @property # - - - - - - - - - - - - -
        def multicastRelayPort(self):
            return self.__multicastRelayPort
        @multicastRelayPort.setter
        def multicastRelayPort(self, multicastRelayPort=None):
            if  multicastRelayPort is None:
                multicastRelayPort = SFInt32.DEFAULT_VALUE
            isValidSFInt32(multicastRelayPort)
            self.__multicastRelayPort = multicastRelayPort
        @property # - - - - - - - - - - - - -
        def munitionApplicationID(self):
            return self.__munitionApplicationID
        @munitionApplicationID.setter
        def munitionApplicationID(self, munitionApplicationID=None):
            if  munitionApplicationID is None:
                munitionApplicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(munitionApplicationID)
            self.__munitionApplicationID = munitionApplicationID
        @property # - - - - - - - - - - - - -
        def munitionEndPoint(self):
            return self.__munitionEndPoint
        @munitionEndPoint.setter
        def munitionEndPoint(self, munitionEndPoint=None):
            if  munitionEndPoint is None:
                munitionEndPoint = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(munitionEndPoint)
            self.__munitionEndPoint = munitionEndPoint
        @property # - - - - - - - - - - - - -
        def munitionEntityID(self):
            return self.__munitionEntityID
        @munitionEntityID.setter
        def munitionEntityID(self, munitionEntityID=None):
            if  munitionEntityID is None:
                munitionEntityID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(munitionEntityID)
            self.__munitionEntityID = munitionEntityID
        @property # - - - - - - - - - - - - -
        def munitionQuantity(self):
            return self.__munitionQuantity
        @munitionQuantity.setter
        def munitionQuantity(self, munitionQuantity=None):
            if  munitionQuantity is None:
                munitionQuantity = SFInt32.DEFAULT_VALUE
            isValidSFInt32(munitionQuantity)
            self.__munitionQuantity = munitionQuantity
        @property # - - - - - - - - - - - - -
        def munitionSiteID(self):
            return self.__munitionSiteID
        @munitionSiteID.setter
        def munitionSiteID(self, munitionSiteID=None):
            if  munitionSiteID is None:
                munitionSiteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(munitionSiteID)
            self.__munitionSiteID = munitionSiteID
        @property # - - - - - - - - - - - - -
        def munitionStartPoint(self):
            return self.__munitionStartPoint
        @munitionStartPoint.setter
        def munitionStartPoint(self, munitionStartPoint=None):
            if  munitionStartPoint is None:
                munitionStartPoint = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(munitionStartPoint)
            self.__munitionStartPoint = munitionStartPoint
        @property # - - - - - - - - - - - - -
        def networkMode(self):
            return self.__networkMode
        @networkMode.setter
        def networkMode(self, networkMode=None):
            if  networkMode is None:
                networkMode = SFString.DEFAULT_VALUE
            isValidSFString(networkMode)
            self.__networkMode = networkMode
        @property # - - - - - - - - - - - - -
        def port(self):
            return self.__port
        @port.setter
        def port(self, port=None):
            if  port is None:
                port = SFInt32.DEFAULT_VALUE
            isValidSFInt32(port)
            self.__port = port
        @property # - - - - - - - - - - - - -
        def readInterval(self):
            return self.__readInterval
        @readInterval.setter
        def readInterval(self, readInterval=None):
            if  readInterval is None:
                readInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(readInterval)
            self.__readInterval = readInterval
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def rtpHeaderExpected(self):
            return self.__rtpHeaderExpected
        @rtpHeaderExpected.setter
        def rtpHeaderExpected(self, rtpHeaderExpected=None):
            if  rtpHeaderExpected is None:
                rtpHeaderExpected = SFBool.DEFAULT_VALUE
            isValidSFBool(rtpHeaderExpected)
            self.__rtpHeaderExpected = rtpHeaderExpected
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def scaleOrientation(self):
            return self.__scaleOrientation
        @scaleOrientation.setter
        def scaleOrientation(self, scaleOrientation=None):
            if  scaleOrientation is None:
                scaleOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(scaleOrientation)
            self.__scaleOrientation = scaleOrientation
        @property # - - - - - - - - - - - - -
        def siteID(self):
            return self.__siteID
        @siteID.setter
        def siteID(self, siteID=None):
            if  siteID is None:
                siteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(siteID)
            self.__siteID = siteID
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def warhead(self):
            return self.__warhead
        @warhead.setter
        def warhead(self, warhead=None):
            if  warhead is None:
                warhead = SFInt32.DEFAULT_VALUE
            isValidSFInt32(warhead)
            self.__warhead = warhead
        @property # - - - - - - - - - - - - -
        def writeInterval(self):
            return self.__writeInterval
        @writeInterval.setter
        def writeInterval(self, writeInterval=None):
            if  writeInterval is None:
                writeInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(writeInterval)
            self.__writeInterval = writeInterval
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class ExplosionEmitter(_X3DParticleEmitterNode):
    """
    X3D element
    """
    __name__ = 'ExplosionEmitter'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#ExplosionEmitter'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ExplosionEmitter'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('mass', 0, 'SFFloat', 'inputOutput'),
                          ('position', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('speed', 0, 'SFFloat', 'inputOutput'),
                          ('surfaceArea', 0, 'SFFloat', 'initializeOnly'),
                          ('variation', 0.25, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 mass=0,
                 position=(0, 0, 0),
                 speed=0,
                 surfaceArea=0,
                 variation=0.25,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ExplosionEmitter __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.mass = mass
        self.position = position
        self.speed = speed
        self.surfaceArea = surfaceArea
        self.variation = variation
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def surfaceArea(self):
            return self.__surfaceArea
        @surfaceArea.setter
        def surfaceArea(self, surfaceArea=None):
            if  surfaceArea is None:
                surfaceArea = SFFloat.DEFAULT_VALUE
            isValidSFFloat(surfaceArea)
            self.__surfaceArea = surfaceArea
        @property # - - - - - - - - - - - - -
        def variation(self):
            return self.__variation
        @variation.setter
        def variation(self, variation=None):
            if  variation is None:
                variation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(variation)
            self.__variation = variation

class Extrusion(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Extrusion'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry3D.html#Extrusion'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Extrusion'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('beginCap', True, 'SFBool', 'initializeOnly'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('convex', True, 'SFBool', 'initializeOnly'),
                          ('creaseAngle', 0.0, 'SFFloat', 'initializeOnly'),
                          ('crossSection', [1, 1, 1, -1, -1, -1, -1, 1, 1, 1], 'MFVec2f', 'initializeOnly'),
                          ('endCap', True, 'SFBool', 'initializeOnly'),
                          ('orientation', [0, 0, 1, 0], 'MFRotation', 'inputOutput'),
                          ('scale', [1, 1], 'MFVec2f', 'inputOutput'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('spine', [0, 0, 0, 0, 1, 0], 'MFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 beginCap=True,
                 ccw=True,
                 convex=True,
                 creaseAngle=0.0,
                 crossSection=[1, 1, 1, -1, -1, -1, -1, 1, 1, 1],
                 endCap=True,
                 orientation=[0, 0, 1, 0],
                 scale=[1, 1],
                 solid=True,
                 spine=[0, 0, 0, 0, 1, 0],
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Extrusion __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.beginCap = beginCap
        self.ccw = ccw
        self.convex = convex
        self.creaseAngle = creaseAngle
        self.crossSection = crossSection
        self.endCap = endCap
        self.orientation = orientation
        self.scale = scale
        self.solid = solid
        self.spine = spine
        @property # - - - - - - - - - - - - -
        def beginCap(self):
            return self.__beginCap
        @beginCap.setter
        def beginCap(self, beginCap=None):
            if  beginCap is None:
                beginCap = SFBool.DEFAULT_VALUE
            isValidSFBool(beginCap)
            self.__beginCap = beginCap
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def convex(self):
            return self.__convex
        @convex.setter
        def convex(self, convex=None):
            if  convex is None:
                convex = SFBool.DEFAULT_VALUE
            isValidSFBool(convex)
            self.__convex = convex
        @property # - - - - - - - - - - - - -
        def creaseAngle(self):
            return self.__creaseAngle
        @creaseAngle.setter
        def creaseAngle(self, creaseAngle=None):
            if  creaseAngle is None:
                creaseAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(creaseAngle)
            self.__creaseAngle = creaseAngle
        @property # - - - - - - - - - - - - -
        def crossSection(self):
            return self.__crossSection
        @crossSection.setter
        def crossSection(self, crossSection=None):
            if  crossSection is None:
                crossSection = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(crossSection)
            self.__crossSection = crossSection
        @property # - - - - - - - - - - - - -
        def endCap(self):
            return self.__endCap
        @endCap.setter
        def endCap(self, endCap=None):
            if  endCap is None:
                endCap = SFBool.DEFAULT_VALUE
            isValidSFBool(endCap)
            self.__endCap = endCap
        @property # - - - - - - - - - - - - -
        def orientation(self):
            return self.__orientation
        @orientation.setter
        def orientation(self, orientation=None):
            if  orientation is None:
                orientation = MFRotation.DEFAULT_VALUE
            isValidMFRotation(orientation)
            self.__orientation = orientation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def spine(self):
            return self.__spine
        @spine.setter
        def spine(self, spine=None):
            if  spine is None:
                spine = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(spine)
            self.__spine = spine

class FillProperties(_X3DAppearanceChildNode):
    """
    X3D element
    """
    __name__ = 'FillProperties'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#FillProperties'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#FillProperties'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('filled', True, 'SFBool', 'inputOutput'),
                          ('hatchColor', (1, 1, 1), 'SFColor', 'inputOutput'),
                          ('hatched', True, 'SFBool', 'inputOutput'),
                          ('hatchStyle', 1, 'SFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 filled=True,
                 hatchColor=(1, 1, 1),
                 hatched=True,
                 hatchStyle=1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode FillProperties __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.filled = filled
        self.hatchColor = hatchColor
        self.hatched = hatched
        self.hatchStyle = hatchStyle
        @property # - - - - - - - - - - - - -
        def filled(self):
            return self.__filled
        @filled.setter
        def filled(self, filled=None):
            if  filled is None:
                filled = SFBool.DEFAULT_VALUE
            isValidSFBool(filled)
            self.__filled = filled
        @property # - - - - - - - - - - - - -
        def hatchColor(self):
            return self.__hatchColor
        @hatchColor.setter
        def hatchColor(self, hatchColor=None):
            if  hatchColor is None:
                hatchColor = SFColor.DEFAULT_VALUE
            isValidSFColor(hatchColor)
            self.__hatchColor = hatchColor
        @property # - - - - - - - - - - - - -
        def hatched(self):
            return self.__hatched
        @hatched.setter
        def hatched(self, hatched=None):
            if  hatched is None:
                hatched = SFBool.DEFAULT_VALUE
            isValidSFBool(hatched)
            self.__hatched = hatched
        @property # - - - - - - - - - - - - -
        def hatchStyle(self):
            return self.__hatchStyle
        @hatchStyle.setter
        def hatchStyle(self, hatchStyle=None):
            if  hatchStyle is None:
                hatchStyle = SFInt32.DEFAULT_VALUE
            isValidSFInt32(hatchStyle)
            self.__hatchStyle = hatchStyle

class FloatVertexAttribute(_X3DVertexAttributeNode):
    """
    X3D element
    """
    __name__ = 'FloatVertexAttribute'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#FloatVertexAttribute'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#FloatVertexAttribute'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('numComponents', 4, 'SFInt32', 'initializeOnly'),
                          ('value', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 numComponents=4,
                 value=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode FloatVertexAttribute __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.numComponents = numComponents
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def numComponents(self):
            return self.__numComponents
        @numComponents.setter
        def numComponents(self, numComponents=None):
            if  numComponents is None:
                numComponents = SFInt32.DEFAULT_VALUE
            isValidSFInt32(numComponents)
            self.__numComponents = numComponents
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFFloat.DEFAULT_VALUE
            isValidMFFloat(value)
            self.__value = value

class Fog(_X3DBindableNode):
    """
    X3D element
    """
    __name__ = 'Fog'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/enveffects.html#Fog'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Fog'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('color', (1, 1, 1), 'SFColor', 'inputOutput'),
                          ('fogType', 'LINEAR', 'SFString', 'inputOutput'),
                          ('visibilityRange', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 color=(1, 1, 1),
                 fogType='LINEAR',
                 visibilityRange=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Fog __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.color = color
        self.fogType = fogType
        self.visibilityRange = visibilityRange
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFColor.DEFAULT_VALUE
            isValidSFColor(color)
            self.__color = color
        @property # - - - - - - - - - - - - -
        def fogType(self):
            return self.__fogType
        @fogType.setter
        def fogType(self, fogType=None):
            if  fogType is None:
                fogType = SFString.DEFAULT_VALUE
            isValidSFString(fogType)
            self.__fogType = fogType
        @property # - - - - - - - - - - - - -
        def visibilityRange(self):
            return self.__visibilityRange
        @visibilityRange.setter
        def visibilityRange(self, visibilityRange=None):
            if  visibilityRange is None:
                visibilityRange = SFFloat.DEFAULT_VALUE
            isValidSFFloat(visibilityRange)
            self.__visibilityRange = visibilityRange

class FogCoordinate(_X3DGeometricPropertyNode):
    """
    X3D element
    """
    __name__ = 'FogCoordinate'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/enveffects.html#FogCoordinate'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#FogCoordinate'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('depth', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 depth=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode FogCoordinate __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.depth = depth
        @property # - - - - - - - - - - - - -
        def depth(self):
            return self.__depth
        @depth.setter
        def depth(self, depth=None):
            if  depth is None:
                depth = MFFloat.DEFAULT_VALUE
            isValidMFFloat(depth)
            self.__depth = depth

class FontStyle(_X3DFontStyleNode):
    """
    X3D element
    """
    __name__ = 'FontStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/text.html#FontStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#FontStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('family', ["SERIF"], 'MFString', 'initializeOnly'),
                          ('horizontal', True, 'SFBool', 'initializeOnly'),
                          ('justify', ["BEGIN"], 'MFString', 'initializeOnly'),
                          ('language', '', 'SFString', 'initializeOnly'),
                          ('leftToRight', True, 'SFBool', 'initializeOnly'),
                          ('size', 1.0, 'SFFloat', 'initializeOnly'),
                          ('spacing', 1.0, 'SFFloat', 'initializeOnly'),
                          ('style', 'PLAIN', 'SFString', 'initializeOnly'),
                          ('topToBottom', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 family=["SERIF"],
                 horizontal=True,
                 justify=["BEGIN"],
                 language='',
                 leftToRight=True,
                 size=1.0,
                 spacing=1.0,
                 style='PLAIN',
                 topToBottom=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode FontStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.family = family
        self.horizontal = horizontal
        self.justify = justify
        self.language = language
        self.leftToRight = leftToRight
        self.size = size
        self.spacing = spacing
        self.style = style
        self.topToBottom = topToBottom
        @property # - - - - - - - - - - - - -
        def family(self):
            return self.__family
        @family.setter
        def family(self, family=None):
            if  family is None:
                family = MFString.DEFAULT_VALUE
            isValidMFString(family)
            self.__family = family
        @property # - - - - - - - - - - - - -
        def horizontal(self):
            return self.__horizontal
        @horizontal.setter
        def horizontal(self, horizontal=None):
            if  horizontal is None:
                horizontal = SFBool.DEFAULT_VALUE
            isValidSFBool(horizontal)
            self.__horizontal = horizontal
        @property # - - - - - - - - - - - - -
        def justify(self):
            return self.__justify
        @justify.setter
        def justify(self, justify=None):
            if  justify is None:
                justify = MFString.DEFAULT_VALUE
            isValidMFString(justify)
            self.__justify = justify
        @property # - - - - - - - - - - - - -
        def language(self):
            return self.__language
        @language.setter
        def language(self, language=None):
            if  language is None:
                language = SFString.DEFAULT_VALUE
            isValidSFString(language)
            self.__language = language
        @property # - - - - - - - - - - - - -
        def leftToRight(self):
            return self.__leftToRight
        @leftToRight.setter
        def leftToRight(self, leftToRight=None):
            if  leftToRight is None:
                leftToRight = SFBool.DEFAULT_VALUE
            isValidSFBool(leftToRight)
            self.__leftToRight = leftToRight
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFFloat.DEFAULT_VALUE
            isValidSFFloat(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def spacing(self):
            return self.__spacing
        @spacing.setter
        def spacing(self, spacing=None):
            if  spacing is None:
                spacing = SFFloat.DEFAULT_VALUE
            isValidSFFloat(spacing)
            self.__spacing = spacing
        @property # - - - - - - - - - - - - -
        def style(self):
            return self.__style
        @style.setter
        def style(self, style=None):
            if  style is None:
                style = SFString.DEFAULT_VALUE
            isValidSFString(style)
            self.__style = style
        @property # - - - - - - - - - - - - -
        def topToBottom(self):
            return self.__topToBottom
        @topToBottom.setter
        def topToBottom(self, topToBottom=None):
            if  topToBottom is None:
                topToBottom = SFBool.DEFAULT_VALUE
            isValidSFBool(topToBottom)
            self.__topToBottom = topToBottom

class ForcePhysicsModel(_X3DParticlePhysicsModelNode):
    """
    X3D element
    """
    __name__ = 'ForcePhysicsModel'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#ForcePhysicsModel'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ForcePhysicsModel'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('force', (0, -9.8, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 force=(0, -9.8, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ForcePhysicsModel __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.force = force
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def force(self):
            return self.__force
        @force.setter
        def force(self, force=None):
            if  force is None:
                force = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(force)
            self.__force = force

class GeneratedCubeMapTexture(_X3DEnvironmentTextureNode):
    """
    X3D element
    """
    __name__ = 'GeneratedCubeMapTexture'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/env_texture.html#GeneratedCubeMapTexture'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeneratedCubeMapTexture'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('size', 128, 'SFInt32', 'initializeOnly'),
                          ('update', 'NONE', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 size=128,
                 update='NONE',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None):
        # if _DEBUG: print ('... in ConcreteNode GeneratedCubeMapTexture __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.size = size
        self.update = update
        self.textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFInt32.DEFAULT_VALUE
            isValidSFInt32(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def update(self):
            return self.__update
        @update.setter
        def update(self, update=None):
            if  update is None:
                update = SFString.DEFAULT_VALUE
            isValidSFString(update)
            self.__update = update
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties

class GeoCoordinate(_X3DCoordinateNode):
    """
    X3D element
    """
    __name__ = 'GeoCoordinate'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoCoordinate'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoCoordinate'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('point', (list()), 'MFVec3d', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 geoSystem=["GD", "WE"],
                 point=(list()),
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode GeoCoordinate __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.geoSystem = geoSystem
        self.point = point
        self.geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def point(self):
            return self.__point
        @point.setter
        def point(self, point=None):
            if  point is None:
                point = MFVec3d.DEFAULT_VALUE
            isValidMFVec3d(point)
            self.__point = point
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin

class GeoElevationGrid(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'GeoElevationGrid'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoElevationGrid'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoElevationGrid'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('creaseAngle', 0, 'SFDouble', 'initializeOnly'),
                          ('geoGridOrigin', (0, 0, 0), 'SFVec3d', 'initializeOnly'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('height', [0, 0, 0, 0], 'MFDouble', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('xDimension', 2, 'SFInt32', 'initializeOnly'),
                          ('xSpacing', 1.0, 'SFDouble', 'initializeOnly'),
                          ('yScale', 1, 'SFFloat', 'inputOutput'),
                          ('zDimension', 2, 'SFInt32', 'initializeOnly'),
                          ('zSpacing', 1.0, 'SFDouble', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 creaseAngle=0,
                 geoGridOrigin=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 height=[0, 0, 0, 0],
                 normalPerVertex=True,
                 solid=True,
                 xDimension=2,
                 xSpacing=1.0,
                 yScale=1,
                 zDimension=2,
                 zSpacing=1.0,
                 USE='',
                 class_='',
                 color=None,
                 geoOrigin=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None):
        # if _DEBUG: print ('... in ConcreteNode GeoElevationGrid __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.creaseAngle = creaseAngle
        self.geoGridOrigin = geoGridOrigin
        self.geoSystem = geoSystem
        self.height = height
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.xDimension = xDimension
        self.xSpacing = xSpacing
        self.yScale = yScale
        self.zDimension = zDimension
        self.zSpacing = zSpacing
        self.color = color
        self.geoOrigin = geoOrigin
        self.normal = normal
        self.texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def creaseAngle(self):
            return self.__creaseAngle
        @creaseAngle.setter
        def creaseAngle(self, creaseAngle=None):
            if  creaseAngle is None:
                creaseAngle = SFDouble.DEFAULT_VALUE
            isValidSFDouble(creaseAngle)
            self.__creaseAngle = creaseAngle
        @property # - - - - - - - - - - - - -
        def geoGridOrigin(self):
            return self.__geoGridOrigin
        @geoGridOrigin.setter
        def geoGridOrigin(self, geoGridOrigin=None):
            if  geoGridOrigin is None:
                geoGridOrigin = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoGridOrigin)
            self.__geoGridOrigin = geoGridOrigin
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def height(self):
            return self.__height
        @height.setter
        def height(self, height=None):
            if  height is None:
                height = MFDouble.DEFAULT_VALUE
            isValidMFDouble(height)
            self.__height = height
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def xDimension(self):
            return self.__xDimension
        @xDimension.setter
        def xDimension(self, xDimension=None):
            if  xDimension is None:
                xDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(xDimension)
            self.__xDimension = xDimension
        @property # - - - - - - - - - - - - -
        def xSpacing(self):
            return self.__xSpacing
        @xSpacing.setter
        def xSpacing(self, xSpacing=None):
            if  xSpacing is None:
                xSpacing = SFDouble.DEFAULT_VALUE
            isValidSFDouble(xSpacing)
            self.__xSpacing = xSpacing
        @property # - - - - - - - - - - - - -
        def yScale(self):
            return self.__yScale
        @yScale.setter
        def yScale(self, yScale=None):
            if  yScale is None:
                yScale = SFFloat.DEFAULT_VALUE
            isValidSFFloat(yScale)
            self.__yScale = yScale
        @property # - - - - - - - - - - - - -
        def zDimension(self):
            return self.__zDimension
        @zDimension.setter
        def zDimension(self, zDimension=None):
            if  zDimension is None:
                zDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(zDimension)
            self.__zDimension = zDimension
        @property # - - - - - - - - - - - - -
        def zSpacing(self):
            return self.__zSpacing
        @zSpacing.setter
        def zSpacing(self, zSpacing=None):
            if  zSpacing is None:
                zSpacing = SFDouble.DEFAULT_VALUE
            isValidSFDouble(zSpacing)
            self.__zSpacing = zSpacing
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord

class GeoLocation(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'GeoLocation'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoLocation'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoLocation'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('geoCoords', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 geoCoords=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode GeoLocation __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.geoCoords = geoCoords
        self.geoSystem = geoSystem
        self.geoOrigin = geoOrigin
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def geoCoords(self):
            return self.__geoCoords
        @geoCoords.setter
        def geoCoords(self, geoCoords=None):
            if  geoCoords is None:
                geoCoords = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCoords)
            self.__geoCoords = geoCoords
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class GeoLOD(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'GeoLOD'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoLOD'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoLOD'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3d', 'initializeOnly'),
                          ('child1Url', list(), 'MFString', 'initializeOnly'),
                          ('child2Url', list(), 'MFString', 'initializeOnly'),
                          ('child3Url', list(), 'MFString', 'initializeOnly'),
                          ('child4Url', list(), 'MFString', 'initializeOnly'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('range', 10, 'SFFloat', 'initializeOnly'),
                          ('rootUrl', list(), 'MFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('rootNode', list(), 'MFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 child1Url=list(),
                 child2Url=list(),
                 child3Url=list(),
                 child4Url=list(),
                 geoSystem=["GD", "WE"],
                 range=10,
                 rootUrl=list(),
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None,
                 rootNode=list()):
        # if _DEBUG: print ('... in ConcreteNode GeoLOD __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.child1Url = child1Url
        self.child2Url = child2Url
        self.child3Url = child3Url
        self.child4Url = child4Url
        self.geoSystem = geoSystem
        self.range = range
        self.rootUrl = rootUrl
        self.geoOrigin = geoOrigin
        self.rootNode = rootNode
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def child1Url(self):
            return self.__child1Url
        @child1Url.setter
        def child1Url(self, child1Url=None):
            if  child1Url is None:
                child1Url = MFString.DEFAULT_VALUE
            isValidMFString(child1Url)
            self.__child1Url = child1Url
        @property # - - - - - - - - - - - - -
        def child2Url(self):
            return self.__child2Url
        @child2Url.setter
        def child2Url(self, child2Url=None):
            if  child2Url is None:
                child2Url = MFString.DEFAULT_VALUE
            isValidMFString(child2Url)
            self.__child2Url = child2Url
        @property # - - - - - - - - - - - - -
        def child3Url(self):
            return self.__child3Url
        @child3Url.setter
        def child3Url(self, child3Url=None):
            if  child3Url is None:
                child3Url = MFString.DEFAULT_VALUE
            isValidMFString(child3Url)
            self.__child3Url = child3Url
        @property # - - - - - - - - - - - - -
        def child4Url(self):
            return self.__child4Url
        @child4Url.setter
        def child4Url(self, child4Url=None):
            if  child4Url is None:
                child4Url = MFString.DEFAULT_VALUE
            isValidMFString(child4Url)
            self.__child4Url = child4Url
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def range(self):
            return self.__range
        @range.setter
        def range(self, range=None):
            if  range is None:
                range = SFFloat.DEFAULT_VALUE
            isValidSFFloat(range)
            self.__range = range
        @property # - - - - - - - - - - - - -
        def rootUrl(self):
            return self.__rootUrl
        @rootUrl.setter
        def rootUrl(self, rootUrl=None):
            if  rootUrl is None:
                rootUrl = MFString.DEFAULT_VALUE
            isValidMFString(rootUrl)
            self.__rootUrl = rootUrl
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def rootNode(self):
            return self.__rootNode
        @rootNode.setter
        def rootNode(self, rootNode=None):
            if  rootNode is None:
                rootNode = MFNode.DEFAULT_VALUE
            isValidMFNode(rootNode)
            self.__rootNode = rootNode

class GeoMetadata(_X3DInfoNode):
    """
    X3D element
    """
    __name__ = 'GeoMetadata'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoMetadata'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoMetadata'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('summary', list(), 'MFString', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('data', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 summary=list(),
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 data=list()):
        # if _DEBUG: print ('... in ConcreteNode GeoMetadata __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.summary = summary
        self.url = url
        self.data = data
        @property # - - - - - - - - - - - - -
        def summary(self):
            return self.__summary
        @summary.setter
        def summary(self, summary=None):
            if  summary is None:
                summary = MFString.DEFAULT_VALUE
            isValidMFString(summary)
            self.__summary = summary
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def data(self):
            return self.__data
        @data.setter
        def data(self, data=None):
            if  data is None:
                data = MFNode.DEFAULT_VALUE
            isValidMFNode(data)
            self.__data = data

class GeoOrigin(_X3DNode):
    """
    GeoOrigin is deprecated and discouraged (but nevertheless allowed) in X3D v3.3. GeoOrigin is likely to be restored in X3D v4.0 for special use on devices with limited floating-point resolution.
    """
    __name__ = 'GeoOrigin'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoOrigin'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoOrigin'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('geoCoords', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('rotateYUp', False, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 geoCoords=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 rotateYUp=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode GeoOrigin __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.geoCoords = geoCoords
        self.geoSystem = geoSystem
        self.rotateYUp = rotateYUp
        @property # - - - - - - - - - - - - -
        def geoCoords(self):
            return self.__geoCoords
        @geoCoords.setter
        def geoCoords(self, geoCoords=None):
            if  geoCoords is None:
                geoCoords = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCoords)
            self.__geoCoords = geoCoords
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def rotateYUp(self):
            return self.__rotateYUp
        @rotateYUp.setter
        def rotateYUp(self, rotateYUp=None):
            if  rotateYUp is None:
                rotateYUp = SFBool.DEFAULT_VALUE
            isValidSFBool(rotateYUp)
            self.__rotateYUp = rotateYUp

class GeoPositionInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'GeoPositionInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoPositionInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoPositionInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec3d', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 geoSystem=["GD", "WE"],
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode GeoPositionInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.geoSystem = geoSystem
        self.key = key
        self.keyValue = keyValue
        self.geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec3d.DEFAULT_VALUE
            isValidMFVec3d(keyValue)
            self.__keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin

class GeoProximitySensor(_X3DEnvironmentalSensorNode):
    """
    X3D element
    """
    __name__ = 'GeoProximitySensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoProximitySensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoProximitySensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('center', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('geoCenter', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('size', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 center=(0, 0, 0),
                 enabled=True,
                 geoCenter=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 size=(0, 0, 0),
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode GeoProximitySensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.center = center
        self.enabled = enabled
        self.geoCenter = geoCenter
        self.geoSystem = geoSystem
        self.size = size
        self.geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def geoCenter(self):
            return self.__geoCenter
        @geoCenter.setter
        def geoCenter(self, geoCenter=None):
            if  geoCenter is None:
                geoCenter = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCenter)
            self.__geoCenter = geoCenter
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin

class GeoTouchSensor(_X3DTouchSensorNode):
    """
    X3D element
    """
    __name__ = 'GeoTouchSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoTouchSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoTouchSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 description='',
                 enabled=True,
                 geoSystem=["GD", "WE"],
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode GeoTouchSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.description = description
        self.enabled = enabled
        self.geoSystem = geoSystem
        self.geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin

class GeoTransform(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'GeoTransform'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoTransform'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoTransform'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('geoCenter', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('scaleOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 geoCenter=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 rotation=(0, 0, 1, 0),
                 scale=(1, 1, 1),
                 scaleOrientation=(0, 0, 1, 0),
                 translation=(0, 0, 0),
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode GeoTransform __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.geoCenter = geoCenter
        self.geoSystem = geoSystem
        self.rotation = rotation
        self.scale = scale
        self.scaleOrientation = scaleOrientation
        self.translation = translation
        self.geoOrigin = geoOrigin
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def geoCenter(self):
            return self.__geoCenter
        @geoCenter.setter
        def geoCenter(self, geoCenter=None):
            if  geoCenter is None:
                geoCenter = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCenter)
            self.__geoCenter = geoCenter
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def scaleOrientation(self):
            return self.__scaleOrientation
        @scaleOrientation.setter
        def scaleOrientation(self, scaleOrientation=None):
            if  scaleOrientation is None:
                scaleOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(scaleOrientation)
            self.__scaleOrientation = scaleOrientation
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class GeoViewpoint(_X3DViewpointNode):
    """
    X3D element
    """
    __name__ = 'GeoViewpoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geodata.html#GeoViewpoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#GeoViewpoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('centerOfRotation', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('fieldOfView', 0.7854, 'SFFloat', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('jump', True, 'SFBool', 'inputOutput'),
                          ('orientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('position', (0, 0, 100000), 'SFVec3d', 'inputOutput'),
                          ('retainUserOffsets', False, 'SFBool', 'inputOutput'),
                          ('speedFactor', 1.0, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('geoOrigin', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 centerOfRotation=(0, 0, 0),
                 description='',
                 fieldOfView=0.7854,
                 geoSystem=["GD", "WE"],
                 jump=True,
                 orientation=(0, 0, 1, 0),
                 position=(0, 0, 100000),
                 retainUserOffsets=False,
                 speedFactor=1.0,
                 USE='',
                 class_='',
                 geoOrigin=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode GeoViewpoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.centerOfRotation = centerOfRotation
        self.description = description
        self.fieldOfView = fieldOfView
        self.geoSystem = geoSystem
        self.jump = jump
        self.orientation = orientation
        self.position = position
        self.retainUserOffsets = retainUserOffsets
        self.speedFactor = speedFactor
        self.geoOrigin = geoOrigin
        @property # - - - - - - - - - - - - -
        def centerOfRotation(self):
            return self.__centerOfRotation
        @centerOfRotation.setter
        def centerOfRotation(self, centerOfRotation=None):
            if  centerOfRotation is None:
                centerOfRotation = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(centerOfRotation)
            self.__centerOfRotation = centerOfRotation
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def fieldOfView(self):
            return self.__fieldOfView
        @fieldOfView.setter
        def fieldOfView(self, fieldOfView=None):
            if  fieldOfView is None:
                fieldOfView = SFFloat.DEFAULT_VALUE
            isValidSFFloat(fieldOfView)
            self.__fieldOfView = fieldOfView
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def jump(self):
            return self.__jump
        @jump.setter
        def jump(self, jump=None):
            if  jump is None:
                jump = SFBool.DEFAULT_VALUE
            isValidSFBool(jump)
            self.__jump = jump
        @property # - - - - - - - - - - - - -
        def orientation(self):
            return self.__orientation
        @orientation.setter
        def orientation(self, orientation=None):
            if  orientation is None:
                orientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(orientation)
            self.__orientation = orientation
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def retainUserOffsets(self):
            return self.__retainUserOffsets
        @retainUserOffsets.setter
        def retainUserOffsets(self, retainUserOffsets=None):
            if  retainUserOffsets is None:
                retainUserOffsets = SFBool.DEFAULT_VALUE
            isValidSFBool(retainUserOffsets)
            self.__retainUserOffsets = retainUserOffsets
        @property # - - - - - - - - - - - - -
        def speedFactor(self):
            return self.__speedFactor
        @speedFactor.setter
        def speedFactor(self, speedFactor=None):
            if  speedFactor is None:
                speedFactor = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speedFactor)
            self.__speedFactor = speedFactor
        @property # - - - - - - - - - - - - -
        def geoOrigin(self):
            return self.__geoOrigin
        @geoOrigin.setter
        def geoOrigin(self, geoOrigin=None):
            if  geoOrigin is None:
                geoOrigin = SFNode.DEFAULT_VALUE
            isValidSFNode(geoOrigin)
            if not isinstance(geoOrigin, object):
                raise RuntimeError(str(geoOrigin) + ' does not have a valid node type object')
            self.__geoOrigin = geoOrigin

class Group(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'Group'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/group.html#Group'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Group'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Group __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class HAnimDisplacer(_X3DGeometricPropertyNode):
    """
    X3D element
    """
    __name__ = 'HAnimDisplacer'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/hanim.html#HAnimDisplacer'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#HAnimDisplacer'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('coordIndex', list(), 'MFInt32', 'initializeOnly'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('displacements', (list()), 'MFVec3f', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('weight', 0.0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 coordIndex=list(),
                 description='',
                 displacements=(list()),
                 name='',
                 weight=0.0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode HAnimDisplacer __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.coordIndex = coordIndex
        self.description = description
        self.displacements = displacements
        self.name = name
        self.weight = weight
        @property # - - - - - - - - - - - - -
        def coordIndex(self):
            return self.__coordIndex
        @coordIndex.setter
        def coordIndex(self, coordIndex=None):
            if  coordIndex is None:
                coordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(coordIndex)
            self.__coordIndex = coordIndex
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def displacements(self):
            return self.__displacements
        @displacements.setter
        def displacements(self, displacements=None):
            if  displacements is None:
                displacements = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(displacements)
            self.__displacements = displacements
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = SFFloat.DEFAULT_VALUE
            isValidSFFloat(weight)
            self.__weight = weight

class HAnimHumanoid(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'HAnimHumanoid'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/hanim.html#HAnimHumanoid'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#HAnimHumanoid'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('info', list(), 'MFString', 'inputOutput'),
                          ('jointBindingPositions', [0, 0, 0], 'MFVec3f', 'inputOutput'),
                          ('jointBindingRotations', [0, 0, 1, 0], 'MFRotation', 'inputOutput'),
                          ('jointBindingScales', [0, 0, 0], 'MFVec3f', 'inputOutput'),
                          ('loa', -1, 'SFInt32', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('scaleOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('skeletalConfiguration', 'BASIC', 'SFString', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('version', '2.0', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('skinCoord', None, 'SFNode', 'inputOutput'),
                          ('skinNormal', None, 'SFNode', 'inputOutput'),
                          ('joints', list(), 'MFNode', 'inputOutput'),
                          ('motions', list(), 'MFNode', 'inputOutput'),
                          ('segments', list(), 'MFNode', 'inputOutput'),
                          ('sites', list(), 'MFNode', 'inputOutput'),
                          ('skeleton', list(), 'MFNode', 'inputOutput'),
                          ('skin', list(), 'MFNode', 'inputOutput'),
                          ('skinBindingCoords', list(), 'MFNode', 'inputOutput'),
                          ('skinBindingNormals', list(), 'MFNode', 'inputOutput'),
                          ('viewpoints', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 description='',
                 info=list(),
                 jointBindingPositions=[0, 0, 0],
                 jointBindingRotations=[0, 0, 1, 0],
                 jointBindingScales=[0, 0, 0],
                 loa=-1,
                 name='',
                 rotation=(0, 0, 1, 0),
                 scale=(1, 1, 1),
                 scaleOrientation=(0, 0, 1, 0),
                 skeletalConfiguration='BASIC',
                 translation=(0, 0, 0),
                 version='2.0',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 skinCoord=None,
                 skinNormal=None,
                 joints=list(),
                 motions=list(),
                 segments=list(),
                 sites=list(),
                 skeleton=list(),
                 skin=list(),
                 skinBindingCoords=list(),
                 skinBindingNormals=list(),
                 viewpoints=list()):
        # if _DEBUG: print ('... in ConcreteNode HAnimHumanoid __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.description = description
        self.info = info
        self.jointBindingPositions = jointBindingPositions
        self.jointBindingRotations = jointBindingRotations
        self.jointBindingScales = jointBindingScales
        self.loa = loa
        self.name = name
        self.rotation = rotation
        self.scale = scale
        self.scaleOrientation = scaleOrientation
        self.skeletalConfiguration = skeletalConfiguration
        self.translation = translation
        self.version = version
        self.skinCoord = skinCoord
        self.skinNormal = skinNormal
        self.joints = joints
        self.motions = motions
        self.segments = segments
        self.sites = sites
        self.skeleton = skeleton
        self.skin = skin
        self.skinBindingCoords = skinBindingCoords
        self.skinBindingNormals = skinBindingNormals
        self.viewpoints = viewpoints
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def info(self):
            return self.__info
        @info.setter
        def info(self, info=None):
            if  info is None:
                info = MFString.DEFAULT_VALUE
            isValidMFString(info)
            self.__info = info
        @property # - - - - - - - - - - - - -
        def jointBindingPositions(self):
            return self.__jointBindingPositions
        @jointBindingPositions.setter
        def jointBindingPositions(self, jointBindingPositions=None):
            if  jointBindingPositions is None:
                jointBindingPositions = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(jointBindingPositions)
            self.__jointBindingPositions = jointBindingPositions
        @property # - - - - - - - - - - - - -
        def jointBindingRotations(self):
            return self.__jointBindingRotations
        @jointBindingRotations.setter
        def jointBindingRotations(self, jointBindingRotations=None):
            if  jointBindingRotations is None:
                jointBindingRotations = MFRotation.DEFAULT_VALUE
            isValidMFRotation(jointBindingRotations)
            self.__jointBindingRotations = jointBindingRotations
        @property # - - - - - - - - - - - - -
        def jointBindingScales(self):
            return self.__jointBindingScales
        @jointBindingScales.setter
        def jointBindingScales(self, jointBindingScales=None):
            if  jointBindingScales is None:
                jointBindingScales = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(jointBindingScales)
            self.__jointBindingScales = jointBindingScales
        @property # - - - - - - - - - - - - -
        def loa(self):
            return self.__loa
        @loa.setter
        def loa(self, loa=None):
            if  loa is None:
                loa = SFInt32.DEFAULT_VALUE
            isValidSFInt32(loa)
            self.__loa = loa
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def scaleOrientation(self):
            return self.__scaleOrientation
        @scaleOrientation.setter
        def scaleOrientation(self, scaleOrientation=None):
            if  scaleOrientation is None:
                scaleOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(scaleOrientation)
            self.__scaleOrientation = scaleOrientation
        @property # - - - - - - - - - - - - -
        def skeletalConfiguration(self):
            return self.__skeletalConfiguration
        @skeletalConfiguration.setter
        def skeletalConfiguration(self, skeletalConfiguration=None):
            if  skeletalConfiguration is None:
                skeletalConfiguration = SFString.DEFAULT_VALUE
            isValidSFString(skeletalConfiguration)
            self.__skeletalConfiguration = skeletalConfiguration
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def version(self):
            return self.__version
        @version.setter
        def version(self, version=None):
            if  version is None:
                version = SFString.DEFAULT_VALUE
            isValidSFString(version)
            self.__version = version
        @property # - - - - - - - - - - - - -
        def skinCoord(self):
            return self.__skinCoord
        @skinCoord.setter
        def skinCoord(self, skinCoord=None):
            if  skinCoord is None:
                skinCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(skinCoord)
            if not isinstance(skinCoord, object):
                raise RuntimeError(str(skinCoord) + ' does not have a valid node type object')
            self.__skinCoord = skinCoord
        @property # - - - - - - - - - - - - -
        def skinNormal(self):
            return self.__skinNormal
        @skinNormal.setter
        def skinNormal(self, skinNormal=None):
            if  skinNormal is None:
                skinNormal = SFNode.DEFAULT_VALUE
            isValidSFNode(skinNormal)
            if not isinstance(skinNormal, object):
                raise RuntimeError(str(skinNormal) + ' does not have a valid node type object')
            self.__skinNormal = skinNormal
        @property # - - - - - - - - - - - - -
        def joints(self):
            return self.__joints
        @joints.setter
        def joints(self, joints=None):
            if  joints is None:
                joints = MFNode.DEFAULT_VALUE
            isValidMFNode(joints)
            self.__joints = joints
        @property # - - - - - - - - - - - - -
        def motions(self):
            return self.__motions
        @motions.setter
        def motions(self, motions=None):
            if  motions is None:
                motions = MFNode.DEFAULT_VALUE
            isValidMFNode(motions)
            self.__motions = motions
        @property # - - - - - - - - - - - - -
        def segments(self):
            return self.__segments
        @segments.setter
        def segments(self, segments=None):
            if  segments is None:
                segments = MFNode.DEFAULT_VALUE
            isValidMFNode(segments)
            self.__segments = segments
        @property # - - - - - - - - - - - - -
        def sites(self):
            return self.__sites
        @sites.setter
        def sites(self, sites=None):
            if  sites is None:
                sites = MFNode.DEFAULT_VALUE
            isValidMFNode(sites)
            self.__sites = sites
        @property # - - - - - - - - - - - - -
        def skeleton(self):
            return self.__skeleton
        @skeleton.setter
        def skeleton(self, skeleton=None):
            if  skeleton is None:
                skeleton = MFNode.DEFAULT_VALUE
            isValidMFNode(skeleton)
            self.__skeleton = skeleton
        @property # - - - - - - - - - - - - -
        def skin(self):
            return self.__skin
        @skin.setter
        def skin(self, skin=None):
            if  skin is None:
                skin = MFNode.DEFAULT_VALUE
            isValidMFNode(skin)
            self.__skin = skin
        @property # - - - - - - - - - - - - -
        def skinBindingCoords(self):
            return self.__skinBindingCoords
        @skinBindingCoords.setter
        def skinBindingCoords(self, skinBindingCoords=None):
            if  skinBindingCoords is None:
                skinBindingCoords = MFNode.DEFAULT_VALUE
            isValidMFNode(skinBindingCoords)
            self.__skinBindingCoords = skinBindingCoords
        @property # - - - - - - - - - - - - -
        def skinBindingNormals(self):
            return self.__skinBindingNormals
        @skinBindingNormals.setter
        def skinBindingNormals(self, skinBindingNormals=None):
            if  skinBindingNormals is None:
                skinBindingNormals = MFNode.DEFAULT_VALUE
            isValidMFNode(skinBindingNormals)
            self.__skinBindingNormals = skinBindingNormals
        @property # - - - - - - - - - - - - -
        def viewpoints(self):
            return self.__viewpoints
        @viewpoints.setter
        def viewpoints(self, viewpoints=None):
            if  viewpoints is None:
                viewpoints = MFNode.DEFAULT_VALUE
            isValidMFNode(viewpoints)
            self.__viewpoints = viewpoints

class HAnimJoint(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'HAnimJoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/hanim.html#HAnimJoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#HAnimJoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('limitOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('llimit', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('scaleOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('skinCoordIndex', list(), 'MFInt32', 'inputOutput'),
                          ('skinCoordWeight', list(), 'MFFloat', 'inputOutput'),
                          ('stiffness', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('ulimit', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput'),
                          ('displacers', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 description='',
                 limitOrientation=(0, 0, 1, 0),
                 llimit=(0, 0, 0),
                 name='',
                 rotation=(0, 0, 1, 0),
                 scale=(1, 1, 1),
                 scaleOrientation=(0, 0, 1, 0),
                 skinCoordIndex=list(),
                 skinCoordWeight=list(),
                 stiffness=(1, 1, 1),
                 translation=(0, 0, 0),
                 ulimit=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list(),
                 displacers=list()):
        # if _DEBUG: print ('... in ConcreteNode HAnimJoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.description = description
        self.limitOrientation = limitOrientation
        self.llimit = llimit
        self.name = name
        self.rotation = rotation
        self.scale = scale
        self.scaleOrientation = scaleOrientation
        self.skinCoordIndex = skinCoordIndex
        self.skinCoordWeight = skinCoordWeight
        self.stiffness = stiffness
        self.translation = translation
        self.ulimit = ulimit
        self.children = children
        self.displacers = displacers
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def limitOrientation(self):
            return self.__limitOrientation
        @limitOrientation.setter
        def limitOrientation(self, limitOrientation=None):
            if  limitOrientation is None:
                limitOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(limitOrientation)
            self.__limitOrientation = limitOrientation
        @property # - - - - - - - - - - - - -
        def llimit(self):
            return self.__llimit
        @llimit.setter
        def llimit(self, llimit=None):
            if  llimit is None:
                llimit = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(llimit)
            self.__llimit = llimit
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def scaleOrientation(self):
            return self.__scaleOrientation
        @scaleOrientation.setter
        def scaleOrientation(self, scaleOrientation=None):
            if  scaleOrientation is None:
                scaleOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(scaleOrientation)
            self.__scaleOrientation = scaleOrientation
        @property # - - - - - - - - - - - - -
        def skinCoordIndex(self):
            return self.__skinCoordIndex
        @skinCoordIndex.setter
        def skinCoordIndex(self, skinCoordIndex=None):
            if  skinCoordIndex is None:
                skinCoordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(skinCoordIndex)
            self.__skinCoordIndex = skinCoordIndex
        @property # - - - - - - - - - - - - -
        def skinCoordWeight(self):
            return self.__skinCoordWeight
        @skinCoordWeight.setter
        def skinCoordWeight(self, skinCoordWeight=None):
            if  skinCoordWeight is None:
                skinCoordWeight = MFFloat.DEFAULT_VALUE
            isValidMFFloat(skinCoordWeight)
            self.__skinCoordWeight = skinCoordWeight
        @property # - - - - - - - - - - - - -
        def stiffness(self):
            return self.__stiffness
        @stiffness.setter
        def stiffness(self, stiffness=None):
            if  stiffness is None:
                stiffness = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(stiffness)
            self.__stiffness = stiffness
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def ulimit(self):
            return self.__ulimit
        @ulimit.setter
        def ulimit(self, ulimit=None):
            if  ulimit is None:
                ulimit = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(ulimit)
            self.__ulimit = ulimit
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children
        @property # - - - - - - - - - - - - -
        def displacers(self):
            return self.__displacers
        @displacers.setter
        def displacers(self, displacers=None):
            if  displacers is None:
                displacers = MFNode.DEFAULT_VALUE
            isValidMFNode(displacers)
            self.__displacers = displacers

class HAnimMotion(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'HAnimMotion'
    specificationUrl = 'TODO publish'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#HAnimMotion'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('channels', list(), 'MFString', 'inputOutput'),
                          ('channelsEnabled', list(), 'MFBool', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('enabled', False, 'SFBool', 'inputOutput'),
                          ('endFrame', -1, 'SFInt32', 'inputOutput'),
                          ('frameDuration', 0.1, 'SFTime', 'inputOutput'),
                          ('frameIncrement', 1, 'SFInt32', 'inputOutput'),
                          ('frameIndex', 0, 'SFInt32', 'inputOutput'),
                          ('joints', list(), 'MFString', 'inputOutput'),
                          ('loa', -1, 'SFInt32', 'inputOutput'),
                          ('loop', False, 'SFBool', 'inputOutput'),
                          ('startFrame', 0, 'SFInt32', 'inputOutput'),
                          ('values', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 channels=list(),
                 channelsEnabled=list(),
                 description='',
                 enabled=False,
                 endFrame=-1,
                 frameDuration=0.1,
                 frameIncrement=1,
                 frameIndex=0,
                 joints=list(),
                 loa=-1,
                 loop=False,
                 startFrame=0,
                 values=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode HAnimMotion __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.channels = channels
        self.channelsEnabled = channelsEnabled
        self.description = description
        self.enabled = enabled
        self.endFrame = endFrame
        self.frameDuration = frameDuration
        self.frameIncrement = frameIncrement
        self.frameIndex = frameIndex
        self.joints = joints
        self.loa = loa
        self.loop = loop
        self.startFrame = startFrame
        self.values = values
        @property # - - - - - - - - - - - - -
        def channels(self):
            return self.__channels
        @channels.setter
        def channels(self, channels=None):
            if  channels is None:
                channels = MFString.DEFAULT_VALUE
            isValidMFString(channels)
            self.__channels = channels
        @property # - - - - - - - - - - - - -
        def channelsEnabled(self):
            return self.__channelsEnabled
        @channelsEnabled.setter
        def channelsEnabled(self, channelsEnabled=None):
            if  channelsEnabled is None:
                channelsEnabled = MFBool.DEFAULT_VALUE
            isValidMFBool(channelsEnabled)
            self.__channelsEnabled = channelsEnabled
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def endFrame(self):
            return self.__endFrame
        @endFrame.setter
        def endFrame(self, endFrame=None):
            if  endFrame is None:
                endFrame = SFInt32.DEFAULT_VALUE
            isValidSFInt32(endFrame)
            self.__endFrame = endFrame
        @property # - - - - - - - - - - - - -
        def frameDuration(self):
            return self.__frameDuration
        @frameDuration.setter
        def frameDuration(self, frameDuration=None):
            if  frameDuration is None:
                frameDuration = SFTime.DEFAULT_VALUE
            isValidSFTime(frameDuration)
            self.__frameDuration = frameDuration
        @property # - - - - - - - - - - - - -
        def frameIncrement(self):
            return self.__frameIncrement
        @frameIncrement.setter
        def frameIncrement(self, frameIncrement=None):
            if  frameIncrement is None:
                frameIncrement = SFInt32.DEFAULT_VALUE
            isValidSFInt32(frameIncrement)
            self.__frameIncrement = frameIncrement
        @property # - - - - - - - - - - - - -
        def frameIndex(self):
            return self.__frameIndex
        @frameIndex.setter
        def frameIndex(self, frameIndex=None):
            if  frameIndex is None:
                frameIndex = SFInt32.DEFAULT_VALUE
            isValidSFInt32(frameIndex)
            self.__frameIndex = frameIndex
        @property # - - - - - - - - - - - - -
        def joints(self):
            return self.__joints
        @joints.setter
        def joints(self, joints=None):
            if  joints is None:
                joints = MFString.DEFAULT_VALUE
            isValidMFString(joints)
            self.__joints = joints
        @property # - - - - - - - - - - - - -
        def loa(self):
            return self.__loa
        @loa.setter
        def loa(self, loa=None):
            if  loa is None:
                loa = SFInt32.DEFAULT_VALUE
            isValidSFInt32(loa)
            self.__loa = loa
        @property # - - - - - - - - - - - - -
        def loop(self):
            return self.__loop
        @loop.setter
        def loop(self, loop=None):
            if  loop is None:
                loop = SFBool.DEFAULT_VALUE
            isValidSFBool(loop)
            self.__loop = loop
        @property # - - - - - - - - - - - - -
        def startFrame(self):
            return self.__startFrame
        @startFrame.setter
        def startFrame(self, startFrame=None):
            if  startFrame is None:
                startFrame = SFInt32.DEFAULT_VALUE
            isValidSFInt32(startFrame)
            self.__startFrame = startFrame
        @property # - - - - - - - - - - - - -
        def values(self):
            return self.__values
        @values.setter
        def values(self, values=None):
            if  values is None:
                values = MFFloat.DEFAULT_VALUE
            isValidMFFloat(values)
            self.__values = values

class HAnimSegment(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'HAnimSegment'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/hanim.html#HAnimSegment'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#HAnimSegment'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('centerOfMass', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('mass', 0, 'SFFloat', 'inputOutput'),
                          ('momentsOfInertia', [0, 0, 0, 0, 0, 0, 0, 0, 0], 'MFFloat', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput'),
                          ('displacers', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 centerOfMass=(0, 0, 0),
                 description='',
                 mass=0,
                 momentsOfInertia=[0, 0, 0, 0, 0, 0, 0, 0, 0],
                 name='',
                 USE='',
                 class_='',
                 coord=None,
                 IS=None,
                 metadata=None,
                 children=list(),
                 displacers=list()):
        # if _DEBUG: print ('... in ConcreteNode HAnimSegment __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.centerOfMass = centerOfMass
        self.description = description
        self.mass = mass
        self.momentsOfInertia = momentsOfInertia
        self.name = name
        self.coord = coord
        self.children = children
        self.displacers = displacers
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def centerOfMass(self):
            return self.__centerOfMass
        @centerOfMass.setter
        def centerOfMass(self, centerOfMass=None):
            if  centerOfMass is None:
                centerOfMass = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(centerOfMass)
            self.__centerOfMass = centerOfMass
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def momentsOfInertia(self):
            return self.__momentsOfInertia
        @momentsOfInertia.setter
        def momentsOfInertia(self, momentsOfInertia=None):
            if  momentsOfInertia is None:
                momentsOfInertia = MFFloat.DEFAULT_VALUE
            isValidMFFloat(momentsOfInertia)
            self.__momentsOfInertia = momentsOfInertia
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children
        @property # - - - - - - - - - - - - -
        def displacers(self):
            return self.__displacers
        @displacers.setter
        def displacers(self, displacers=None):
            if  displacers is None:
                displacers = MFNode.DEFAULT_VALUE
            isValidMFNode(displacers)
            self.__displacers = displacers

class HAnimSite(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'HAnimSite'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/hanim.html#HAnimSite'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#HAnimSite'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('scaleOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 description='',
                 name='',
                 rotation=(0, 0, 1, 0),
                 scale=(1, 1, 1),
                 scaleOrientation=(0, 0, 1, 0),
                 translation=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode HAnimSite __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.description = description
        self.name = name
        self.rotation = rotation
        self.scale = scale
        self.scaleOrientation = scaleOrientation
        self.translation = translation
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def scaleOrientation(self):
            return self.__scaleOrientation
        @scaleOrientation.setter
        def scaleOrientation(self, scaleOrientation=None):
            if  scaleOrientation is None:
                scaleOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(scaleOrientation)
            self.__scaleOrientation = scaleOrientation
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class ImageCubeMapTexture(_X3DEnvironmentTextureNode):
    """
    X3D element
    """
    __name__ = 'ImageCubeMapTexture'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/env_texture.html#ImageCubeMapTexture'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ImageCubeMapTexture'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None):
        # if _DEBUG: print ('... in ConcreteNode ImageCubeMapTexture __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.url = url
        self.textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties

class ImageTexture(_X3DTexture2DNode):
    """
    X3D element
    """
    __name__ = 'ImageTexture'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#ImageTexture'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ImageTexture'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('repeatS', True, 'SFBool', 'initializeOnly'),
                          ('repeatT', True, 'SFBool', 'initializeOnly'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 repeatS=True,
                 repeatT=True,
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None):
        # if _DEBUG: print ('... in ConcreteNode ImageTexture __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.repeatS = repeatS
        self.repeatT = repeatT
        self.url = url
        self.textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def repeatS(self):
            return self.__repeatS
        @repeatS.setter
        def repeatS(self, repeatS=None):
            if  repeatS is None:
                repeatS = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatS)
            self.__repeatS = repeatS
        @property # - - - - - - - - - - - - -
        def repeatT(self):
            return self.__repeatT
        @repeatT.setter
        def repeatT(self, repeatT=None):
            if  repeatT is None:
                repeatT = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatT)
            self.__repeatT = repeatT
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties

class ImageTexture3D(_X3DTexture3DNode):
    """
    X3D element
    """
    __name__ = 'ImageTexture3D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#ImageTexture3D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ImageTexture3D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('repeatR', False, 'SFBool', 'initializeOnly'),
                          ('repeatS', False, 'SFBool', 'initializeOnly'),
                          ('repeatT', False, 'SFBool', 'initializeOnly'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 repeatR=False,
                 repeatS=False,
                 repeatT=False,
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None):
        # if _DEBUG: print ('... in ConcreteNode ImageTexture3D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.repeatR = repeatR
        self.repeatS = repeatS
        self.repeatT = repeatT
        self.url = url
        self.textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def repeatR(self):
            return self.__repeatR
        @repeatR.setter
        def repeatR(self, repeatR=None):
            if  repeatR is None:
                repeatR = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatR)
            self.__repeatR = repeatR
        @property # - - - - - - - - - - - - -
        def repeatS(self):
            return self.__repeatS
        @repeatS.setter
        def repeatS(self, repeatS=None):
            if  repeatS is None:
                repeatS = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatS)
            self.__repeatS = repeatS
        @property # - - - - - - - - - - - - -
        def repeatT(self):
            return self.__repeatT
        @repeatT.setter
        def repeatT(self, repeatT=None):
            if  repeatT is None:
                repeatT = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatT)
            self.__repeatT = repeatT
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties

class IndexedFaceSet(_X3DComposedGeometryNode):
    """
    X3D element
    """
    __name__ = 'IndexedFaceSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry3D.html#IndexedFaceSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IndexedFaceSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorIndex', list(), 'MFInt32', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('convex', True, 'SFBool', 'initializeOnly'),
                          ('coordIndex', list(), 'MFInt32', 'initializeOnly'),
                          ('creaseAngle', 0, 'SFFloat', 'initializeOnly'),
                          ('normalIndex', list(), 'MFInt32', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('texCoordIndex', list(), 'MFInt32', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorIndex=list(),
                 colorPerVertex=True,
                 convex=True,
                 coordIndex=list(),
                 creaseAngle=0,
                 normalIndex=list(),
                 normalPerVertex=True,
                 solid=True,
                 texCoordIndex=list(),
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode IndexedFaceSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorIndex = colorIndex
        self.colorPerVertex = colorPerVertex
        self.convex = convex
        self.coordIndex = coordIndex
        self.creaseAngle = creaseAngle
        self.normalIndex = normalIndex
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.texCoordIndex = texCoordIndex
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorIndex(self):
            return self.__colorIndex
        @colorIndex.setter
        def colorIndex(self, colorIndex=None):
            if  colorIndex is None:
                colorIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(colorIndex)
            self.__colorIndex = colorIndex
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def convex(self):
            return self.__convex
        @convex.setter
        def convex(self, convex=None):
            if  convex is None:
                convex = SFBool.DEFAULT_VALUE
            isValidSFBool(convex)
            self.__convex = convex
        @property # - - - - - - - - - - - - -
        def coordIndex(self):
            return self.__coordIndex
        @coordIndex.setter
        def coordIndex(self, coordIndex=None):
            if  coordIndex is None:
                coordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(coordIndex)
            self.__coordIndex = coordIndex
        @property # - - - - - - - - - - - - -
        def creaseAngle(self):
            return self.__creaseAngle
        @creaseAngle.setter
        def creaseAngle(self, creaseAngle=None):
            if  creaseAngle is None:
                creaseAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(creaseAngle)
            self.__creaseAngle = creaseAngle
        @property # - - - - - - - - - - - - -
        def normalIndex(self):
            return self.__normalIndex
        @normalIndex.setter
        def normalIndex(self, normalIndex=None):
            if  normalIndex is None:
                normalIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(normalIndex)
            self.__normalIndex = normalIndex
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def texCoordIndex(self):
            return self.__texCoordIndex
        @texCoordIndex.setter
        def texCoordIndex(self, texCoordIndex=None):
            if  texCoordIndex is None:
                texCoordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(texCoordIndex)
            self.__texCoordIndex = texCoordIndex
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class IndexedLineSet(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'IndexedLineSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#IndexedLineSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IndexedLineSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('colorIndex', list(), 'MFInt32', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('coordIndex', list(), 'MFInt32', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 colorIndex=list(),
                 colorPerVertex=True,
                 coordIndex=list(),
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode IndexedLineSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.colorIndex = colorIndex
        self.colorPerVertex = colorPerVertex
        self.coordIndex = coordIndex
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def colorIndex(self):
            return self.__colorIndex
        @colorIndex.setter
        def colorIndex(self, colorIndex=None):
            if  colorIndex is None:
                colorIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(colorIndex)
            self.__colorIndex = colorIndex
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def coordIndex(self):
            return self.__coordIndex
        @coordIndex.setter
        def coordIndex(self, coordIndex=None):
            if  coordIndex is None:
                coordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(coordIndex)
            self.__coordIndex = coordIndex
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class IndexedQuadSet(_X3DComposedGeometryNode):
    """
    IndexedQuadSet is a geometry node that defines quadrilaterals.
    """
    __name__ = 'IndexedQuadSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/CADGeometry.html#IndexedQuadSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IndexedQuadSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('index', list(), 'MFInt32', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 index=list(),
                 normalPerVertex=True,
                 solid=True,
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode IndexedQuadSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.index = index
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def index(self):
            return self.__index
        @index.setter
        def index(self, index=None):
            if  index is None:
                index = MFInt32.DEFAULT_VALUE
            isValidMFInt32(index)
            self.__index = index
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class IndexedTriangleFanSet(_X3DComposedGeometryNode):
    """
    X3D element
    """
    __name__ = 'IndexedTriangleFanSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#IndexedTriangleFanSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IndexedTriangleFanSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('index', list(), 'MFInt32', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 index=list(),
                 normalPerVertex=True,
                 solid=True,
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode IndexedTriangleFanSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.index = index
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def index(self):
            return self.__index
        @index.setter
        def index(self, index=None):
            if  index is None:
                index = MFInt32.DEFAULT_VALUE
            isValidMFInt32(index)
            self.__index = index
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class IndexedTriangleSet(_X3DComposedGeometryNode):
    """
    X3D element
    """
    __name__ = 'IndexedTriangleSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#IndexedTriangleSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IndexedTriangleSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('index', list(), 'MFInt32', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 index=list(),
                 normalPerVertex=True,
                 solid=True,
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode IndexedTriangleSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.index = index
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def index(self):
            return self.__index
        @index.setter
        def index(self, index=None):
            if  index is None:
                index = MFInt32.DEFAULT_VALUE
            isValidMFInt32(index)
            self.__index = index
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class IndexedTriangleStripSet(_X3DComposedGeometryNode):
    """
    X3D element
    """
    __name__ = 'IndexedTriangleStripSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#IndexedTriangleStripSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IndexedTriangleStripSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('index', list(), 'MFInt32', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 index=list(),
                 normalPerVertex=True,
                 solid=True,
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode IndexedTriangleStripSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.index = index
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def index(self):
            return self.__index
        @index.setter
        def index(self, index=None):
            if  index is None:
                index = MFInt32.DEFAULT_VALUE
            isValidMFInt32(index)
            self.__index = index
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class Inline(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'Inline'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/networking.html#Inline'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Inline'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('load', True, 'SFBool', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 load=True,
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Inline __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.load = load
        self.url = url
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def load(self):
            return self.__load
        @load.setter
        def load(self, load=None):
            if  load is None:
                load = SFBool.DEFAULT_VALUE
            isValidSFBool(load)
            self.__load = load
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url

class IntegerSequencer(_X3DSequencerNode):
    """
    X3D element
    """
    __name__ = 'IntegerSequencer'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#IntegerSequencer'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IntegerSequencer'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', list(), 'MFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode IntegerSequencer __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFInt32.DEFAULT_VALUE
            isValidMFInt32(keyValue)
            self.__keyValue = keyValue

class IntegerTrigger(_X3DTriggerNode):
    """
    X3D element
    """
    __name__ = 'IntegerTrigger'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#IntegerTrigger'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IntegerTrigger'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('integerKey', -1, 'SFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 integerKey=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode IntegerTrigger __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.integerKey = integerKey
        @property # - - - - - - - - - - - - -
        def integerKey(self):
            return self.__integerKey
        @integerKey.setter
        def integerKey(self, integerKey=None):
            if  integerKey is None:
                integerKey = SFInt32.DEFAULT_VALUE
            isValidSFInt32(integerKey)
            self.__integerKey = integerKey

class IsoSurfaceVolumeData(_X3DVolumeDataNode):
    """
    X3D element
    """
    __name__ = 'IsoSurfaceVolumeData'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#IsoSurfaceVolumeData'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#IsoSurfaceVolumeData'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('contourStepSize', 0, 'SFFloat', 'inputOutput'),
                          ('dimensions', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('surfaceTolerance', 0, 'SFFloat', 'inputOutput'),
                          ('surfaceValues', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('gradients', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('voxels', None, 'SFNode', 'inputOutput'),
                          ('renderStyle', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 contourStepSize=0,
                 dimensions=(1, 1, 1),
                 surfaceTolerance=0,
                 surfaceValues=list(),
                 USE='',
                 class_='',
                 gradients=None,
                 IS=None,
                 metadata=None,
                 voxels=None,
                 renderStyle=list()):
        # if _DEBUG: print ('... in ConcreteNode IsoSurfaceVolumeData __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.contourStepSize = contourStepSize
        self.dimensions = dimensions
        self.surfaceTolerance = surfaceTolerance
        self.surfaceValues = surfaceValues
        self.gradients = gradients
        self.voxels = voxels
        self.renderStyle = renderStyle
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def contourStepSize(self):
            return self.__contourStepSize
        @contourStepSize.setter
        def contourStepSize(self, contourStepSize=None):
            if  contourStepSize is None:
                contourStepSize = SFFloat.DEFAULT_VALUE
            isValidSFFloat(contourStepSize)
            self.__contourStepSize = contourStepSize
        @property # - - - - - - - - - - - - -
        def dimensions(self):
            return self.__dimensions
        @dimensions.setter
        def dimensions(self, dimensions=None):
            if  dimensions is None:
                dimensions = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(dimensions)
            self.__dimensions = dimensions
        @property # - - - - - - - - - - - - -
        def surfaceTolerance(self):
            return self.__surfaceTolerance
        @surfaceTolerance.setter
        def surfaceTolerance(self, surfaceTolerance=None):
            if  surfaceTolerance is None:
                surfaceTolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(surfaceTolerance)
            self.__surfaceTolerance = surfaceTolerance
        @property # - - - - - - - - - - - - -
        def surfaceValues(self):
            return self.__surfaceValues
        @surfaceValues.setter
        def surfaceValues(self, surfaceValues=None):
            if  surfaceValues is None:
                surfaceValues = MFFloat.DEFAULT_VALUE
            isValidMFFloat(surfaceValues)
            self.__surfaceValues = surfaceValues
        @property # - - - - - - - - - - - - -
        def gradients(self):
            return self.__gradients
        @gradients.setter
        def gradients(self, gradients=None):
            if  gradients is None:
                gradients = SFNode.DEFAULT_VALUE
            isValidSFNode(gradients)
            if not isinstance(gradients, object):
                raise RuntimeError(str(gradients) + ' does not have a valid node type object')
            self.__gradients = gradients
        @property # - - - - - - - - - - - - -
        def voxels(self):
            return self.__voxels
        @voxels.setter
        def voxels(self, voxels=None):
            if  voxels is None:
                voxels = SFNode.DEFAULT_VALUE
            isValidSFNode(voxels)
            if not isinstance(voxels, object):
                raise RuntimeError(str(voxels) + ' does not have a valid node type object')
            self.__voxels = voxels
        @property # - - - - - - - - - - - - -
        def renderStyle(self):
            return self.__renderStyle
        @renderStyle.setter
        def renderStyle(self, renderStyle=None):
            if  renderStyle is None:
                renderStyle = MFNode.DEFAULT_VALUE
            isValidMFNode(renderStyle)
            self.__renderStyle = renderStyle

class KeySensor(_X3DKeyDeviceSensorNode):
    """
    X3D element
    """
    __name__ = 'KeySensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/keyboard.html#KeySensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#KeySensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode KeySensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled

class Layer(_X3DLayerNode):
    """
    X3D element
    """
    __name__ = 'Layer'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layering.html#Layer'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Layer'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('isPickable', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('viewport', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 isPickable=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 viewport=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Layer __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.isPickable = isPickable
        self.viewport = viewport
        self.children = children
        @property # - - - - - - - - - - - - -
        def isPickable(self):
            return self.__isPickable
        @isPickable.setter
        def isPickable(self, isPickable=None):
            if  isPickable is None:
                isPickable = SFBool.DEFAULT_VALUE
            isValidSFBool(isPickable)
            self.__isPickable = isPickable
        @property # - - - - - - - - - - - - -
        def viewport(self):
            return self.__viewport
        @viewport.setter
        def viewport(self, viewport=None):
            if  viewport is None:
                viewport = SFNode.DEFAULT_VALUE
            isValidSFNode(viewport)
            if not isinstance(viewport, object):
                raise RuntimeError(str(viewport) + ' does not have a valid node type object')
            self.__viewport = viewport
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class LayerSet(_X3DNode):
    """
    X3D element
    """
    __name__ = 'LayerSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layering.html#LayerSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LayerSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('activeLayer', 0, 'SFInt32', 'inputOutput'),
                          ('order', [0], 'MFInt32', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('layers', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 activeLayer=0,
                 order=[0],
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 layers=list()):
        # if _DEBUG: print ('... in ConcreteNode LayerSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.activeLayer = activeLayer
        self.order = order
        self.layers = layers
        @property # - - - - - - - - - - - - -
        def activeLayer(self):
            return self.__activeLayer
        @activeLayer.setter
        def activeLayer(self, activeLayer=None):
            if  activeLayer is None:
                activeLayer = SFInt32.DEFAULT_VALUE
            isValidSFInt32(activeLayer)
            self.__activeLayer = activeLayer
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = MFInt32.DEFAULT_VALUE
            isValidMFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def layers(self):
            return self.__layers
        @layers.setter
        def layers(self, layers=None):
            if  layers is None:
                layers = MFNode.DEFAULT_VALUE
            isValidMFNode(layers)
            self.__layers = layers

class Layout(_X3DLayoutNode):
    """
    X3D element
    """
    __name__ = 'Layout'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layout.html#Layout'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Layout'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('align', ["CENTER", "CENTER"], 'MFString', 'inputOutput'),
                          ('offset', [0, 0], 'MFFloat', 'inputOutput'),
                          ('offsetUnits', ["WORLD", "WORLD"], 'MFString', 'inputOutput'),
                          ('scaleMode', ["NONE", "NONE"], 'MFString', 'inputOutput'),
                          ('size', [1, 1], 'MFFloat', 'initializeOnly'),
                          ('sizeUnits', ["WORLD", "WORLD"], 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 align=["CENTER", "CENTER"],
                 offset=[0, 0],
                 offsetUnits=["WORLD", "WORLD"],
                 scaleMode=["NONE", "NONE"],
                 size=[1, 1],
                 sizeUnits=["WORLD", "WORLD"],
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Layout __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.align = align
        self.offset = offset
        self.offsetUnits = offsetUnits
        self.scaleMode = scaleMode
        self.size = size
        self.sizeUnits = sizeUnits
        @property # - - - - - - - - - - - - -
        def align(self):
            return self.__align
        @align.setter
        def align(self, align=None):
            if  align is None:
                align = MFString.DEFAULT_VALUE
            isValidMFString(align)
            self.__align = align
        @property # - - - - - - - - - - - - -
        def offset(self):
            return self.__offset
        @offset.setter
        def offset(self, offset=None):
            if  offset is None:
                offset = MFFloat.DEFAULT_VALUE
            isValidMFFloat(offset)
            self.__offset = offset
        @property # - - - - - - - - - - - - -
        def offsetUnits(self):
            return self.__offsetUnits
        @offsetUnits.setter
        def offsetUnits(self, offsetUnits=None):
            if  offsetUnits is None:
                offsetUnits = MFString.DEFAULT_VALUE
            isValidMFString(offsetUnits)
            self.__offsetUnits = offsetUnits
        @property # - - - - - - - - - - - - -
        def scaleMode(self):
            return self.__scaleMode
        @scaleMode.setter
        def scaleMode(self, scaleMode=None):
            if  scaleMode is None:
                scaleMode = MFString.DEFAULT_VALUE
            isValidMFString(scaleMode)
            self.__scaleMode = scaleMode
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = MFFloat.DEFAULT_VALUE
            isValidMFFloat(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def sizeUnits(self):
            return self.__sizeUnits
        @sizeUnits.setter
        def sizeUnits(self, sizeUnits=None):
            if  sizeUnits is None:
                sizeUnits = MFString.DEFAULT_VALUE
            isValidMFString(sizeUnits)
            self.__sizeUnits = sizeUnits

class LayoutGroup(_X3DNode):
    """
    X3D element
    """
    __name__ = 'LayoutGroup'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layout.html#LayoutGroup'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LayoutGroup'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('layout', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('viewport', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 USE='',
                 class_='',
                 IS=None,
                 layout=None,
                 metadata=None,
                 viewport=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode LayoutGroup __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.layout = layout
        self.viewport = viewport
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def layout(self):
            return self.__layout
        @layout.setter
        def layout(self, layout=None):
            if  layout is None:
                layout = SFNode.DEFAULT_VALUE
            isValidSFNode(layout)
            if not isinstance(layout, object):
                raise RuntimeError(str(layout) + ' does not have a valid node type object')
            self.__layout = layout
        @property # - - - - - - - - - - - - -
        def viewport(self):
            return self.__viewport
        @viewport.setter
        def viewport(self, viewport=None):
            if  viewport is None:
                viewport = SFNode.DEFAULT_VALUE
            isValidSFNode(viewport)
            if not isinstance(viewport, object):
                raise RuntimeError(str(viewport) + ' does not have a valid node type object')
            self.__viewport = viewport
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class LayoutLayer(_X3DLayerNode):
    """
    X3D element
    """
    __name__ = 'LayoutLayer'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layout.html#LayoutLayer'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LayoutLayer'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('isPickable', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('layout', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('viewport', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 isPickable=True,
                 USE='',
                 class_='',
                 IS=None,
                 layout=None,
                 metadata=None,
                 viewport=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode LayoutLayer __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.isPickable = isPickable
        self.layout = layout
        self.viewport = viewport
        self.children = children
        @property # - - - - - - - - - - - - -
        def isPickable(self):
            return self.__isPickable
        @isPickable.setter
        def isPickable(self, isPickable=None):
            if  isPickable is None:
                isPickable = SFBool.DEFAULT_VALUE
            isValidSFBool(isPickable)
            self.__isPickable = isPickable
        @property # - - - - - - - - - - - - -
        def layout(self):
            return self.__layout
        @layout.setter
        def layout(self, layout=None):
            if  layout is None:
                layout = SFNode.DEFAULT_VALUE
            isValidSFNode(layout)
            if not isinstance(layout, object):
                raise RuntimeError(str(layout) + ' does not have a valid node type object')
            self.__layout = layout
        @property # - - - - - - - - - - - - -
        def viewport(self):
            return self.__viewport
        @viewport.setter
        def viewport(self, viewport=None):
            if  viewport is None:
                viewport = SFNode.DEFAULT_VALUE
            isValidSFNode(viewport)
            if not isinstance(viewport, object):
                raise RuntimeError(str(viewport) + ' does not have a valid node type object')
            self.__viewport = viewport
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class LinePickSensor(_X3DPickSensorNode):
    """
    X3D element
    """
    __name__ = 'LinePickSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/picking.html#LinePickSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LinePickSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('intersectionType', 'BOUNDS', 'SFString', 'initializeOnly'),
                          ('matchCriterion', 'MATCH_ANY', 'SFString', 'inputOutput'),
                          ('objectType', ["ALL"], 'MFString', 'inputOutput'),
                          ('sortOrder', 'CLOSEST', 'SFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('pickingGeometry', None, 'SFNode', 'inputOutput'),
                          ('pickTarget', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 intersectionType='BOUNDS',
                 matchCriterion='MATCH_ANY',
                 objectType=["ALL"],
                 sortOrder='CLOSEST',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 pickingGeometry=None,
                 pickTarget=list()):
        # if _DEBUG: print ('... in ConcreteNode LinePickSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.intersectionType = intersectionType
        self.matchCriterion = matchCriterion
        self.objectType = objectType
        self.sortOrder = sortOrder
        self.pickingGeometry = pickingGeometry
        self.pickTarget = pickTarget
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def intersectionType(self):
            return self.__intersectionType
        @intersectionType.setter
        def intersectionType(self, intersectionType=None):
            if  intersectionType is None:
                intersectionType = SFString.DEFAULT_VALUE
            isValidSFString(intersectionType)
            self.__intersectionType = intersectionType
        @property # - - - - - - - - - - - - -
        def matchCriterion(self):
            return self.__matchCriterion
        @matchCriterion.setter
        def matchCriterion(self, matchCriterion=None):
            if  matchCriterion is None:
                matchCriterion = SFString.DEFAULT_VALUE
            isValidSFString(matchCriterion)
            self.__matchCriterion = matchCriterion
        @property # - - - - - - - - - - - - -
        def objectType(self):
            return self.__objectType
        @objectType.setter
        def objectType(self, objectType=None):
            if  objectType is None:
                objectType = MFString.DEFAULT_VALUE
            isValidMFString(objectType)
            self.__objectType = objectType
        @property # - - - - - - - - - - - - -
        def sortOrder(self):
            return self.__sortOrder
        @sortOrder.setter
        def sortOrder(self, sortOrder=None):
            if  sortOrder is None:
                sortOrder = SFString.DEFAULT_VALUE
            isValidSFString(sortOrder)
            self.__sortOrder = sortOrder
        @property # - - - - - - - - - - - - -
        def pickingGeometry(self):
            return self.__pickingGeometry
        @pickingGeometry.setter
        def pickingGeometry(self, pickingGeometry=None):
            if  pickingGeometry is None:
                pickingGeometry = SFNode.DEFAULT_VALUE
            isValidSFNode(pickingGeometry)
            if not isinstance(pickingGeometry, object):
                raise RuntimeError(str(pickingGeometry) + ' does not have a valid node type object')
            self.__pickingGeometry = pickingGeometry
        @property # - - - - - - - - - - - - -
        def pickTarget(self):
            return self.__pickTarget
        @pickTarget.setter
        def pickTarget(self, pickTarget=None):
            if  pickTarget is None:
                pickTarget = MFNode.DEFAULT_VALUE
            isValidMFNode(pickTarget)
            self.__pickTarget = pickTarget

class LineProperties(_X3DAppearanceChildNode):
    """
    X3D element
    """
    __name__ = 'LineProperties'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#LineProperties'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LineProperties'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('applied', True, 'SFBool', 'inputOutput'),
                          ('linetype', 1, 'SFInt32', 'inputOutput'),
                          ('linewidthScaleFactor', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 applied=True,
                 linetype=1,
                 linewidthScaleFactor=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode LineProperties __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.applied = applied
        self.linetype = linetype
        self.linewidthScaleFactor = linewidthScaleFactor
        @property # - - - - - - - - - - - - -
        def applied(self):
            return self.__applied
        @applied.setter
        def applied(self, applied=None):
            if  applied is None:
                applied = SFBool.DEFAULT_VALUE
            isValidSFBool(applied)
            self.__applied = applied
        @property # - - - - - - - - - - - - -
        def linetype(self):
            return self.__linetype
        @linetype.setter
        def linetype(self, linetype=None):
            if  linetype is None:
                linetype = SFInt32.DEFAULT_VALUE
            isValidSFInt32(linetype)
            self.__linetype = linetype
        @property # - - - - - - - - - - - - -
        def linewidthScaleFactor(self):
            return self.__linewidthScaleFactor
        @linewidthScaleFactor.setter
        def linewidthScaleFactor(self, linewidthScaleFactor=None):
            if  linewidthScaleFactor is None:
                linewidthScaleFactor = SFFloat.DEFAULT_VALUE
            isValidSFFloat(linewidthScaleFactor)
            self.__linewidthScaleFactor = linewidthScaleFactor

class LineSet(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'LineSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#LineSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LineSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('vertexCount', list(), 'MFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 vertexCount=list(),
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode LineSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.vertexCount = vertexCount
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def vertexCount(self):
            return self.__vertexCount
        @vertexCount.setter
        def vertexCount(self, vertexCount=None):
            if  vertexCount is None:
                vertexCount = MFInt32.DEFAULT_VALUE
            isValidMFInt32(vertexCount)
            self.__vertexCount = vertexCount
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class LoadSensor(_X3DNetworkSensorNode):
    """
    X3D element
    """
    __name__ = 'LoadSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/networking.html#LoadSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LoadSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('timeOut', 0, 'SFTime', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('watchList', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 timeOut=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 watchList=list()):
        # if _DEBUG: print ('... in ConcreteNode LoadSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.timeOut = timeOut
        self.watchList = watchList
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def timeOut(self):
            return self.__timeOut
        @timeOut.setter
        def timeOut(self, timeOut=None):
            if  timeOut is None:
                timeOut = SFTime.DEFAULT_VALUE
            isValidSFTime(timeOut)
            self.__timeOut = timeOut
        @property # - - - - - - - - - - - - -
        def watchList(self):
            return self.__watchList
        @watchList.setter
        def watchList(self, watchList=None):
            if  watchList is None:
                watchList = MFNode.DEFAULT_VALUE
            isValidMFNode(watchList)
            self.__watchList = watchList

class LocalFog(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'LocalFog'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/enveffects.html#LocalFog'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LocalFog'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('color', (1, 1, 1), 'SFColor', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('fogType', 'LINEAR', 'SFString', 'inputOutput'),
                          ('visibilityRange', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 color=(1, 1, 1),
                 enabled=True,
                 fogType='LINEAR',
                 visibilityRange=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode LocalFog __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.color = color
        self.enabled = enabled
        self.fogType = fogType
        self.visibilityRange = visibilityRange
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFColor.DEFAULT_VALUE
            isValidSFColor(color)
            self.__color = color
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def fogType(self):
            return self.__fogType
        @fogType.setter
        def fogType(self, fogType=None):
            if  fogType is None:
                fogType = SFString.DEFAULT_VALUE
            isValidSFString(fogType)
            self.__fogType = fogType
        @property # - - - - - - - - - - - - -
        def visibilityRange(self):
            return self.__visibilityRange
        @visibilityRange.setter
        def visibilityRange(self, visibilityRange=None):
            if  visibilityRange is None:
                visibilityRange = SFFloat.DEFAULT_VALUE
            isValidSFFloat(visibilityRange)
            self.__visibilityRange = visibilityRange

class LOD(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'LOD'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#LOD'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#LOD'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('forceTransitions', False, 'SFBool', 'initializeOnly'),
                          ('range', list(), 'MFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 forceTransitions=False,
                 range=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode LOD __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.forceTransitions = forceTransitions
        self.range = range
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def forceTransitions(self):
            return self.__forceTransitions
        @forceTransitions.setter
        def forceTransitions(self, forceTransitions=None):
            if  forceTransitions is None:
                forceTransitions = SFBool.DEFAULT_VALUE
            isValidSFBool(forceTransitions)
            self.__forceTransitions = forceTransitions
        @property # - - - - - - - - - - - - -
        def range(self):
            return self.__range
        @range.setter
        def range(self, range=None):
            if  range is None:
                range = MFFloat.DEFAULT_VALUE
            isValidMFFloat(range)
            self.__range = range
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class Material(_X3DMaterialNode):
    """
    X3D element
    """
    __name__ = 'Material'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#Material'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Material'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ambientIntensity', 0.2, 'SFFloat', 'inputOutput'),
                          ('diffuseColor', (0.8, 0.8, 0.8), 'SFColor', 'inputOutput'),
                          ('emissiveColor', (0, 0, 0), 'SFColor', 'inputOutput'),
                          ('shininess', 0.2, 'SFFloat', 'inputOutput'),
                          ('specularColor', (0, 0, 0), 'SFColor', 'inputOutput'),
                          ('transparency', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ambientIntensity=0.2,
                 diffuseColor=(0.8, 0.8, 0.8),
                 emissiveColor=(0, 0, 0),
                 shininess=0.2,
                 specularColor=(0, 0, 0),
                 transparency=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Material __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ambientIntensity = ambientIntensity
        self.diffuseColor = diffuseColor
        self.emissiveColor = emissiveColor
        self.shininess = shininess
        self.specularColor = specularColor
        self.transparency = transparency
        @property # - - - - - - - - - - - - -
        def ambientIntensity(self):
            return self.__ambientIntensity
        @ambientIntensity.setter
        def ambientIntensity(self, ambientIntensity=None):
            if  ambientIntensity is None:
                ambientIntensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(ambientIntensity)
            self.__ambientIntensity = ambientIntensity
        @property # - - - - - - - - - - - - -
        def diffuseColor(self):
            return self.__diffuseColor
        @diffuseColor.setter
        def diffuseColor(self, diffuseColor=None):
            if  diffuseColor is None:
                diffuseColor = SFColor.DEFAULT_VALUE
            isValidSFColor(diffuseColor)
            self.__diffuseColor = diffuseColor
        @property # - - - - - - - - - - - - -
        def emissiveColor(self):
            return self.__emissiveColor
        @emissiveColor.setter
        def emissiveColor(self, emissiveColor=None):
            if  emissiveColor is None:
                emissiveColor = SFColor.DEFAULT_VALUE
            isValidSFColor(emissiveColor)
            self.__emissiveColor = emissiveColor
        @property # - - - - - - - - - - - - -
        def shininess(self):
            return self.__shininess
        @shininess.setter
        def shininess(self, shininess=None):
            if  shininess is None:
                shininess = SFFloat.DEFAULT_VALUE
            isValidSFFloat(shininess)
            self.__shininess = shininess
        @property # - - - - - - - - - - - - -
        def specularColor(self):
            return self.__specularColor
        @specularColor.setter
        def specularColor(self, specularColor=None):
            if  specularColor is None:
                specularColor = SFColor.DEFAULT_VALUE
            isValidSFColor(specularColor)
            self.__specularColor = specularColor
        @property # - - - - - - - - - - - - -
        def transparency(self):
            return self.__transparency
        @transparency.setter
        def transparency(self, transparency=None):
            if  transparency is None:
                transparency = SFFloat.DEFAULT_VALUE
            isValidSFFloat(transparency)
            self.__transparency = transparency

class Matrix3VertexAttribute(_X3DVertexAttributeNode):
    """
    X3D element
    """
    __name__ = 'Matrix3VertexAttribute'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#Matrix3VertexAttribute'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Matrix3VertexAttribute'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('value', (list()), 'MFMatrix3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 value=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Matrix3VertexAttribute __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFMatrix3f.DEFAULT_VALUE
            isValidMFMatrix3f(value)
            self.__value = value

class Matrix4VertexAttribute(_X3DVertexAttributeNode):
    """
    X3D element
    """
    __name__ = 'Matrix4VertexAttribute'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#Matrix4VertexAttribute'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Matrix4VertexAttribute'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('value', (list()), 'MFMatrix4f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 value=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Matrix4VertexAttribute __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFMatrix4f.DEFAULT_VALUE
            isValidMFMatrix4f(value)
            self.__value = value

class MetadataBoolean(_X3DMetadataObject):
    """
    The metadata provided by this node is contained in the Boolean values of the value field.
    """
    __name__ = 'MetadataBoolean'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#MetadataBoolean'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MetadataBoolean'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('reference', '', 'SFString', 'inputOutput'),
                          ('value', list(), 'MFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 reference='',
                 value=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode MetadataBoolean __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.reference = reference
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def reference(self):
            return self.__reference
        @reference.setter
        def reference(self, reference=None):
            if  reference is None:
                reference = SFString.DEFAULT_VALUE
            isValidSFString(reference)
            self.__reference = reference
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFBool.DEFAULT_VALUE
            isValidMFBool(value)
            self.__value = value

class MetadataDouble(_X3DMetadataObject):
    """
    The metadata provided by this node is contained in the double-precision floating point numbers of the value field.
    """
    __name__ = 'MetadataDouble'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#MetadataDouble'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MetadataDouble'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('reference', '', 'SFString', 'inputOutput'),
                          ('value', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 reference='',
                 value=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode MetadataDouble __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.reference = reference
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def reference(self):
            return self.__reference
        @reference.setter
        def reference(self, reference=None):
            if  reference is None:
                reference = SFString.DEFAULT_VALUE
            isValidSFString(reference)
            self.__reference = reference
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFDouble.DEFAULT_VALUE
            isValidMFDouble(value)
            self.__value = value

class MetadataFloat(_X3DMetadataObject):
    """
    The metadata provided by this node is contained in the single-precision floating point numbers of the value field.
    """
    __name__ = 'MetadataFloat'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#MetadataFloat'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MetadataFloat'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('reference', '', 'SFString', 'inputOutput'),
                          ('value', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 reference='',
                 value=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode MetadataFloat __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.reference = reference
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def reference(self):
            return self.__reference
        @reference.setter
        def reference(self, reference=None):
            if  reference is None:
                reference = SFString.DEFAULT_VALUE
            isValidSFString(reference)
            self.__reference = reference
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFFloat.DEFAULT_VALUE
            isValidMFFloat(value)
            self.__value = value

class MetadataInteger(_X3DMetadataObject):
    """
    The metadata provided by this node is contained in the integer numbers of the value field.
    """
    __name__ = 'MetadataInteger'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#MetadataInteger'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MetadataInteger'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('reference', '', 'SFString', 'inputOutput'),
                          ('value', list(), 'MFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 reference='',
                 value=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode MetadataInteger __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.reference = reference
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def reference(self):
            return self.__reference
        @reference.setter
        def reference(self, reference=None):
            if  reference is None:
                reference = SFString.DEFAULT_VALUE
            isValidSFString(reference)
            self.__reference = reference
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFInt32.DEFAULT_VALUE
            isValidMFInt32(value)
            self.__value = value

class MetadataSet(_X3DNode):
    """
    The metadata provided by this node is contained in the metadata nodes of the value field.
    """
    __name__ = 'MetadataSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#MetadataSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MetadataSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('reference', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('value', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 reference='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 value=list()):
        # if _DEBUG: print ('... in ConcreteNode MetadataSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.reference = reference
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def reference(self):
            return self.__reference
        @reference.setter
        def reference(self, reference=None):
            if  reference is None:
                reference = SFString.DEFAULT_VALUE
            isValidSFString(reference)
            self.__reference = reference
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFNode.DEFAULT_VALUE
            isValidMFNode(value)
            self.__value = value

class MetadataString(_X3DMetadataObject):
    """
    The metadata provided by this node is contained in the strings of the value field.
    """
    __name__ = 'MetadataString'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#MetadataString'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MetadataString'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('reference', '', 'SFString', 'inputOutput'),
                          ('value', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 reference='',
                 value=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode MetadataString __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.reference = reference
        self.value = value
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def reference(self):
            return self.__reference
        @reference.setter
        def reference(self, reference=None):
            if  reference is None:
                reference = SFString.DEFAULT_VALUE
            isValidSFString(reference)
            self.__reference = reference
        @property # - - - - - - - - - - - - -
        def value(self):
            return self.__value
        @value.setter
        def value(self, value=None):
            if  value is None:
                value = MFString.DEFAULT_VALUE
            isValidMFString(value)
            self.__value = value

class MotorJoint(_X3DRigidJointNode):
    """
    MotorJoint drives relative angular velocities between body1 and body2 within a common reference frame.
    """
    __name__ = 'MotorJoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#MotorJoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MotorJoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('autoCalc', False, 'SFBool', 'initializeOnly'),
                          ('axis1Angle', 0, 'SFFloat', 'inputOutput'),
                          ('axis1Torque', 0, 'SFFloat', 'inputOutput'),
                          ('axis2Angle', 0, 'SFFloat', 'inputOutput'),
                          ('axis2Torque', 0, 'SFFloat', 'inputOutput'),
                          ('axis3Angle', 0, 'SFFloat', 'inputOutput'),
                          ('axis3Torque', 0, 'SFFloat', 'inputOutput'),
                          ('enabledAxes', 1, 'SFInt32', 'inputOutput'),
                          ('forceOutput', ["NONE"], 'MFString', 'inputOutput'),
                          ('motor1Axis', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('motor2Axis', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('motor3Axis', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('stop1Bounce', 0, 'SFFloat', 'inputOutput'),
                          ('stop1ErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('stop2Bounce', 0, 'SFFloat', 'inputOutput'),
                          ('stop2ErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('stop3Bounce', 0, 'SFFloat', 'inputOutput'),
                          ('stop3ErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('body1', None, 'SFNode', 'inputOutput'),
                          ('body2', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 autoCalc=False,
                 axis1Angle=0,
                 axis1Torque=0,
                 axis2Angle=0,
                 axis2Torque=0,
                 axis3Angle=0,
                 axis3Torque=0,
                 enabledAxes=1,
                 forceOutput=["NONE"],
                 motor1Axis=(0, 0, 0),
                 motor2Axis=(0, 0, 0),
                 motor3Axis=(0, 0, 0),
                 stop1Bounce=0,
                 stop1ErrorCorrection=0.8,
                 stop2Bounce=0,
                 stop2ErrorCorrection=0.8,
                 stop3Bounce=0,
                 stop3ErrorCorrection=0.8,
                 USE='',
                 class_='',
                 body1=None,
                 body2=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode MotorJoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.autoCalc = autoCalc
        self.axis1Angle = axis1Angle
        self.axis1Torque = axis1Torque
        self.axis2Angle = axis2Angle
        self.axis2Torque = axis2Torque
        self.axis3Angle = axis3Angle
        self.axis3Torque = axis3Torque
        self.enabledAxes = enabledAxes
        self.forceOutput = forceOutput
        self.motor1Axis = motor1Axis
        self.motor2Axis = motor2Axis
        self.motor3Axis = motor3Axis
        self.stop1Bounce = stop1Bounce
        self.stop1ErrorCorrection = stop1ErrorCorrection
        self.stop2Bounce = stop2Bounce
        self.stop2ErrorCorrection = stop2ErrorCorrection
        self.stop3Bounce = stop3Bounce
        self.stop3ErrorCorrection = stop3ErrorCorrection
        self.body1 = body1
        self.body2 = body2
        @property # - - - - - - - - - - - - -
        def autoCalc(self):
            return self.__autoCalc
        @autoCalc.setter
        def autoCalc(self, autoCalc=None):
            if  autoCalc is None:
                autoCalc = SFBool.DEFAULT_VALUE
            isValidSFBool(autoCalc)
            self.__autoCalc = autoCalc
        @property # - - - - - - - - - - - - -
        def axis1Angle(self):
            return self.__axis1Angle
        @axis1Angle.setter
        def axis1Angle(self, axis1Angle=None):
            if  axis1Angle is None:
                axis1Angle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(axis1Angle)
            self.__axis1Angle = axis1Angle
        @property # - - - - - - - - - - - - -
        def axis1Torque(self):
            return self.__axis1Torque
        @axis1Torque.setter
        def axis1Torque(self, axis1Torque=None):
            if  axis1Torque is None:
                axis1Torque = SFFloat.DEFAULT_VALUE
            isValidSFFloat(axis1Torque)
            self.__axis1Torque = axis1Torque
        @property # - - - - - - - - - - - - -
        def axis2Angle(self):
            return self.__axis2Angle
        @axis2Angle.setter
        def axis2Angle(self, axis2Angle=None):
            if  axis2Angle is None:
                axis2Angle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(axis2Angle)
            self.__axis2Angle = axis2Angle
        @property # - - - - - - - - - - - - -
        def axis2Torque(self):
            return self.__axis2Torque
        @axis2Torque.setter
        def axis2Torque(self, axis2Torque=None):
            if  axis2Torque is None:
                axis2Torque = SFFloat.DEFAULT_VALUE
            isValidSFFloat(axis2Torque)
            self.__axis2Torque = axis2Torque
        @property # - - - - - - - - - - - - -
        def axis3Angle(self):
            return self.__axis3Angle
        @axis3Angle.setter
        def axis3Angle(self, axis3Angle=None):
            if  axis3Angle is None:
                axis3Angle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(axis3Angle)
            self.__axis3Angle = axis3Angle
        @property # - - - - - - - - - - - - -
        def axis3Torque(self):
            return self.__axis3Torque
        @axis3Torque.setter
        def axis3Torque(self, axis3Torque=None):
            if  axis3Torque is None:
                axis3Torque = SFFloat.DEFAULT_VALUE
            isValidSFFloat(axis3Torque)
            self.__axis3Torque = axis3Torque
        @property # - - - - - - - - - - - - -
        def enabledAxes(self):
            return self.__enabledAxes
        @enabledAxes.setter
        def enabledAxes(self, enabledAxes=None):
            if  enabledAxes is None:
                enabledAxes = SFInt32.DEFAULT_VALUE
            isValidSFInt32(enabledAxes)
            self.__enabledAxes = enabledAxes
        @property # - - - - - - - - - - - - -
        def forceOutput(self):
            return self.__forceOutput
        @forceOutput.setter
        def forceOutput(self, forceOutput=None):
            if  forceOutput is None:
                forceOutput = MFString.DEFAULT_VALUE
            isValidMFString(forceOutput)
            self.__forceOutput = forceOutput
        @property # - - - - - - - - - - - - -
        def motor1Axis(self):
            return self.__motor1Axis
        @motor1Axis.setter
        def motor1Axis(self, motor1Axis=None):
            if  motor1Axis is None:
                motor1Axis = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(motor1Axis)
            self.__motor1Axis = motor1Axis
        @property # - - - - - - - - - - - - -
        def motor2Axis(self):
            return self.__motor2Axis
        @motor2Axis.setter
        def motor2Axis(self, motor2Axis=None):
            if  motor2Axis is None:
                motor2Axis = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(motor2Axis)
            self.__motor2Axis = motor2Axis
        @property # - - - - - - - - - - - - -
        def motor3Axis(self):
            return self.__motor3Axis
        @motor3Axis.setter
        def motor3Axis(self, motor3Axis=None):
            if  motor3Axis is None:
                motor3Axis = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(motor3Axis)
            self.__motor3Axis = motor3Axis
        @property # - - - - - - - - - - - - -
        def stop1Bounce(self):
            return self.__stop1Bounce
        @stop1Bounce.setter
        def stop1Bounce(self, stop1Bounce=None):
            if  stop1Bounce is None:
                stop1Bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop1Bounce)
            self.__stop1Bounce = stop1Bounce
        @property # - - - - - - - - - - - - -
        def stop1ErrorCorrection(self):
            return self.__stop1ErrorCorrection
        @stop1ErrorCorrection.setter
        def stop1ErrorCorrection(self, stop1ErrorCorrection=None):
            if  stop1ErrorCorrection is None:
                stop1ErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop1ErrorCorrection)
            self.__stop1ErrorCorrection = stop1ErrorCorrection
        @property # - - - - - - - - - - - - -
        def stop2Bounce(self):
            return self.__stop2Bounce
        @stop2Bounce.setter
        def stop2Bounce(self, stop2Bounce=None):
            if  stop2Bounce is None:
                stop2Bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop2Bounce)
            self.__stop2Bounce = stop2Bounce
        @property # - - - - - - - - - - - - -
        def stop2ErrorCorrection(self):
            return self.__stop2ErrorCorrection
        @stop2ErrorCorrection.setter
        def stop2ErrorCorrection(self, stop2ErrorCorrection=None):
            if  stop2ErrorCorrection is None:
                stop2ErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop2ErrorCorrection)
            self.__stop2ErrorCorrection = stop2ErrorCorrection
        @property # - - - - - - - - - - - - -
        def stop3Bounce(self):
            return self.__stop3Bounce
        @stop3Bounce.setter
        def stop3Bounce(self, stop3Bounce=None):
            if  stop3Bounce is None:
                stop3Bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop3Bounce)
            self.__stop3Bounce = stop3Bounce
        @property # - - - - - - - - - - - - -
        def stop3ErrorCorrection(self):
            return self.__stop3ErrorCorrection
        @stop3ErrorCorrection.setter
        def stop3ErrorCorrection(self, stop3ErrorCorrection=None):
            if  stop3ErrorCorrection is None:
                stop3ErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop3ErrorCorrection)
            self.__stop3ErrorCorrection = stop3ErrorCorrection
        @property # - - - - - - - - - - - - -
        def body1(self):
            return self.__body1
        @body1.setter
        def body1(self, body1=None):
            if  body1 is None:
                body1 = SFNode.DEFAULT_VALUE
            isValidSFNode(body1)
            if not isinstance(body1, object):
                raise RuntimeError(str(body1) + ' does not have a valid node type object')
            self.__body1 = body1
        @property # - - - - - - - - - - - - -
        def body2(self):
            return self.__body2
        @body2.setter
        def body2(self, body2=None):
            if  body2 is None:
                body2 = SFNode.DEFAULT_VALUE
            isValidSFNode(body2)
            if not isinstance(body2, object):
                raise RuntimeError(str(body2) + ' does not have a valid node type object')
            self.__body2 = body2

class MovieTexture(_X3DSoundSourceNode):
    """
    X3D element
    """
    __name__ = 'MovieTexture'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#MovieTexture'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MovieTexture'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('loop', False, 'SFBool', 'inputOutput'),
                          ('pauseTime', 0, 'SFTime', 'inputOutput'),
                          ('pitch', 1.0, 'SFFloat', 'inputOutput'),
                          ('repeatS', True, 'SFBool', 'initializeOnly'),
                          ('repeatT', True, 'SFBool', 'initializeOnly'),
                          ('resumeTime', 0, 'SFTime', 'inputOutput'),
                          ('speed', 1.0, 'SFFloat', 'inputOutput'),
                          ('startTime', 0, 'SFTime', 'inputOutput'),
                          ('stopTime', 0, 'SFTime', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 description='',
                 loop=False,
                 pauseTime=0,
                 pitch=1.0,
                 repeatS=True,
                 repeatT=True,
                 resumeTime=0,
                 speed=1.0,
                 startTime=0,
                 stopTime=0,
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None):
        # if _DEBUG: print ('... in ConcreteNode MovieTexture __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.description = description
        self.loop = loop
        self.pauseTime = pauseTime
        self.pitch = pitch
        self.repeatS = repeatS
        self.repeatT = repeatT
        self.resumeTime = resumeTime
        self.speed = speed
        self.startTime = startTime
        self.stopTime = stopTime
        self.url = url
        self.textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def loop(self):
            return self.__loop
        @loop.setter
        def loop(self, loop=None):
            if  loop is None:
                loop = SFBool.DEFAULT_VALUE
            isValidSFBool(loop)
            self.__loop = loop
        @property # - - - - - - - - - - - - -
        def pauseTime(self):
            return self.__pauseTime
        @pauseTime.setter
        def pauseTime(self, pauseTime=None):
            if  pauseTime is None:
                pauseTime = SFTime.DEFAULT_VALUE
            isValidSFTime(pauseTime)
            self.__pauseTime = pauseTime
        @property # - - - - - - - - - - - - -
        def pitch(self):
            return self.__pitch
        @pitch.setter
        def pitch(self, pitch=None):
            if  pitch is None:
                pitch = SFFloat.DEFAULT_VALUE
            isValidSFFloat(pitch)
            self.__pitch = pitch
        @property # - - - - - - - - - - - - -
        def repeatS(self):
            return self.__repeatS
        @repeatS.setter
        def repeatS(self, repeatS=None):
            if  repeatS is None:
                repeatS = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatS)
            self.__repeatS = repeatS
        @property # - - - - - - - - - - - - -
        def repeatT(self):
            return self.__repeatT
        @repeatT.setter
        def repeatT(self, repeatT=None):
            if  repeatT is None:
                repeatT = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatT)
            self.__repeatT = repeatT
        @property # - - - - - - - - - - - - -
        def resumeTime(self):
            return self.__resumeTime
        @resumeTime.setter
        def resumeTime(self, resumeTime=None):
            if  resumeTime is None:
                resumeTime = SFTime.DEFAULT_VALUE
            isValidSFTime(resumeTime)
            self.__resumeTime = resumeTime
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def startTime(self):
            return self.__startTime
        @startTime.setter
        def startTime(self, startTime=None):
            if  startTime is None:
                startTime = SFTime.DEFAULT_VALUE
            isValidSFTime(startTime)
            self.__startTime = startTime
        @property # - - - - - - - - - - - - -
        def stopTime(self):
            return self.__stopTime
        @stopTime.setter
        def stopTime(self, stopTime=None):
            if  stopTime is None:
                stopTime = SFTime.DEFAULT_VALUE
            isValidSFTime(stopTime)
            self.__stopTime = stopTime
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties

class MultiTexture(_X3DTextureNode):
    """
    X3D element
    """
    __name__ = 'MultiTexture'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#MultiTexture'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MultiTexture'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('alpha', 1, 'SFFloat', 'inputOutput'),
                          ('color', (1, 1, 1), 'SFColor', 'inputOutput'),
                          ('function', list(), 'MFString', 'inputOutput'),
                          ('mode', list(), 'MFString', 'inputOutput'),
                          ('source', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('texture', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 alpha=1,
                 color=(1, 1, 1),
                 function=list(),
                 mode=list(),
                 source=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 texture=list()):
        # if _DEBUG: print ('... in ConcreteNode MultiTexture __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.alpha = alpha
        self.color = color
        self.function = function
        self.mode = mode
        self.source = source
        self.texture = texture
        @property # - - - - - - - - - - - - -
        def alpha(self):
            return self.__alpha
        @alpha.setter
        def alpha(self, alpha=None):
            if  alpha is None:
                alpha = SFFloat.DEFAULT_VALUE
            isValidSFFloat(alpha)
            self.__alpha = alpha
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFColor.DEFAULT_VALUE
            isValidSFColor(color)
            self.__color = color
        @property # - - - - - - - - - - - - -
        def function(self):
            return self.__function
        @function.setter
        def function(self, function=None):
            if  function is None:
                function = MFString.DEFAULT_VALUE
            isValidMFString(function)
            self.__function = function
        @property # - - - - - - - - - - - - -
        def mode(self):
            return self.__mode
        @mode.setter
        def mode(self, mode=None):
            if  mode is None:
                mode = MFString.DEFAULT_VALUE
            isValidMFString(mode)
            self.__mode = mode
        @property # - - - - - - - - - - - - -
        def source(self):
            return self.__source
        @source.setter
        def source(self, source=None):
            if  source is None:
                source = MFString.DEFAULT_VALUE
            isValidMFString(source)
            self.__source = source
        @property # - - - - - - - - - - - - -
        def texture(self):
            return self.__texture
        @texture.setter
        def texture(self, texture=None):
            if  texture is None:
                texture = MFNode.DEFAULT_VALUE
            isValidMFNode(texture)
            self.__texture = texture

class MultiTextureCoordinate(_X3DTextureCoordinateNode):
    """
    X3D element
    """
    __name__ = 'MultiTextureCoordinate'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#MultiTextureCoordinate'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MultiTextureCoordinate'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('texCoord', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 texCoord=list()):
        # if _DEBUG: print ('... in ConcreteNode MultiTextureCoordinate __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = MFNode.DEFAULT_VALUE
            isValidMFNode(texCoord)
            self.__texCoord = texCoord

class MultiTextureTransform(_X3DTextureTransformNode):
    """
    X3D element
    """
    __name__ = 'MultiTextureTransform'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#MultiTextureTransform'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#MultiTextureTransform'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureTransform', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureTransform=list()):
        # if _DEBUG: print ('... in ConcreteNode MultiTextureTransform __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.textureTransform = textureTransform
        @property # - - - - - - - - - - - - -
        def textureTransform(self):
            return self.__textureTransform
        @textureTransform.setter
        def textureTransform(self, textureTransform=None):
            if  textureTransform is None:
                textureTransform = MFNode.DEFAULT_VALUE
            isValidMFNode(textureTransform)
            self.__textureTransform = textureTransform

class NavigationInfo(_X3DBindableNode):
    """
    X3D element
    """
    __name__ = 'NavigationInfo'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#NavigationInfo'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NavigationInfo'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('avatarSize', [0.25, 1.6, 0.75], 'MFFloat', 'inputOutput'),
                          ('headlight', True, 'SFBool', 'inputOutput'),
                          ('speed', 1, 'SFFloat', 'inputOutput'),
                          ('transitionTime', 1.0, 'SFTime', 'inputOutput'),
                          ('transitionType', ["LINEAR"], 'MFString', 'inputOutput'),
                          ('type', ["EXAMINE", "ANY"], 'MFString', 'inputOutput'),
                          ('visibilityLimit', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 avatarSize=[0.25, 1.6, 0.75],
                 headlight=True,
                 speed=1,
                 transitionTime=1.0,
                 transitionType=["LINEAR"],
                 type=["EXAMINE", "ANY"],
                 visibilityLimit=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NavigationInfo __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.avatarSize = avatarSize
        self.headlight = headlight
        self.speed = speed
        self.transitionTime = transitionTime
        self.transitionType = transitionType
        self.type = type
        self.visibilityLimit = visibilityLimit
        @property # - - - - - - - - - - - - -
        def avatarSize(self):
            return self.__avatarSize
        @avatarSize.setter
        def avatarSize(self, avatarSize=None):
            if  avatarSize is None:
                avatarSize = MFFloat.DEFAULT_VALUE
            isValidMFFloat(avatarSize)
            self.__avatarSize = avatarSize
        @property # - - - - - - - - - - - - -
        def headlight(self):
            return self.__headlight
        @headlight.setter
        def headlight(self, headlight=None):
            if  headlight is None:
                headlight = SFBool.DEFAULT_VALUE
            isValidSFBool(headlight)
            self.__headlight = headlight
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def transitionTime(self):
            return self.__transitionTime
        @transitionTime.setter
        def transitionTime(self, transitionTime=None):
            if  transitionTime is None:
                transitionTime = SFTime.DEFAULT_VALUE
            isValidSFTime(transitionTime)
            self.__transitionTime = transitionTime
        @property # - - - - - - - - - - - - -
        def transitionType(self):
            return self.__transitionType
        @transitionType.setter
        def transitionType(self, transitionType=None):
            if  transitionType is None:
                transitionType = MFString.DEFAULT_VALUE
            isValidMFString(transitionType)
            self.__transitionType = transitionType
        @property # - - - - - - - - - - - - -
        def type(self):
            return self.__type
        @type.setter
        def type(self, type=None):
            if  type is None:
                type = MFString.DEFAULT_VALUE
            isValidMFString(type)
            self.__type = type
        @property # - - - - - - - - - - - - -
        def visibilityLimit(self):
            return self.__visibilityLimit
        @visibilityLimit.setter
        def visibilityLimit(self, visibilityLimit=None):
            if  visibilityLimit is None:
                visibilityLimit = SFFloat.DEFAULT_VALUE
            isValidSFFloat(visibilityLimit)
            self.__visibilityLimit = visibilityLimit

class Normal(_X3DNormalNode):
    """
    X3D element
    """
    __name__ = 'Normal'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#Normal'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Normal'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('vector', (list()), 'MFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 vector=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Normal __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.vector = vector
        @property # - - - - - - - - - - - - -
        def vector(self):
            return self.__vector
        @vector.setter
        def vector(self, vector=None):
            if  vector is None:
                vector = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(vector)
            self.__vector = vector

class NormalInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'NormalInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#NormalInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NormalInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NormalInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(keyValue)
            self.__keyValue = keyValue

class NurbsCurve(_X3DParametricGeometryNode):
    """
    X3D element
    """
    __name__ = 'NurbsCurve'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsCurve'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsCurve'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('closed', False, 'SFBool', 'initializeOnly'),
                          ('knot', list(), 'MFDouble', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tessellation', 0, 'SFInt32', 'inputOutput'),
                          ('weight', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('controlPoint', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 closed=False,
                 knot=list(),
                 order=3,
                 tessellation=0,
                 weight=list(),
                 USE='',
                 class_='',
                 controlPoint=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsCurve __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.closed = closed
        self.knot = knot
        self.order = order
        self.tessellation = tessellation
        self.weight = weight
        self.controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def closed(self):
            return self.__closed
        @closed.setter
        def closed(self, closed=None):
            if  closed is None:
                closed = SFBool.DEFAULT_VALUE
            isValidSFBool(closed)
            self.__closed = closed
        @property # - - - - - - - - - - - - -
        def knot(self):
            return self.__knot
        @knot.setter
        def knot(self, knot=None):
            if  knot is None:
                knot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(knot)
            self.__knot = knot
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tessellation(self):
            return self.__tessellation
        @tessellation.setter
        def tessellation(self, tessellation=None):
            if  tessellation is None:
                tessellation = SFInt32.DEFAULT_VALUE
            isValidSFInt32(tessellation)
            self.__tessellation = tessellation
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFDouble.DEFAULT_VALUE
            isValidMFDouble(weight)
            self.__weight = weight
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = SFNode.DEFAULT_VALUE
            isValidSFNode(controlPoint)
            if not isinstance(controlPoint, object):
                raise RuntimeError(str(controlPoint) + ' does not have a valid node type object')
            self.__controlPoint = controlPoint

class NurbsCurve2D(_X3DNurbsControlCurveNode):
    """
    X3D element
    """
    __name__ = 'NurbsCurve2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsCurve2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsCurve2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('closed', False, 'SFBool', 'initializeOnly'),
                          ('controlPoint', (list()), 'MFVec2d', 'inputOutput'),
                          ('knot', list(), 'MFDouble', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tessellation', 0, 'SFInt32', 'inputOutput'),
                          ('weight', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 closed=False,
                 controlPoint=(list()),
                 knot=list(),
                 order=3,
                 tessellation=0,
                 weight=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsCurve2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.closed = closed
        self.controlPoint = controlPoint
        self.knot = knot
        self.order = order
        self.tessellation = tessellation
        self.weight = weight
        @property # - - - - - - - - - - - - -
        def closed(self):
            return self.__closed
        @closed.setter
        def closed(self, closed=None):
            if  closed is None:
                closed = SFBool.DEFAULT_VALUE
            isValidSFBool(closed)
            self.__closed = closed
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = MFVec2d.DEFAULT_VALUE
            isValidMFVec2d(controlPoint)
            self.__controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def knot(self):
            return self.__knot
        @knot.setter
        def knot(self, knot=None):
            if  knot is None:
                knot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(knot)
            self.__knot = knot
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tessellation(self):
            return self.__tessellation
        @tessellation.setter
        def tessellation(self, tessellation=None):
            if  tessellation is None:
                tessellation = SFInt32.DEFAULT_VALUE
            isValidSFInt32(tessellation)
            self.__tessellation = tessellation
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFDouble.DEFAULT_VALUE
            isValidMFDouble(weight)
            self.__weight = weight

class NurbsOrientationInterpolator(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'NurbsOrientationInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsOrientationInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsOrientationInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('knot', list(), 'MFDouble', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'inputOutput'),
                          ('weight', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('controlPoint', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 knot=list(),
                 order=3,
                 weight=list(),
                 USE='',
                 class_='',
                 controlPoint=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsOrientationInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.knot = knot
        self.order = order
        self.weight = weight
        self.controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def knot(self):
            return self.__knot
        @knot.setter
        def knot(self, knot=None):
            if  knot is None:
                knot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(knot)
            self.__knot = knot
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFDouble.DEFAULT_VALUE
            isValidMFDouble(weight)
            self.__weight = weight
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = SFNode.DEFAULT_VALUE
            isValidSFNode(controlPoint)
            if not isinstance(controlPoint, object):
                raise RuntimeError(str(controlPoint) + ' does not have a valid node type object')
            self.__controlPoint = controlPoint

class NurbsPatchSurface(_X3DNurbsSurfaceGeometryNode):
    """
    X3D element
    """
    __name__ = 'NurbsPatchSurface'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsPatchSurface'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsPatchSurface'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('uClosed', False, 'SFBool', 'initializeOnly'),
                          ('uDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('uKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('uOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('uTessellation', 0, 'SFInt32', 'inputOutput'),
                          ('vClosed', False, 'SFBool', 'initializeOnly'),
                          ('vDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('vKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('vOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('vTessellation', 0, 'SFInt32', 'inputOutput'),
                          ('weight', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('controlPoint', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 solid=True,
                 uClosed=False,
                 uDimension=0,
                 uKnot=list(),
                 uOrder=3,
                 uTessellation=0,
                 vClosed=False,
                 vDimension=0,
                 vKnot=list(),
                 vOrder=3,
                 vTessellation=0,
                 weight=list(),
                 USE='',
                 class_='',
                 controlPoint=None,
                 IS=None,
                 metadata=None,
                 texCoord=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsPatchSurface __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.solid = solid
        self.uClosed = uClosed
        self.uDimension = uDimension
        self.uKnot = uKnot
        self.uOrder = uOrder
        self.uTessellation = uTessellation
        self.vClosed = vClosed
        self.vDimension = vDimension
        self.vKnot = vKnot
        self.vOrder = vOrder
        self.vTessellation = vTessellation
        self.weight = weight
        self.controlPoint = controlPoint
        self.texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def uClosed(self):
            return self.__uClosed
        @uClosed.setter
        def uClosed(self, uClosed=None):
            if  uClosed is None:
                uClosed = SFBool.DEFAULT_VALUE
            isValidSFBool(uClosed)
            self.__uClosed = uClosed
        @property # - - - - - - - - - - - - -
        def uDimension(self):
            return self.__uDimension
        @uDimension.setter
        def uDimension(self, uDimension=None):
            if  uDimension is None:
                uDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uDimension)
            self.__uDimension = uDimension
        @property # - - - - - - - - - - - - -
        def uKnot(self):
            return self.__uKnot
        @uKnot.setter
        def uKnot(self, uKnot=None):
            if  uKnot is None:
                uKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(uKnot)
            self.__uKnot = uKnot
        @property # - - - - - - - - - - - - -
        def uOrder(self):
            return self.__uOrder
        @uOrder.setter
        def uOrder(self, uOrder=None):
            if  uOrder is None:
                uOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uOrder)
            self.__uOrder = uOrder
        @property # - - - - - - - - - - - - -
        def uTessellation(self):
            return self.__uTessellation
        @uTessellation.setter
        def uTessellation(self, uTessellation=None):
            if  uTessellation is None:
                uTessellation = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uTessellation)
            self.__uTessellation = uTessellation
        @property # - - - - - - - - - - - - -
        def vClosed(self):
            return self.__vClosed
        @vClosed.setter
        def vClosed(self, vClosed=None):
            if  vClosed is None:
                vClosed = SFBool.DEFAULT_VALUE
            isValidSFBool(vClosed)
            self.__vClosed = vClosed
        @property # - - - - - - - - - - - - -
        def vDimension(self):
            return self.__vDimension
        @vDimension.setter
        def vDimension(self, vDimension=None):
            if  vDimension is None:
                vDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vDimension)
            self.__vDimension = vDimension
        @property # - - - - - - - - - - - - -
        def vKnot(self):
            return self.__vKnot
        @vKnot.setter
        def vKnot(self, vKnot=None):
            if  vKnot is None:
                vKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(vKnot)
            self.__vKnot = vKnot
        @property # - - - - - - - - - - - - -
        def vOrder(self):
            return self.__vOrder
        @vOrder.setter
        def vOrder(self, vOrder=None):
            if  vOrder is None:
                vOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vOrder)
            self.__vOrder = vOrder
        @property # - - - - - - - - - - - - -
        def vTessellation(self):
            return self.__vTessellation
        @vTessellation.setter
        def vTessellation(self, vTessellation=None):
            if  vTessellation is None:
                vTessellation = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vTessellation)
            self.__vTessellation = vTessellation
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFDouble.DEFAULT_VALUE
            isValidMFDouble(weight)
            self.__weight = weight
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = SFNode.DEFAULT_VALUE
            isValidSFNode(controlPoint)
            if not isinstance(controlPoint, object):
                raise RuntimeError(str(controlPoint) + ' does not have a valid node type object')
            self.__controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord

class NurbsPositionInterpolator(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'NurbsPositionInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsPositionInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsPositionInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('knot', list(), 'MFDouble', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'inputOutput'),
                          ('weight', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('controlPoint', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 knot=list(),
                 order=3,
                 weight=list(),
                 USE='',
                 class_='',
                 controlPoint=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsPositionInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.knot = knot
        self.order = order
        self.weight = weight
        self.controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def knot(self):
            return self.__knot
        @knot.setter
        def knot(self, knot=None):
            if  knot is None:
                knot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(knot)
            self.__knot = knot
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFDouble.DEFAULT_VALUE
            isValidMFDouble(weight)
            self.__weight = weight
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = SFNode.DEFAULT_VALUE
            isValidSFNode(controlPoint)
            if not isinstance(controlPoint, object):
                raise RuntimeError(str(controlPoint) + ' does not have a valid node type object')
            self.__controlPoint = controlPoint

class NurbsSet(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'NurbsSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('tessellationScale', 1.0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('geometry', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 tessellationScale=1.0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 geometry=list()):
        # if _DEBUG: print ('... in ConcreteNode NurbsSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.tessellationScale = tessellationScale
        self.geometry = geometry
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def tessellationScale(self):
            return self.__tessellationScale
        @tessellationScale.setter
        def tessellationScale(self, tessellationScale=None):
            if  tessellationScale is None:
                tessellationScale = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tessellationScale)
            self.__tessellationScale = tessellationScale
        @property # - - - - - - - - - - - - -
        def geometry(self):
            return self.__geometry
        @geometry.setter
        def geometry(self, geometry=None):
            if  geometry is None:
                geometry = MFNode.DEFAULT_VALUE
            isValidMFNode(geometry)
            self.__geometry = geometry

class NurbsSurfaceInterpolator(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'NurbsSurfaceInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsSurfaceInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsSurfaceInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('uDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('uKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('uOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('vDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('vKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('vOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('weight', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('controlPoint', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 uDimension=0,
                 uKnot=list(),
                 uOrder=3,
                 vDimension=0,
                 vKnot=list(),
                 vOrder=3,
                 weight=list(),
                 USE='',
                 class_='',
                 controlPoint=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsSurfaceInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.uDimension = uDimension
        self.uKnot = uKnot
        self.uOrder = uOrder
        self.vDimension = vDimension
        self.vKnot = vKnot
        self.vOrder = vOrder
        self.weight = weight
        self.controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def uDimension(self):
            return self.__uDimension
        @uDimension.setter
        def uDimension(self, uDimension=None):
            if  uDimension is None:
                uDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uDimension)
            self.__uDimension = uDimension
        @property # - - - - - - - - - - - - -
        def uKnot(self):
            return self.__uKnot
        @uKnot.setter
        def uKnot(self, uKnot=None):
            if  uKnot is None:
                uKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(uKnot)
            self.__uKnot = uKnot
        @property # - - - - - - - - - - - - -
        def uOrder(self):
            return self.__uOrder
        @uOrder.setter
        def uOrder(self, uOrder=None):
            if  uOrder is None:
                uOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uOrder)
            self.__uOrder = uOrder
        @property # - - - - - - - - - - - - -
        def vDimension(self):
            return self.__vDimension
        @vDimension.setter
        def vDimension(self, vDimension=None):
            if  vDimension is None:
                vDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vDimension)
            self.__vDimension = vDimension
        @property # - - - - - - - - - - - - -
        def vKnot(self):
            return self.__vKnot
        @vKnot.setter
        def vKnot(self, vKnot=None):
            if  vKnot is None:
                vKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(vKnot)
            self.__vKnot = vKnot
        @property # - - - - - - - - - - - - -
        def vOrder(self):
            return self.__vOrder
        @vOrder.setter
        def vOrder(self, vOrder=None):
            if  vOrder is None:
                vOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vOrder)
            self.__vOrder = vOrder
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFDouble.DEFAULT_VALUE
            isValidMFDouble(weight)
            self.__weight = weight
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = SFNode.DEFAULT_VALUE
            isValidSFNode(controlPoint)
            if not isinstance(controlPoint, object):
                raise RuntimeError(str(controlPoint) + ' does not have a valid node type object')
            self.__controlPoint = controlPoint

class NurbsSweptSurface(_X3DParametricGeometryNode):
    """
    X3D element
    """
    __name__ = 'NurbsSweptSurface'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsSweptSurface'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsSweptSurface'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('crossSectionCurve', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('trajectoryCurve', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 solid=True,
                 USE='',
                 class_='',
                 crossSectionCurve=None,
                 IS=None,
                 metadata=None,
                 trajectoryCurve=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsSweptSurface __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.solid = solid
        self.crossSectionCurve = crossSectionCurve
        self.trajectoryCurve = trajectoryCurve
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def crossSectionCurve(self):
            return self.__crossSectionCurve
        @crossSectionCurve.setter
        def crossSectionCurve(self, crossSectionCurve=None):
            if  crossSectionCurve is None:
                crossSectionCurve = SFNode.DEFAULT_VALUE
            isValidSFNode(crossSectionCurve)
            if not isinstance(crossSectionCurve, object):
                raise RuntimeError(str(crossSectionCurve) + ' does not have a valid node type object')
            self.__crossSectionCurve = crossSectionCurve
        @property # - - - - - - - - - - - - -
        def trajectoryCurve(self):
            return self.__trajectoryCurve
        @trajectoryCurve.setter
        def trajectoryCurve(self, trajectoryCurve=None):
            if  trajectoryCurve is None:
                trajectoryCurve = SFNode.DEFAULT_VALUE
            isValidSFNode(trajectoryCurve)
            if not isinstance(trajectoryCurve, object):
                raise RuntimeError(str(trajectoryCurve) + ' does not have a valid node type object')
            self.__trajectoryCurve = trajectoryCurve

class NurbsSwungSurface(_X3DParametricGeometryNode):
    """
    X3D element
    """
    __name__ = 'NurbsSwungSurface'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsSwungSurface'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsSwungSurface'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('profileCurve', None, 'SFNode', 'inputOutput'),
                          ('trajectoryCurve', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 solid=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 profileCurve=None,
                 trajectoryCurve=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsSwungSurface __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.solid = solid
        self.profileCurve = profileCurve
        self.trajectoryCurve = trajectoryCurve
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def profileCurve(self):
            return self.__profileCurve
        @profileCurve.setter
        def profileCurve(self, profileCurve=None):
            if  profileCurve is None:
                profileCurve = SFNode.DEFAULT_VALUE
            isValidSFNode(profileCurve)
            if not isinstance(profileCurve, object):
                raise RuntimeError(str(profileCurve) + ' does not have a valid node type object')
            self.__profileCurve = profileCurve
        @property # - - - - - - - - - - - - -
        def trajectoryCurve(self):
            return self.__trajectoryCurve
        @trajectoryCurve.setter
        def trajectoryCurve(self, trajectoryCurve=None):
            if  trajectoryCurve is None:
                trajectoryCurve = SFNode.DEFAULT_VALUE
            isValidSFNode(trajectoryCurve)
            if not isinstance(trajectoryCurve, object):
                raise RuntimeError(str(trajectoryCurve) + ' does not have a valid node type object')
            self.__trajectoryCurve = trajectoryCurve

class NurbsTextureCoordinate(_X3DNode):
    """
    X3D element
    """
    __name__ = 'NurbsTextureCoordinate'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsTextureCoordinate'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsTextureCoordinate'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('controlPoint', (list()), 'MFVec2f', 'inputOutput'),
                          ('uDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('uKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('uOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('vDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('vKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('vOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('weight', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 controlPoint=(list()),
                 uDimension=0,
                 uKnot=list(),
                 uOrder=3,
                 vDimension=0,
                 vKnot=list(),
                 vOrder=3,
                 weight=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode NurbsTextureCoordinate __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.controlPoint = controlPoint
        self.uDimension = uDimension
        self.uKnot = uKnot
        self.uOrder = uOrder
        self.vDimension = vDimension
        self.vKnot = vKnot
        self.vOrder = vOrder
        self.weight = weight
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(controlPoint)
            self.__controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def uDimension(self):
            return self.__uDimension
        @uDimension.setter
        def uDimension(self, uDimension=None):
            if  uDimension is None:
                uDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uDimension)
            self.__uDimension = uDimension
        @property # - - - - - - - - - - - - -
        def uKnot(self):
            return self.__uKnot
        @uKnot.setter
        def uKnot(self, uKnot=None):
            if  uKnot is None:
                uKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(uKnot)
            self.__uKnot = uKnot
        @property # - - - - - - - - - - - - -
        def uOrder(self):
            return self.__uOrder
        @uOrder.setter
        def uOrder(self, uOrder=None):
            if  uOrder is None:
                uOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uOrder)
            self.__uOrder = uOrder
        @property # - - - - - - - - - - - - -
        def vDimension(self):
            return self.__vDimension
        @vDimension.setter
        def vDimension(self, vDimension=None):
            if  vDimension is None:
                vDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vDimension)
            self.__vDimension = vDimension
        @property # - - - - - - - - - - - - -
        def vKnot(self):
            return self.__vKnot
        @vKnot.setter
        def vKnot(self, vKnot=None):
            if  vKnot is None:
                vKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(vKnot)
            self.__vKnot = vKnot
        @property # - - - - - - - - - - - - -
        def vOrder(self):
            return self.__vOrder
        @vOrder.setter
        def vOrder(self, vOrder=None):
            if  vOrder is None:
                vOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vOrder)
            self.__vOrder = vOrder
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFFloat.DEFAULT_VALUE
            isValidMFFloat(weight)
            self.__weight = weight

class NurbsTrimmedSurface(_X3DNurbsSurfaceGeometryNode):
    """
    X3D element
    """
    __name__ = 'NurbsTrimmedSurface'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/nurbs.html#NurbsTrimmedSurface'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#NurbsTrimmedSurface'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('uClosed', False, 'SFBool', 'initializeOnly'),
                          ('uDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('uKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('uOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('uTessellation', 0, 'SFInt32', 'inputOutput'),
                          ('vClosed', False, 'SFBool', 'initializeOnly'),
                          ('vDimension', 0, 'SFInt32', 'initializeOnly'),
                          ('vKnot', list(), 'MFDouble', 'initializeOnly'),
                          ('vOrder', 3, 'SFInt32', 'initializeOnly'),
                          ('vTessellation', 0, 'SFInt32', 'inputOutput'),
                          ('weight', list(), 'MFDouble', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('controlPoint', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('trimmingContour', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 solid=True,
                 uClosed=False,
                 uDimension=0,
                 uKnot=list(),
                 uOrder=3,
                 uTessellation=0,
                 vClosed=False,
                 vDimension=0,
                 vKnot=list(),
                 vOrder=3,
                 vTessellation=0,
                 weight=list(),
                 USE='',
                 class_='',
                 controlPoint=None,
                 IS=None,
                 metadata=None,
                 texCoord=None,
                 trimmingContour=list()):
        # if _DEBUG: print ('... in ConcreteNode NurbsTrimmedSurface __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.solid = solid
        self.uClosed = uClosed
        self.uDimension = uDimension
        self.uKnot = uKnot
        self.uOrder = uOrder
        self.uTessellation = uTessellation
        self.vClosed = vClosed
        self.vDimension = vDimension
        self.vKnot = vKnot
        self.vOrder = vOrder
        self.vTessellation = vTessellation
        self.weight = weight
        self.controlPoint = controlPoint
        self.texCoord = texCoord
        self.trimmingContour = trimmingContour
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def uClosed(self):
            return self.__uClosed
        @uClosed.setter
        def uClosed(self, uClosed=None):
            if  uClosed is None:
                uClosed = SFBool.DEFAULT_VALUE
            isValidSFBool(uClosed)
            self.__uClosed = uClosed
        @property # - - - - - - - - - - - - -
        def uDimension(self):
            return self.__uDimension
        @uDimension.setter
        def uDimension(self, uDimension=None):
            if  uDimension is None:
                uDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uDimension)
            self.__uDimension = uDimension
        @property # - - - - - - - - - - - - -
        def uKnot(self):
            return self.__uKnot
        @uKnot.setter
        def uKnot(self, uKnot=None):
            if  uKnot is None:
                uKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(uKnot)
            self.__uKnot = uKnot
        @property # - - - - - - - - - - - - -
        def uOrder(self):
            return self.__uOrder
        @uOrder.setter
        def uOrder(self, uOrder=None):
            if  uOrder is None:
                uOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uOrder)
            self.__uOrder = uOrder
        @property # - - - - - - - - - - - - -
        def uTessellation(self):
            return self.__uTessellation
        @uTessellation.setter
        def uTessellation(self, uTessellation=None):
            if  uTessellation is None:
                uTessellation = SFInt32.DEFAULT_VALUE
            isValidSFInt32(uTessellation)
            self.__uTessellation = uTessellation
        @property # - - - - - - - - - - - - -
        def vClosed(self):
            return self.__vClosed
        @vClosed.setter
        def vClosed(self, vClosed=None):
            if  vClosed is None:
                vClosed = SFBool.DEFAULT_VALUE
            isValidSFBool(vClosed)
            self.__vClosed = vClosed
        @property # - - - - - - - - - - - - -
        def vDimension(self):
            return self.__vDimension
        @vDimension.setter
        def vDimension(self, vDimension=None):
            if  vDimension is None:
                vDimension = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vDimension)
            self.__vDimension = vDimension
        @property # - - - - - - - - - - - - -
        def vKnot(self):
            return self.__vKnot
        @vKnot.setter
        def vKnot(self, vKnot=None):
            if  vKnot is None:
                vKnot = MFDouble.DEFAULT_VALUE
            isValidMFDouble(vKnot)
            self.__vKnot = vKnot
        @property # - - - - - - - - - - - - -
        def vOrder(self):
            return self.__vOrder
        @vOrder.setter
        def vOrder(self, vOrder=None):
            if  vOrder is None:
                vOrder = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vOrder)
            self.__vOrder = vOrder
        @property # - - - - - - - - - - - - -
        def vTessellation(self):
            return self.__vTessellation
        @vTessellation.setter
        def vTessellation(self, vTessellation=None):
            if  vTessellation is None:
                vTessellation = SFInt32.DEFAULT_VALUE
            isValidSFInt32(vTessellation)
            self.__vTessellation = vTessellation
        @property # - - - - - - - - - - - - -
        def weight(self):
            return self.__weight
        @weight.setter
        def weight(self, weight=None):
            if  weight is None:
                weight = MFDouble.DEFAULT_VALUE
            isValidMFDouble(weight)
            self.__weight = weight
        @property # - - - - - - - - - - - - -
        def controlPoint(self):
            return self.__controlPoint
        @controlPoint.setter
        def controlPoint(self, controlPoint=None):
            if  controlPoint is None:
                controlPoint = SFNode.DEFAULT_VALUE
            isValidSFNode(controlPoint)
            if not isinstance(controlPoint, object):
                raise RuntimeError(str(controlPoint) + ' does not have a valid node type object')
            self.__controlPoint = controlPoint
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def trimmingContour(self):
            return self.__trimmingContour
        @trimmingContour.setter
        def trimmingContour(self, trimmingContour=None):
            if  trimmingContour is None:
                trimmingContour = MFNode.DEFAULT_VALUE
            isValidMFNode(trimmingContour)
            self.__trimmingContour = trimmingContour

class OpacityMapVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'OpacityMapVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#OpacityMapVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#OpacityMapVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('transferFunction', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 transferFunction=None):
        # if _DEBUG: print ('... in ConcreteNode OpacityMapVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.transferFunction = transferFunction
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def transferFunction(self):
            return self.__transferFunction
        @transferFunction.setter
        def transferFunction(self, transferFunction=None):
            if  transferFunction is None:
                transferFunction = SFNode.DEFAULT_VALUE
            isValidSFNode(transferFunction)
            if not isinstance(transferFunction, object):
                raise RuntimeError(str(transferFunction) + ' does not have a valid node type object')
            self.__transferFunction = transferFunction

class OrientationChaser(_X3DChaserNode):
    """
    X3D element
    """
    __name__ = 'OrientationChaser'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#OrientationChaser'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#OrientationChaser'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('duration', 1, 'SFTime', 'initializeOnly'),
                          ('initialDestination', (0, 1, 0, 0), 'SFRotation', 'initializeOnly'),
                          ('initialValue', (0, 1, 0, 0), 'SFRotation', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 duration=1,
                 initialDestination=(0, 1, 0, 0),
                 initialValue=(0, 1, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode OrientationChaser __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.duration = duration
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def duration(self):
            return self.__duration
        @duration.setter
        def duration(self, duration=None):
            if  duration is None:
                duration = SFTime.DEFAULT_VALUE
            isValidSFTime(duration)
            self.__duration = duration
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFRotation.DEFAULT_VALUE
            isValidSFRotation(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFRotation.DEFAULT_VALUE
            isValidSFRotation(initialValue)
            self.__initialValue = initialValue

class OrientationDamper(_X3DDamperNode):
    """
    X3D element
    """
    __name__ = 'OrientationDamper'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#OrientationDamper'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#OrientationDamper'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('initialDestination', (0, 1, 0, 0), 'SFRotation', 'initializeOnly'),
                          ('initialValue', (0, 1, 0, 0), 'SFRotation', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tau', 0.3, 'SFTime', 'inputOutput'),
                          ('tolerance', -1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 initialDestination=(0, 1, 0, 0),
                 initialValue=(0, 1, 0, 0),
                 order=3,
                 tau=0.3,
                 tolerance=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode OrientationDamper __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        self.order = order
        self.tau = tau
        self.tolerance = tolerance
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFRotation.DEFAULT_VALUE
            isValidSFRotation(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFRotation.DEFAULT_VALUE
            isValidSFRotation(initialValue)
            self.__initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tau(self):
            return self.__tau
        @tau.setter
        def tau(self, tau=None):
            if  tau is None:
                tau = SFTime.DEFAULT_VALUE
            isValidSFTime(tau)
            self.__tau = tau
        @property # - - - - - - - - - - - - -
        def tolerance(self):
            return self.__tolerance
        @tolerance.setter
        def tolerance(self, tolerance=None):
            if  tolerance is None:
                tolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tolerance)
            self.__tolerance = tolerance

class OrientationInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'OrientationInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#OrientationInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#OrientationInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFRotation', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode OrientationInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFRotation.DEFAULT_VALUE
            isValidMFRotation(keyValue)
            self.__keyValue = keyValue

class OrthoViewpoint(_X3DViewpointNode):
    """
    X3D element
    """
    __name__ = 'OrthoViewpoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#OrthoViewpoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#OrthoViewpoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('centerOfRotation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('fieldOfView', [-1, -1, 1, 1], 'MFFloat', 'inputOutput'),
                          ('jump', True, 'SFBool', 'inputOutput'),
                          ('orientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('position', (0, 0, 10), 'SFVec3f', 'inputOutput'),
                          ('retainUserOffsets', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 centerOfRotation=(0, 0, 0),
                 description='',
                 fieldOfView=[-1, -1, 1, 1],
                 jump=True,
                 orientation=(0, 0, 1, 0),
                 position=(0, 0, 10),
                 retainUserOffsets=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode OrthoViewpoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.centerOfRotation = centerOfRotation
        self.description = description
        self.fieldOfView = fieldOfView
        self.jump = jump
        self.orientation = orientation
        self.position = position
        self.retainUserOffsets = retainUserOffsets
        @property # - - - - - - - - - - - - -
        def centerOfRotation(self):
            return self.__centerOfRotation
        @centerOfRotation.setter
        def centerOfRotation(self, centerOfRotation=None):
            if  centerOfRotation is None:
                centerOfRotation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(centerOfRotation)
            self.__centerOfRotation = centerOfRotation
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def fieldOfView(self):
            return self.__fieldOfView
        @fieldOfView.setter
        def fieldOfView(self, fieldOfView=None):
            if  fieldOfView is None:
                fieldOfView = MFFloat.DEFAULT_VALUE
            isValidMFFloat(fieldOfView)
            self.__fieldOfView = fieldOfView
        @property # - - - - - - - - - - - - -
        def jump(self):
            return self.__jump
        @jump.setter
        def jump(self, jump=None):
            if  jump is None:
                jump = SFBool.DEFAULT_VALUE
            isValidSFBool(jump)
            self.__jump = jump
        @property # - - - - - - - - - - - - -
        def orientation(self):
            return self.__orientation
        @orientation.setter
        def orientation(self, orientation=None):
            if  orientation is None:
                orientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(orientation)
            self.__orientation = orientation
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def retainUserOffsets(self):
            return self.__retainUserOffsets
        @retainUserOffsets.setter
        def retainUserOffsets(self, retainUserOffsets=None):
            if  retainUserOffsets is None:
                retainUserOffsets = SFBool.DEFAULT_VALUE
            isValidSFBool(retainUserOffsets)
            self.__retainUserOffsets = retainUserOffsets

class PackagedShader(_X3DShaderNode):
    """
    PackagedShader can contain field declarations, but no CDATA section of plain-text source code.
    """
    __name__ = 'PackagedShader'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#PackagedShader'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PackagedShader'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('language', '', 'SFString', 'initializeOnly'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('field', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 language='',
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 field=list()):
        # if _DEBUG: print ('... in ConcreteNode PackagedShader __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.language = language
        self.url = url
        self.field = field
        @property # - - - - - - - - - - - - -
        def language(self):
            return self.__language
        @language.setter
        def language(self, language=None):
            if  language is None:
                language = SFString.DEFAULT_VALUE
            isValidSFString(language)
            self.__language = language
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def field(self):
            return self.__field
        @field.setter
        def field(self, field=None):
            if  field is None:
                field = MFNode.DEFAULT_VALUE
            isValidMFNode(field)
            self.__field = field

class ParticleSystem(_X3DShapeNode):
    """
    X3D element
    """
    __name__ = 'ParticleSystem'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#ParticleSystem'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ParticleSystem'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('colorKey', list(), 'MFFloat', 'initializeOnly'),
                          ('createParticles', True, 'SFBool', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('geometryType', 'QUAD', 'SFString', 'initializeOnly'),
                          ('lifetimeVariation', 0.25, 'SFFloat', 'inputOutput'),
                          ('maxParticles', 200, 'SFInt32', 'inputOutput'),
                          ('particleLifetime', 5, 'SFFloat', 'inputOutput'),
                          ('particleSize', (0.02, 0.02), 'SFVec2f', 'inputOutput'),
                          ('texCoordKey', list(), 'MFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('appearance', None, 'SFNode', 'inputOutput'),
                          ('colorRamp', None, 'SFNode', 'initializeOnly'),
                          ('emitter', None, 'SFNode', 'initializeOnly'),
                          ('geometry', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('texCoordRamp', None, 'SFNode', 'initializeOnly'),
                          ('physics', list(), 'MFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 colorKey=list(),
                 createParticles=True,
                 enabled=True,
                 geometryType='QUAD',
                 lifetimeVariation=0.25,
                 maxParticles=200,
                 particleLifetime=5,
                 particleSize=(0.02, 0.02),
                 texCoordKey=list(),
                 USE='',
                 class_='',
                 appearance=None,
                 colorRamp=None,
                 emitter=None,
                 geometry=None,
                 IS=None,
                 metadata=None,
                 texCoordRamp=None,
                 physics=list()):
        # if _DEBUG: print ('... in ConcreteNode ParticleSystem __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.colorKey = colorKey
        self.createParticles = createParticles
        self.enabled = enabled
        self.geometryType = geometryType
        self.lifetimeVariation = lifetimeVariation
        self.maxParticles = maxParticles
        self.particleLifetime = particleLifetime
        self.particleSize = particleSize
        self.texCoordKey = texCoordKey
        self.appearance = appearance
        self.colorRamp = colorRamp
        self.emitter = emitter
        self.geometry = geometry
        self.geometry = geometry
        self.texCoordRamp = texCoordRamp
        self.physics = physics
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def colorKey(self):
            return self.__colorKey
        @colorKey.setter
        def colorKey(self, colorKey=None):
            if  colorKey is None:
                colorKey = MFFloat.DEFAULT_VALUE
            isValidMFFloat(colorKey)
            self.__colorKey = colorKey
        @property # - - - - - - - - - - - - -
        def createParticles(self):
            return self.__createParticles
        @createParticles.setter
        def createParticles(self, createParticles=None):
            if  createParticles is None:
                createParticles = SFBool.DEFAULT_VALUE
            isValidSFBool(createParticles)
            self.__createParticles = createParticles
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def geometryType(self):
            return self.__geometryType
        @geometryType.setter
        def geometryType(self, geometryType=None):
            if  geometryType is None:
                geometryType = SFString.DEFAULT_VALUE
            isValidSFString(geometryType)
            self.__geometryType = geometryType
        @property # - - - - - - - - - - - - -
        def lifetimeVariation(self):
            return self.__lifetimeVariation
        @lifetimeVariation.setter
        def lifetimeVariation(self, lifetimeVariation=None):
            if  lifetimeVariation is None:
                lifetimeVariation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(lifetimeVariation)
            self.__lifetimeVariation = lifetimeVariation
        @property # - - - - - - - - - - - - -
        def maxParticles(self):
            return self.__maxParticles
        @maxParticles.setter
        def maxParticles(self, maxParticles=None):
            if  maxParticles is None:
                maxParticles = SFInt32.DEFAULT_VALUE
            isValidSFInt32(maxParticles)
            self.__maxParticles = maxParticles
        @property # - - - - - - - - - - - - -
        def particleLifetime(self):
            return self.__particleLifetime
        @particleLifetime.setter
        def particleLifetime(self, particleLifetime=None):
            if  particleLifetime is None:
                particleLifetime = SFFloat.DEFAULT_VALUE
            isValidSFFloat(particleLifetime)
            self.__particleLifetime = particleLifetime
        @property # - - - - - - - - - - - - -
        def particleSize(self):
            return self.__particleSize
        @particleSize.setter
        def particleSize(self, particleSize=None):
            if  particleSize is None:
                particleSize = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(particleSize)
            self.__particleSize = particleSize
        @property # - - - - - - - - - - - - -
        def texCoordKey(self):
            return self.__texCoordKey
        @texCoordKey.setter
        def texCoordKey(self, texCoordKey=None):
            if  texCoordKey is None:
                texCoordKey = MFFloat.DEFAULT_VALUE
            isValidMFFloat(texCoordKey)
            self.__texCoordKey = texCoordKey
        @property # - - - - - - - - - - - - -
        def appearance(self):
            return self.__appearance
        @appearance.setter
        def appearance(self, appearance=None):
            if  appearance is None:
                appearance = SFNode.DEFAULT_VALUE
            isValidSFNode(appearance)
            if not isinstance(appearance, object):
                raise RuntimeError(str(appearance) + ' does not have a valid node type object')
            self.__appearance = appearance
        @property # - - - - - - - - - - - - -
        def colorRamp(self):
            return self.__colorRamp
        @colorRamp.setter
        def colorRamp(self, colorRamp=None):
            if  colorRamp is None:
                colorRamp = SFNode.DEFAULT_VALUE
            isValidSFNode(colorRamp)
            if not isinstance(colorRamp, object):
                raise RuntimeError(str(colorRamp) + ' does not have a valid node type object')
            self.__colorRamp = colorRamp
        @property # - - - - - - - - - - - - -
        def emitter(self):
            return self.__emitter
        @emitter.setter
        def emitter(self, emitter=None):
            if  emitter is None:
                emitter = SFNode.DEFAULT_VALUE
            isValidSFNode(emitter)
            if not isinstance(emitter, object):
                raise RuntimeError(str(emitter) + ' does not have a valid node type object')
            self.__emitter = emitter
        @property # - - - - - - - - - - - - -
        def geometry(self):
            return self.__geometry
        @geometry.setter
        def geometry(self, geometry=None):
            if  geometry is None:
                geometry = SFNode.DEFAULT_VALUE
            isValidSFNode(geometry)
            if not isinstance(geometry, object):
                raise RuntimeError(str(geometry) + ' does not have a valid node type object')
            self.__geometry = geometry
        @property # - - - - - - - - - - - - -
        def geometry(self):
            return self.__geometry
        @geometry.setter
        def geometry(self, geometry=None):
            if  geometry is None:
                geometry = SFNode.DEFAULT_VALUE
            isValidSFNode(geometry)
            if not isinstance(geometry, object):
                raise RuntimeError(str(geometry) + ' does not have a valid node type object')
            self.__geometry = geometry
        @property # - - - - - - - - - - - - -
        def texCoordRamp(self):
            return self.__texCoordRamp
        @texCoordRamp.setter
        def texCoordRamp(self, texCoordRamp=None):
            if  texCoordRamp is None:
                texCoordRamp = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoordRamp)
            if not isinstance(texCoordRamp, object):
                raise RuntimeError(str(texCoordRamp) + ' does not have a valid node type object')
            self.__texCoordRamp = texCoordRamp
        @property # - - - - - - - - - - - - -
        def physics(self):
            return self.__physics
        @physics.setter
        def physics(self, physics=None):
            if  physics is None:
                physics = MFNode.DEFAULT_VALUE
            isValidMFNode(physics)
            self.__physics = physics

class PickableGroup(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'PickableGroup'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/picking.html#PickableGroup'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PickableGroup'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('objectType', ["ALL"], 'MFString', 'inputOutput'),
                          ('pickable', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 objectType=["ALL"],
                 pickable=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode PickableGroup __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.objectType = objectType
        self.pickable = pickable
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def objectType(self):
            return self.__objectType
        @objectType.setter
        def objectType(self, objectType=None):
            if  objectType is None:
                objectType = MFString.DEFAULT_VALUE
            isValidMFString(objectType)
            self.__objectType = objectType
        @property # - - - - - - - - - - - - -
        def pickable(self):
            return self.__pickable
        @pickable.setter
        def pickable(self, pickable=None):
            if  pickable is None:
                pickable = SFBool.DEFAULT_VALUE
            isValidSFBool(pickable)
            self.__pickable = pickable
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class PixelTexture(_X3DTexture2DNode):
    """
    X3D element
    """
    __name__ = 'PixelTexture'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#PixelTexture'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PixelTexture'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('image', [0, 0, 0], 'SFImage', 'inputOutput'),
                          ('repeatS', True, 'SFBool', 'initializeOnly'),
                          ('repeatT', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 image=[0, 0, 0],
                 repeatS=True,
                 repeatT=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None):
        # if _DEBUG: print ('... in ConcreteNode PixelTexture __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.image = image
        self.repeatS = repeatS
        self.repeatT = repeatT
        self.textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def image(self):
            return self.__image
        @image.setter
        def image(self, image=None):
            if  image is None:
                image = SFImage.DEFAULT_VALUE
            isValidSFImage(image)
            self.__image = image
        @property # - - - - - - - - - - - - -
        def repeatS(self):
            return self.__repeatS
        @repeatS.setter
        def repeatS(self, repeatS=None):
            if  repeatS is None:
                repeatS = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatS)
            self.__repeatS = repeatS
        @property # - - - - - - - - - - - - -
        def repeatT(self):
            return self.__repeatT
        @repeatT.setter
        def repeatT(self, repeatT=None):
            if  repeatT is None:
                repeatT = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatT)
            self.__repeatT = repeatT
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties

class PixelTexture3D(_X3DTexture3DNode):
    """
    X3D element
    """
    __name__ = 'PixelTexture3D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#PixelTexture3D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PixelTexture3D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('image', [0, 0, 0, 0], 'MFInt32', 'inputOutput'),
                          ('repeatR', False, 'SFBool', 'initializeOnly'),
                          ('repeatS', False, 'SFBool', 'initializeOnly'),
                          ('repeatT', False, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('textureProperties', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 image=[0, 0, 0, 0],
                 repeatR=False,
                 repeatS=False,
                 repeatT=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 textureProperties=None):
        # if _DEBUG: print ('... in ConcreteNode PixelTexture3D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.image = image
        self.repeatR = repeatR
        self.repeatS = repeatS
        self.repeatT = repeatT
        self.textureProperties = textureProperties
        @property # - - - - - - - - - - - - -
        def image(self):
            return self.__image
        @image.setter
        def image(self, image=None):
            if  image is None:
                image = MFInt32.DEFAULT_VALUE
            isValidMFInt32(image)
            self.__image = image
        @property # - - - - - - - - - - - - -
        def repeatR(self):
            return self.__repeatR
        @repeatR.setter
        def repeatR(self, repeatR=None):
            if  repeatR is None:
                repeatR = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatR)
            self.__repeatR = repeatR
        @property # - - - - - - - - - - - - -
        def repeatS(self):
            return self.__repeatS
        @repeatS.setter
        def repeatS(self, repeatS=None):
            if  repeatS is None:
                repeatS = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatS)
            self.__repeatS = repeatS
        @property # - - - - - - - - - - - - -
        def repeatT(self):
            return self.__repeatT
        @repeatT.setter
        def repeatT(self, repeatT=None):
            if  repeatT is None:
                repeatT = SFBool.DEFAULT_VALUE
            isValidSFBool(repeatT)
            self.__repeatT = repeatT
        @property # - - - - - - - - - - - - -
        def textureProperties(self):
            return self.__textureProperties
        @textureProperties.setter
        def textureProperties(self, textureProperties=None):
            if  textureProperties is None:
                textureProperties = SFNode.DEFAULT_VALUE
            isValidSFNode(textureProperties)
            if not isinstance(textureProperties, object):
                raise RuntimeError(str(textureProperties) + ' does not have a valid node type object')
            self.__textureProperties = textureProperties

class PlaneSensor(_X3DDragSensorNode):
    """
    X3D element
    """
    __name__ = 'PlaneSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/pointingsensor.html#PlaneSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PlaneSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('autoOffset', True, 'SFBool', 'inputOutput'),
                          ('axisRotation', (0, 1, 0, 0), 'SFRotation', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('maxPosition', (-1, -1), 'SFVec2f', 'inputOutput'),
                          ('minPosition', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('offset', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 autoOffset=True,
                 axisRotation=(0, 1, 0, 0),
                 description='',
                 enabled=True,
                 maxPosition=(-1, -1),
                 minPosition=(0, 0),
                 offset=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PlaneSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.autoOffset = autoOffset
        self.axisRotation = axisRotation
        self.description = description
        self.enabled = enabled
        self.maxPosition = maxPosition
        self.minPosition = minPosition
        self.offset = offset
        @property # - - - - - - - - - - - - -
        def autoOffset(self):
            return self.__autoOffset
        @autoOffset.setter
        def autoOffset(self, autoOffset=None):
            if  autoOffset is None:
                autoOffset = SFBool.DEFAULT_VALUE
            isValidSFBool(autoOffset)
            self.__autoOffset = autoOffset
        @property # - - - - - - - - - - - - -
        def axisRotation(self):
            return self.__axisRotation
        @axisRotation.setter
        def axisRotation(self, axisRotation=None):
            if  axisRotation is None:
                axisRotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(axisRotation)
            self.__axisRotation = axisRotation
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def maxPosition(self):
            return self.__maxPosition
        @maxPosition.setter
        def maxPosition(self, maxPosition=None):
            if  maxPosition is None:
                maxPosition = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(maxPosition)
            self.__maxPosition = maxPosition
        @property # - - - - - - - - - - - - -
        def minPosition(self):
            return self.__minPosition
        @minPosition.setter
        def minPosition(self, minPosition=None):
            if  minPosition is None:
                minPosition = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(minPosition)
            self.__minPosition = minPosition
        @property # - - - - - - - - - - - - -
        def offset(self):
            return self.__offset
        @offset.setter
        def offset(self, offset=None):
            if  offset is None:
                offset = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(offset)
            self.__offset = offset

class PointEmitter(_X3DParticleEmitterNode):
    """
    X3D element
    """
    __name__ = 'PointEmitter'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#PointEmitter'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PointEmitter'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('direction', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('mass', 0, 'SFFloat', 'inputOutput'),
                          ('position', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('speed', 0, 'SFFloat', 'inputOutput'),
                          ('surfaceArea', 0, 'SFFloat', 'initializeOnly'),
                          ('variation', 0.25, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 direction=(0, 1, 0),
                 mass=0,
                 position=(0, 0, 0),
                 speed=0,
                 surfaceArea=0,
                 variation=0.25,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PointEmitter __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.direction = direction
        self.mass = mass
        self.position = position
        self.speed = speed
        self.surfaceArea = surfaceArea
        self.variation = variation
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def surfaceArea(self):
            return self.__surfaceArea
        @surfaceArea.setter
        def surfaceArea(self, surfaceArea=None):
            if  surfaceArea is None:
                surfaceArea = SFFloat.DEFAULT_VALUE
            isValidSFFloat(surfaceArea)
            self.__surfaceArea = surfaceArea
        @property # - - - - - - - - - - - - -
        def variation(self):
            return self.__variation
        @variation.setter
        def variation(self, variation=None):
            if  variation is None:
                variation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(variation)
            self.__variation = variation

class PointLight(_X3DLightNode):
    """
    Linear attenuation may occur at level 2, full support at level 3.
    """
    __name__ = 'PointLight'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/lighting.html#PointLight'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PointLight'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ambientIntensity', 0, 'SFFloat', 'inputOutput'),
                          ('attenuation', (1, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('color', (1, 1, 1), 'SFColor', 'inputOutput'),
                          ('global_', True, 'SFBool', 'inputOutput'),
                          ('intensity', 1, 'SFFloat', 'inputOutput'),
                          ('location', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('on', True, 'SFBool', 'inputOutput'),
                          ('radius', 100, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ambientIntensity=0,
                 attenuation=(1, 0, 0),
                 color=(1, 1, 1),
                 global_=True,
                 intensity=1,
                 location=(0, 0, 0),
                 on=True,
                 radius=100,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PointLight __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ambientIntensity = ambientIntensity
        self.attenuation = attenuation
        self.color = color
        self.global_ = global_
        self.intensity = intensity
        self.location = location
        self.on = on
        self.radius = radius
        @property # - - - - - - - - - - - - -
        def ambientIntensity(self):
            return self.__ambientIntensity
        @ambientIntensity.setter
        def ambientIntensity(self, ambientIntensity=None):
            if  ambientIntensity is None:
                ambientIntensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(ambientIntensity)
            self.__ambientIntensity = ambientIntensity
        @property # - - - - - - - - - - - - -
        def attenuation(self):
            return self.__attenuation
        @attenuation.setter
        def attenuation(self, attenuation=None):
            if  attenuation is None:
                attenuation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(attenuation)
            self.__attenuation = attenuation
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFColor.DEFAULT_VALUE
            isValidSFColor(color)
            self.__color = color
        @property # - - - - - - - - - - - - -
        def global_(self):
            return self.__global_
        @global_.setter
        def global_(self, global_=None):
            if  global_ is None:
                global_ = SFBool.DEFAULT_VALUE
            isValidSFBool(global_)
            self.__global_ = global_
        @property # - - - - - - - - - - - - -
        def intensity(self):
            return self.__intensity
        @intensity.setter
        def intensity(self, intensity=None):
            if  intensity is None:
                intensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(intensity)
            self.__intensity = intensity
        @property # - - - - - - - - - - - - -
        def location(self):
            return self.__location
        @location.setter
        def location(self, location=None):
            if  location is None:
                location = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(location)
            self.__location = location
        @property # - - - - - - - - - - - - -
        def on(self):
            return self.__on
        @on.setter
        def on(self, on=None):
            if  on is None:
                on = SFBool.DEFAULT_VALUE
            isValidSFBool(on)
            self.__on = on
        @property # - - - - - - - - - - - - -
        def radius(self):
            return self.__radius
        @radius.setter
        def radius(self, radius=None):
            if  radius is None:
                radius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(radius)
            self.__radius = radius

class PointPickSensor(_X3DPickSensorNode):
    """
    X3D element
    """
    __name__ = 'PointPickSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/picking.html#PointPickSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PointPickSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('intersectionType', 'BOUNDS', 'SFString', 'initializeOnly'),
                          ('matchCriterion', 'MATCH_ANY', 'SFString', 'inputOutput'),
                          ('objectType', ["ALL"], 'MFString', 'inputOutput'),
                          ('sortOrder', 'CLOSEST', 'SFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('pickingGeometry', None, 'SFNode', 'inputOutput'),
                          ('pickTarget', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 intersectionType='BOUNDS',
                 matchCriterion='MATCH_ANY',
                 objectType=["ALL"],
                 sortOrder='CLOSEST',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 pickingGeometry=None,
                 pickTarget=list()):
        # if _DEBUG: print ('... in ConcreteNode PointPickSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.intersectionType = intersectionType
        self.matchCriterion = matchCriterion
        self.objectType = objectType
        self.sortOrder = sortOrder
        self.pickingGeometry = pickingGeometry
        self.pickTarget = pickTarget
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def intersectionType(self):
            return self.__intersectionType
        @intersectionType.setter
        def intersectionType(self, intersectionType=None):
            if  intersectionType is None:
                intersectionType = SFString.DEFAULT_VALUE
            isValidSFString(intersectionType)
            self.__intersectionType = intersectionType
        @property # - - - - - - - - - - - - -
        def matchCriterion(self):
            return self.__matchCriterion
        @matchCriterion.setter
        def matchCriterion(self, matchCriterion=None):
            if  matchCriterion is None:
                matchCriterion = SFString.DEFAULT_VALUE
            isValidSFString(matchCriterion)
            self.__matchCriterion = matchCriterion
        @property # - - - - - - - - - - - - -
        def objectType(self):
            return self.__objectType
        @objectType.setter
        def objectType(self, objectType=None):
            if  objectType is None:
                objectType = MFString.DEFAULT_VALUE
            isValidMFString(objectType)
            self.__objectType = objectType
        @property # - - - - - - - - - - - - -
        def sortOrder(self):
            return self.__sortOrder
        @sortOrder.setter
        def sortOrder(self, sortOrder=None):
            if  sortOrder is None:
                sortOrder = SFString.DEFAULT_VALUE
            isValidSFString(sortOrder)
            self.__sortOrder = sortOrder
        @property # - - - - - - - - - - - - -
        def pickingGeometry(self):
            return self.__pickingGeometry
        @pickingGeometry.setter
        def pickingGeometry(self, pickingGeometry=None):
            if  pickingGeometry is None:
                pickingGeometry = SFNode.DEFAULT_VALUE
            isValidSFNode(pickingGeometry)
            if not isinstance(pickingGeometry, object):
                raise RuntimeError(str(pickingGeometry) + ' does not have a valid node type object')
            self.__pickingGeometry = pickingGeometry
        @property # - - - - - - - - - - - - -
        def pickTarget(self):
            return self.__pickTarget
        @pickTarget.setter
        def pickTarget(self, pickTarget=None):
            if  pickTarget is None:
                pickTarget = MFNode.DEFAULT_VALUE
            isValidMFNode(pickTarget)
            self.__pickTarget = pickTarget

class PointProperties(_X3DAppearanceChildNode):
    """
    X3D element
    """
    __name__ = 'PointProperties'
    specificationUrl = 'https://github.com/Web3DConsortium/X3D/blob/master/ISO-IEC19775/ISO-IEC19775-1/ISO-IEC19775-1v4.0/ISO-IEC19775-1v4-WD1/Part01/components/shape.html'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PointProperties'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('colorMode', 'TEXTURE_AND_POINT_COLOR', 'SFString', 'inputOutput'),
                          ('pointSizeAttenuation', [1, 0, 0], 'MFFloat', 'inputOutput'),
                          ('pointSizeMaxValue', 1, 'SFFloat', 'inputOutput'),
                          ('pointSizeMinValue', 1, 'SFFloat', 'inputOutput'),
                          ('pointSizeScaleFactor', 1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 colorMode='TEXTURE_AND_POINT_COLOR',
                 pointSizeAttenuation=[1, 0, 0],
                 pointSizeMaxValue=1,
                 pointSizeMinValue=1,
                 pointSizeScaleFactor=1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PointProperties __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.colorMode = colorMode
        self.pointSizeAttenuation = pointSizeAttenuation
        self.pointSizeMaxValue = pointSizeMaxValue
        self.pointSizeMinValue = pointSizeMinValue
        self.pointSizeScaleFactor = pointSizeScaleFactor
        @property # - - - - - - - - - - - - -
        def colorMode(self):
            return self.__colorMode
        @colorMode.setter
        def colorMode(self, colorMode=None):
            if  colorMode is None:
                colorMode = SFString.DEFAULT_VALUE
            isValidSFString(colorMode)
            self.__colorMode = colorMode
        @property # - - - - - - - - - - - - -
        def pointSizeAttenuation(self):
            return self.__pointSizeAttenuation
        @pointSizeAttenuation.setter
        def pointSizeAttenuation(self, pointSizeAttenuation=None):
            if  pointSizeAttenuation is None:
                pointSizeAttenuation = MFFloat.DEFAULT_VALUE
            isValidMFFloat(pointSizeAttenuation)
            self.__pointSizeAttenuation = pointSizeAttenuation
        @property # - - - - - - - - - - - - -
        def pointSizeMaxValue(self):
            return self.__pointSizeMaxValue
        @pointSizeMaxValue.setter
        def pointSizeMaxValue(self, pointSizeMaxValue=None):
            if  pointSizeMaxValue is None:
                pointSizeMaxValue = SFFloat.DEFAULT_VALUE
            isValidSFFloat(pointSizeMaxValue)
            self.__pointSizeMaxValue = pointSizeMaxValue
        @property # - - - - - - - - - - - - -
        def pointSizeMinValue(self):
            return self.__pointSizeMinValue
        @pointSizeMinValue.setter
        def pointSizeMinValue(self, pointSizeMinValue=None):
            if  pointSizeMinValue is None:
                pointSizeMinValue = SFFloat.DEFAULT_VALUE
            isValidSFFloat(pointSizeMinValue)
            self.__pointSizeMinValue = pointSizeMinValue
        @property # - - - - - - - - - - - - -
        def pointSizeScaleFactor(self):
            return self.__pointSizeScaleFactor
        @pointSizeScaleFactor.setter
        def pointSizeScaleFactor(self, pointSizeScaleFactor=None):
            if  pointSizeScaleFactor is None:
                pointSizeScaleFactor = SFFloat.DEFAULT_VALUE
            isValidSFFloat(pointSizeScaleFactor)
            self.__pointSizeScaleFactor = pointSizeScaleFactor

class PointSet(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'PointSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#PointSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PointSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode PointSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class Polyline2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Polyline2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#Polyline2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Polyline2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('lineSegments', (list()), 'MFVec2f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 lineSegments=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Polyline2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.lineSegments = lineSegments
        @property # - - - - - - - - - - - - -
        def lineSegments(self):
            return self.__lineSegments
        @lineSegments.setter
        def lineSegments(self, lineSegments=None):
            if  lineSegments is None:
                lineSegments = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(lineSegments)
            self.__lineSegments = lineSegments

class PolylineEmitter(_X3DParticleEmitterNode):
    """
    X3D element
    """
    __name__ = 'PolylineEmitter'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#PolylineEmitter'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PolylineEmitter'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('coordIndex', [-1], 'MFInt32', 'initializeOnly'),
                          ('direction', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('mass', 0, 'SFFloat', 'inputOutput'),
                          ('speed', 0, 'SFFloat', 'inputOutput'),
                          ('surfaceArea', 0, 'SFFloat', 'initializeOnly'),
                          ('variation', 0.25, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 coordIndex=[-1],
                 direction=(0, 1, 0),
                 mass=0,
                 speed=0,
                 surfaceArea=0,
                 variation=0.25,
                 USE='',
                 class_='',
                 coord=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PolylineEmitter __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.coordIndex = coordIndex
        self.direction = direction
        self.mass = mass
        self.speed = speed
        self.surfaceArea = surfaceArea
        self.variation = variation
        self.coord = coord
        @property # - - - - - - - - - - - - -
        def coordIndex(self):
            return self.__coordIndex
        @coordIndex.setter
        def coordIndex(self, coordIndex=None):
            if  coordIndex is None:
                coordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(coordIndex)
            self.__coordIndex = coordIndex
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def surfaceArea(self):
            return self.__surfaceArea
        @surfaceArea.setter
        def surfaceArea(self, surfaceArea=None):
            if  surfaceArea is None:
                surfaceArea = SFFloat.DEFAULT_VALUE
            isValidSFFloat(surfaceArea)
            self.__surfaceArea = surfaceArea
        @property # - - - - - - - - - - - - -
        def variation(self):
            return self.__variation
        @variation.setter
        def variation(self, variation=None):
            if  variation is None:
                variation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(variation)
            self.__variation = variation
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord

class Polypoint2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Polypoint2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#Polypoint2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Polypoint2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('point', (list()), 'MFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 point=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Polypoint2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.point = point
        @property # - - - - - - - - - - - - -
        def point(self):
            return self.__point
        @point.setter
        def point(self, point=None):
            if  point is None:
                point = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(point)
            self.__point = point

class PositionChaser(_X3DChaserNode):
    """
    X3D element
    """
    __name__ = 'PositionChaser'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#PositionChaser'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PositionChaser'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('duration', 1, 'SFTime', 'initializeOnly'),
                          ('initialDestination', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('initialValue', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 duration=1,
                 initialDestination=(0, 0, 0),
                 initialValue=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PositionChaser __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.duration = duration
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def duration(self):
            return self.__duration
        @duration.setter
        def duration(self, duration=None):
            if  duration is None:
                duration = SFTime.DEFAULT_VALUE
            isValidSFTime(duration)
            self.__duration = duration
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(initialValue)
            self.__initialValue = initialValue

class PositionChaser2D(_X3DChaserNode):
    """
    X3D element
    """
    __name__ = 'PositionChaser2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#PositionChaser2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PositionChaser2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('duration', 1, 'SFTime', 'initializeOnly'),
                          ('initialDestination', (0, 0), 'SFVec2f', 'initializeOnly'),
                          ('initialValue', (0, 0), 'SFVec2f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 duration=1,
                 initialDestination=(0, 0),
                 initialValue=(0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PositionChaser2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.duration = duration
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def duration(self):
            return self.__duration
        @duration.setter
        def duration(self, duration=None):
            if  duration is None:
                duration = SFTime.DEFAULT_VALUE
            isValidSFTime(duration)
            self.__duration = duration
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(initialValue)
            self.__initialValue = initialValue

class PositionDamper(_X3DDamperNode):
    """
    X3D element
    """
    __name__ = 'PositionDamper'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#PositionDamper'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PositionDamper'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('initialDestination', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('initialValue', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tau', 0.3, 'SFTime', 'inputOutput'),
                          ('tolerance', -1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 initialDestination=(0, 0, 0),
                 initialValue=(0, 0, 0),
                 order=3,
                 tau=0.3,
                 tolerance=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PositionDamper __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        self.order = order
        self.tau = tau
        self.tolerance = tolerance
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(initialValue)
            self.__initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tau(self):
            return self.__tau
        @tau.setter
        def tau(self, tau=None):
            if  tau is None:
                tau = SFTime.DEFAULT_VALUE
            isValidSFTime(tau)
            self.__tau = tau
        @property # - - - - - - - - - - - - -
        def tolerance(self):
            return self.__tolerance
        @tolerance.setter
        def tolerance(self, tolerance=None):
            if  tolerance is None:
                tolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tolerance)
            self.__tolerance = tolerance

class PositionDamper2D(_X3DDamperNode):
    """
    X3D element
    """
    __name__ = 'PositionDamper2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#PositionDamper2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PositionDamper2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('initialDestination', (0, 0), 'SFVec2f', 'initializeOnly'),
                          ('initialValue', (0, 0), 'SFVec2f', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tau', 0.3, 'SFTime', 'inputOutput'),
                          ('tolerance', -1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 initialDestination=(0, 0),
                 initialValue=(0, 0),
                 order=3,
                 tau=0.3,
                 tolerance=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PositionDamper2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        self.order = order
        self.tau = tau
        self.tolerance = tolerance
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(initialValue)
            self.__initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tau(self):
            return self.__tau
        @tau.setter
        def tau(self, tau=None):
            if  tau is None:
                tau = SFTime.DEFAULT_VALUE
            isValidSFTime(tau)
            self.__tau = tau
        @property # - - - - - - - - - - - - -
        def tolerance(self):
            return self.__tolerance
        @tolerance.setter
        def tolerance(self, tolerance=None):
            if  tolerance is None:
                tolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tolerance)
            self.__tolerance = tolerance

class PositionInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'PositionInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#PositionInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PositionInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PositionInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(keyValue)
            self.__keyValue = keyValue

class PositionInterpolator2D(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'PositionInterpolator2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#PositionInterpolator2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PositionInterpolator2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode PositionInterpolator2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(keyValue)
            self.__keyValue = keyValue

class PrimitivePickSensor(_X3DPickSensorNode):
    """
    If a non-uniform scale is applied to the pick sensor, correct results may require level 3 support.
    """
    __name__ = 'PrimitivePickSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/picking.html#PrimitivePickSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#PrimitivePickSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('intersectionType', 'BOUNDS', 'SFString', 'initializeOnly'),
                          ('matchCriterion', 'MATCH_ANY', 'SFString', 'inputOutput'),
                          ('objectType', ["ALL"], 'MFString', 'inputOutput'),
                          ('sortOrder', 'CLOSEST', 'SFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('pickingGeometry', None, 'SFNode', 'inputOutput'),
                          ('pickTarget', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 intersectionType='BOUNDS',
                 matchCriterion='MATCH_ANY',
                 objectType=["ALL"],
                 sortOrder='CLOSEST',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 pickingGeometry=None,
                 pickTarget=list()):
        # if _DEBUG: print ('... in ConcreteNode PrimitivePickSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.intersectionType = intersectionType
        self.matchCriterion = matchCriterion
        self.objectType = objectType
        self.sortOrder = sortOrder
        self.pickingGeometry = pickingGeometry
        self.pickTarget = pickTarget
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def intersectionType(self):
            return self.__intersectionType
        @intersectionType.setter
        def intersectionType(self, intersectionType=None):
            if  intersectionType is None:
                intersectionType = SFString.DEFAULT_VALUE
            isValidSFString(intersectionType)
            self.__intersectionType = intersectionType
        @property # - - - - - - - - - - - - -
        def matchCriterion(self):
            return self.__matchCriterion
        @matchCriterion.setter
        def matchCriterion(self, matchCriterion=None):
            if  matchCriterion is None:
                matchCriterion = SFString.DEFAULT_VALUE
            isValidSFString(matchCriterion)
            self.__matchCriterion = matchCriterion
        @property # - - - - - - - - - - - - -
        def objectType(self):
            return self.__objectType
        @objectType.setter
        def objectType(self, objectType=None):
            if  objectType is None:
                objectType = MFString.DEFAULT_VALUE
            isValidMFString(objectType)
            self.__objectType = objectType
        @property # - - - - - - - - - - - - -
        def sortOrder(self):
            return self.__sortOrder
        @sortOrder.setter
        def sortOrder(self, sortOrder=None):
            if  sortOrder is None:
                sortOrder = SFString.DEFAULT_VALUE
            isValidSFString(sortOrder)
            self.__sortOrder = sortOrder
        @property # - - - - - - - - - - - - -
        def pickingGeometry(self):
            return self.__pickingGeometry
        @pickingGeometry.setter
        def pickingGeometry(self, pickingGeometry=None):
            if  pickingGeometry is None:
                pickingGeometry = SFNode.DEFAULT_VALUE
            isValidSFNode(pickingGeometry)
            if not isinstance(pickingGeometry, object):
                raise RuntimeError(str(pickingGeometry) + ' does not have a valid node type object')
            self.__pickingGeometry = pickingGeometry
        @property # - - - - - - - - - - - - -
        def pickTarget(self):
            return self.__pickTarget
        @pickTarget.setter
        def pickTarget(self, pickTarget=None):
            if  pickTarget is None:
                pickTarget = MFNode.DEFAULT_VALUE
            isValidMFNode(pickTarget)
            self.__pickTarget = pickTarget

class ProgramShader(_X3DShaderNode):
    """
    ProgramShader contains no field declarations and no plain-text source code.
    """
    __name__ = 'ProgramShader'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#ProgramShader'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ProgramShader'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('language', '', 'SFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('programs', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 language='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 programs=list()):
        # if _DEBUG: print ('... in ConcreteNode ProgramShader __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.language = language
        self.programs = programs
        @property # - - - - - - - - - - - - -
        def language(self):
            return self.__language
        @language.setter
        def language(self, language=None):
            if  language is None:
                language = SFString.DEFAULT_VALUE
            isValidSFString(language)
            self.__language = language
        @property # - - - - - - - - - - - - -
        def programs(self):
            return self.__programs
        @programs.setter
        def programs(self, programs=None):
            if  programs is None:
                programs = MFNode.DEFAULT_VALUE
            isValidMFNode(programs)
            self.__programs = programs

class ProjectionVolumeStyle(_X3DVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'ProjectionVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#ProjectionVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ProjectionVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('intensityThreshold', 0, 'SFFloat', 'inputOutput'),
                          ('type', 'MAX', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 intensityThreshold=0,
                 type='MAX',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ProjectionVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.intensityThreshold = intensityThreshold
        self.type = type
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def intensityThreshold(self):
            return self.__intensityThreshold
        @intensityThreshold.setter
        def intensityThreshold(self, intensityThreshold=None):
            if  intensityThreshold is None:
                intensityThreshold = SFFloat.DEFAULT_VALUE
            isValidSFFloat(intensityThreshold)
            self.__intensityThreshold = intensityThreshold
        @property # - - - - - - - - - - - - -
        def type(self):
            return self.__type
        @type.setter
        def type(self, type=None):
            if  type is None:
                type = SFString.DEFAULT_VALUE
            isValidSFString(type)
            self.__type = type

class ProtoInstance(_X3DPrototypeInstance):
    """
    ProtoInstance can override field default values via fieldValue initializations. Non-recursive nested ProtoInstance and ProtoDeclare statements are allowed within a ProtoDeclare.
    """
    __name__ = 'ProtoInstance'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19776-1/V3.3/Part01/concepts.html#ProtoInstanceAndFieldValueStatement'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ProtoInstance'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('name', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('fieldValue', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 name='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 fieldValue=list()):
        # if _DEBUG: print ('... in ConcreteNode ProtoInstance __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.name = name
        self.fieldValue = fieldValue
        @property # - - - - - - - - - - - - -
        def name(self):
            return self.__name
        @name.setter
        def name(self, name=None):
            if  name is None:
                name = SFString.DEFAULT_VALUE
            isValidSFString(name)
            self.__name = name
        @property # - - - - - - - - - - - - -
        def fieldValue(self):
            return self.__fieldValue
        @fieldValue.setter
        def fieldValue(self, fieldValue=None):
            if  fieldValue is None:
                fieldValue = MFNode.DEFAULT_VALUE
            isValidMFNode(fieldValue)
            self.__fieldValue = fieldValue

class ProximitySensor(_X3DEnvironmentalSensorNode):
    """
    X3D element
    """
    __name__ = 'ProximitySensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/envsensor.html#ProximitySensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ProximitySensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('size', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 center=(0, 0, 0),
                 enabled=True,
                 size=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ProximitySensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.center = center
        self.enabled = enabled
        self.size = size
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(size)
            self.__size = size

class QuadSet(_X3DComposedGeometryNode):
    """
    QuadSet is a geometry node that defines quadrilaterals.
    """
    __name__ = 'QuadSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/CADGeometry.html#QuadSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#QuadSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 normalPerVertex=True,
                 solid=True,
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode QuadSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class ReceiverPdu(_X3DNetworkSensorNode):
    """
    X3D element
    """
    __name__ = 'ReceiverPdu'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/dis.html#ReceiverPdu'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ReceiverPdu'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('address', 'localhost', 'SFString', 'inputOutput'),
                          ('applicationID', 0, 'SFInt32', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('entityID', 0, 'SFInt32', 'inputOutput'),
                          ('geoCoords', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('multicastRelayHost', '', 'SFString', 'inputOutput'),
                          ('multicastRelayPort', 0, 'SFInt32', 'inputOutput'),
                          ('networkMode', 'standAlone', 'SFString', 'inputOutput'),
                          ('port', 0, 'SFInt32', 'inputOutput'),
                          ('radioID', 0, 'SFInt32', 'inputOutput'),
                          ('readInterval', 0.1, 'SFTime', 'inputOutput'),
                          ('receivedPower', 0.0, 'SFFloat', 'inputOutput'),
                          ('receiverState', 0, 'SFInt32', 'inputOutput'),
                          ('rtpHeaderExpected', False, 'SFBool', 'initializeOnly'),
                          ('siteID', 0, 'SFInt32', 'inputOutput'),
                          ('transmitterApplicationID', 0, 'SFInt32', 'inputOutput'),
                          ('transmitterEntityID', 0, 'SFInt32', 'inputOutput'),
                          ('transmitterRadioID', 0, 'SFInt32', 'inputOutput'),
                          ('transmitterSiteID', 0, 'SFInt32', 'inputOutput'),
                          ('whichGeometry', 1, 'SFInt32', 'inputOutput'),
                          ('writeInterval', 1.0, 'SFTime', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 address='localhost',
                 applicationID=0,
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 enabled=True,
                 entityID=0,
                 geoCoords=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 multicastRelayHost='',
                 multicastRelayPort=0,
                 networkMode='standAlone',
                 port=0,
                 radioID=0,
                 readInterval=0.1,
                 receivedPower=0.0,
                 receiverState=0,
                 rtpHeaderExpected=False,
                 siteID=0,
                 transmitterApplicationID=0,
                 transmitterEntityID=0,
                 transmitterRadioID=0,
                 transmitterSiteID=0,
                 whichGeometry=1,
                 writeInterval=1.0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ReceiverPdu __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.address = address
        self.applicationID = applicationID
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.enabled = enabled
        self.entityID = entityID
        self.geoCoords = geoCoords
        self.geoSystem = geoSystem
        self.multicastRelayHost = multicastRelayHost
        self.multicastRelayPort = multicastRelayPort
        self.networkMode = networkMode
        self.port = port
        self.radioID = radioID
        self.readInterval = readInterval
        self.receivedPower = receivedPower
        self.receiverState = receiverState
        self.rtpHeaderExpected = rtpHeaderExpected
        self.siteID = siteID
        self.transmitterApplicationID = transmitterApplicationID
        self.transmitterEntityID = transmitterEntityID
        self.transmitterRadioID = transmitterRadioID
        self.transmitterSiteID = transmitterSiteID
        self.whichGeometry = whichGeometry
        self.writeInterval = writeInterval
        @property # - - - - - - - - - - - - -
        def address(self):
            return self.__address
        @address.setter
        def address(self, address=None):
            if  address is None:
                address = SFString.DEFAULT_VALUE
            isValidSFString(address)
            self.__address = address
        @property # - - - - - - - - - - - - -
        def applicationID(self):
            return self.__applicationID
        @applicationID.setter
        def applicationID(self, applicationID=None):
            if  applicationID is None:
                applicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(applicationID)
            self.__applicationID = applicationID
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def entityID(self):
            return self.__entityID
        @entityID.setter
        def entityID(self, entityID=None):
            if  entityID is None:
                entityID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityID)
            self.__entityID = entityID
        @property # - - - - - - - - - - - - -
        def geoCoords(self):
            return self.__geoCoords
        @geoCoords.setter
        def geoCoords(self, geoCoords=None):
            if  geoCoords is None:
                geoCoords = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCoords)
            self.__geoCoords = geoCoords
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def multicastRelayHost(self):
            return self.__multicastRelayHost
        @multicastRelayHost.setter
        def multicastRelayHost(self, multicastRelayHost=None):
            if  multicastRelayHost is None:
                multicastRelayHost = SFString.DEFAULT_VALUE
            isValidSFString(multicastRelayHost)
            self.__multicastRelayHost = multicastRelayHost
        @property # - - - - - - - - - - - - -
        def multicastRelayPort(self):
            return self.__multicastRelayPort
        @multicastRelayPort.setter
        def multicastRelayPort(self, multicastRelayPort=None):
            if  multicastRelayPort is None:
                multicastRelayPort = SFInt32.DEFAULT_VALUE
            isValidSFInt32(multicastRelayPort)
            self.__multicastRelayPort = multicastRelayPort
        @property # - - - - - - - - - - - - -
        def networkMode(self):
            return self.__networkMode
        @networkMode.setter
        def networkMode(self, networkMode=None):
            if  networkMode is None:
                networkMode = SFString.DEFAULT_VALUE
            isValidSFString(networkMode)
            self.__networkMode = networkMode
        @property # - - - - - - - - - - - - -
        def port(self):
            return self.__port
        @port.setter
        def port(self, port=None):
            if  port is None:
                port = SFInt32.DEFAULT_VALUE
            isValidSFInt32(port)
            self.__port = port
        @property # - - - - - - - - - - - - -
        def radioID(self):
            return self.__radioID
        @radioID.setter
        def radioID(self, radioID=None):
            if  radioID is None:
                radioID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioID)
            self.__radioID = radioID
        @property # - - - - - - - - - - - - -
        def readInterval(self):
            return self.__readInterval
        @readInterval.setter
        def readInterval(self, readInterval=None):
            if  readInterval is None:
                readInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(readInterval)
            self.__readInterval = readInterval
        @property # - - - - - - - - - - - - -
        def receivedPower(self):
            return self.__receivedPower
        @receivedPower.setter
        def receivedPower(self, receivedPower=None):
            if  receivedPower is None:
                receivedPower = SFFloat.DEFAULT_VALUE
            isValidSFFloat(receivedPower)
            self.__receivedPower = receivedPower
        @property # - - - - - - - - - - - - -
        def receiverState(self):
            return self.__receiverState
        @receiverState.setter
        def receiverState(self, receiverState=None):
            if  receiverState is None:
                receiverState = SFInt32.DEFAULT_VALUE
            isValidSFInt32(receiverState)
            self.__receiverState = receiverState
        @property # - - - - - - - - - - - - -
        def rtpHeaderExpected(self):
            return self.__rtpHeaderExpected
        @rtpHeaderExpected.setter
        def rtpHeaderExpected(self, rtpHeaderExpected=None):
            if  rtpHeaderExpected is None:
                rtpHeaderExpected = SFBool.DEFAULT_VALUE
            isValidSFBool(rtpHeaderExpected)
            self.__rtpHeaderExpected = rtpHeaderExpected
        @property # - - - - - - - - - - - - -
        def siteID(self):
            return self.__siteID
        @siteID.setter
        def siteID(self, siteID=None):
            if  siteID is None:
                siteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(siteID)
            self.__siteID = siteID
        @property # - - - - - - - - - - - - -
        def transmitterApplicationID(self):
            return self.__transmitterApplicationID
        @transmitterApplicationID.setter
        def transmitterApplicationID(self, transmitterApplicationID=None):
            if  transmitterApplicationID is None:
                transmitterApplicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(transmitterApplicationID)
            self.__transmitterApplicationID = transmitterApplicationID
        @property # - - - - - - - - - - - - -
        def transmitterEntityID(self):
            return self.__transmitterEntityID
        @transmitterEntityID.setter
        def transmitterEntityID(self, transmitterEntityID=None):
            if  transmitterEntityID is None:
                transmitterEntityID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(transmitterEntityID)
            self.__transmitterEntityID = transmitterEntityID
        @property # - - - - - - - - - - - - -
        def transmitterRadioID(self):
            return self.__transmitterRadioID
        @transmitterRadioID.setter
        def transmitterRadioID(self, transmitterRadioID=None):
            if  transmitterRadioID is None:
                transmitterRadioID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(transmitterRadioID)
            self.__transmitterRadioID = transmitterRadioID
        @property # - - - - - - - - - - - - -
        def transmitterSiteID(self):
            return self.__transmitterSiteID
        @transmitterSiteID.setter
        def transmitterSiteID(self, transmitterSiteID=None):
            if  transmitterSiteID is None:
                transmitterSiteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(transmitterSiteID)
            self.__transmitterSiteID = transmitterSiteID
        @property # - - - - - - - - - - - - -
        def whichGeometry(self):
            return self.__whichGeometry
        @whichGeometry.setter
        def whichGeometry(self, whichGeometry=None):
            if  whichGeometry is None:
                whichGeometry = SFInt32.DEFAULT_VALUE
            isValidSFInt32(whichGeometry)
            self.__whichGeometry = whichGeometry
        @property # - - - - - - - - - - - - -
        def writeInterval(self):
            return self.__writeInterval
        @writeInterval.setter
        def writeInterval(self, writeInterval=None):
            if  writeInterval is None:
                writeInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(writeInterval)
            self.__writeInterval = writeInterval

class Rectangle2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Rectangle2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#Rectangle2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Rectangle2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('size', (2, 2), 'SFVec2f', 'initializeOnly'),
                          ('solid', False, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 size=(2, 2),
                 solid=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Rectangle2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.size = size
        self.solid = solid
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid

class RigidBody(_X3DNode):
    """
    RigidBody describes a collection of shapes with a mass distribution that is affected by the physics model.
    """
    __name__ = 'RigidBody'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#RigidBody'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#RigidBody'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('angularDampingFactor', 0.001, 'SFFloat', 'inputOutput'),
                          ('angularVelocity', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('autoDamp', False, 'SFBool', 'inputOutput'),
                          ('autoDisable', False, 'SFBool', 'inputOutput'),
                          ('centerOfMass', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('disableAngularSpeed', 0, 'SFFloat', 'inputOutput'),
                          ('disableLinearSpeed', 0, 'SFFloat', 'inputOutput'),
                          ('disableTime', 0, 'SFTime', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('finiteRotationAxis', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('fixed', False, 'SFBool', 'inputOutput'),
                          ('forces', (list()), 'MFVec3f', 'inputOutput'),
                          ('inertia', (1, 0, 0, 0, 1, 0, 0, 0, 1), 'SFMatrix3f', 'inputOutput'),
                          ('linearDampingFactor', 0.001, 'SFFloat', 'inputOutput'),
                          ('linearVelocity', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('mass', 1, 'SFFloat', 'inputOutput'),
                          ('orientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('position', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('torques', (list()), 'MFVec3f', 'inputOutput'),
                          ('useFiniteRotation', False, 'SFBool', 'inputOutput'),
                          ('useGlobalGravity', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('massDensityModel', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('geometry', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 angularDampingFactor=0.001,
                 angularVelocity=(0, 0, 0),
                 autoDamp=False,
                 autoDisable=False,
                 centerOfMass=(0, 0, 0),
                 disableAngularSpeed=0,
                 disableLinearSpeed=0,
                 disableTime=0,
                 enabled=True,
                 finiteRotationAxis=(0, 1, 0),
                 fixed=False,
                 forces=(list()),
                 inertia=(1, 0, 0, 0, 1, 0, 0, 0, 1),
                 linearDampingFactor=0.001,
                 linearVelocity=(0, 0, 0),
                 mass=1,
                 orientation=(0, 0, 1, 0),
                 position=(0, 0, 0),
                 torques=(list()),
                 useFiniteRotation=False,
                 useGlobalGravity=True,
                 USE='',
                 class_='',
                 IS=None,
                 massDensityModel=None,
                 metadata=None,
                 geometry=list()):
        # if _DEBUG: print ('... in ConcreteNode RigidBody __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.angularDampingFactor = angularDampingFactor
        self.angularVelocity = angularVelocity
        self.autoDamp = autoDamp
        self.autoDisable = autoDisable
        self.centerOfMass = centerOfMass
        self.disableAngularSpeed = disableAngularSpeed
        self.disableLinearSpeed = disableLinearSpeed
        self.disableTime = disableTime
        self.enabled = enabled
        self.finiteRotationAxis = finiteRotationAxis
        self.fixed = fixed
        self.forces = forces
        self.inertia = inertia
        self.linearDampingFactor = linearDampingFactor
        self.linearVelocity = linearVelocity
        self.mass = mass
        self.orientation = orientation
        self.position = position
        self.torques = torques
        self.useFiniteRotation = useFiniteRotation
        self.useGlobalGravity = useGlobalGravity
        self.massDensityModel = massDensityModel
        self.geometry = geometry
        @property # - - - - - - - - - - - - -
        def angularDampingFactor(self):
            return self.__angularDampingFactor
        @angularDampingFactor.setter
        def angularDampingFactor(self, angularDampingFactor=None):
            if  angularDampingFactor is None:
                angularDampingFactor = SFFloat.DEFAULT_VALUE
            isValidSFFloat(angularDampingFactor)
            self.__angularDampingFactor = angularDampingFactor
        @property # - - - - - - - - - - - - -
        def angularVelocity(self):
            return self.__angularVelocity
        @angularVelocity.setter
        def angularVelocity(self, angularVelocity=None):
            if  angularVelocity is None:
                angularVelocity = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(angularVelocity)
            self.__angularVelocity = angularVelocity
        @property # - - - - - - - - - - - - -
        def autoDamp(self):
            return self.__autoDamp
        @autoDamp.setter
        def autoDamp(self, autoDamp=None):
            if  autoDamp is None:
                autoDamp = SFBool.DEFAULT_VALUE
            isValidSFBool(autoDamp)
            self.__autoDamp = autoDamp
        @property # - - - - - - - - - - - - -
        def autoDisable(self):
            return self.__autoDisable
        @autoDisable.setter
        def autoDisable(self, autoDisable=None):
            if  autoDisable is None:
                autoDisable = SFBool.DEFAULT_VALUE
            isValidSFBool(autoDisable)
            self.__autoDisable = autoDisable
        @property # - - - - - - - - - - - - -
        def centerOfMass(self):
            return self.__centerOfMass
        @centerOfMass.setter
        def centerOfMass(self, centerOfMass=None):
            if  centerOfMass is None:
                centerOfMass = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(centerOfMass)
            self.__centerOfMass = centerOfMass
        @property # - - - - - - - - - - - - -
        def disableAngularSpeed(self):
            return self.__disableAngularSpeed
        @disableAngularSpeed.setter
        def disableAngularSpeed(self, disableAngularSpeed=None):
            if  disableAngularSpeed is None:
                disableAngularSpeed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(disableAngularSpeed)
            self.__disableAngularSpeed = disableAngularSpeed
        @property # - - - - - - - - - - - - -
        def disableLinearSpeed(self):
            return self.__disableLinearSpeed
        @disableLinearSpeed.setter
        def disableLinearSpeed(self, disableLinearSpeed=None):
            if  disableLinearSpeed is None:
                disableLinearSpeed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(disableLinearSpeed)
            self.__disableLinearSpeed = disableLinearSpeed
        @property # - - - - - - - - - - - - -
        def disableTime(self):
            return self.__disableTime
        @disableTime.setter
        def disableTime(self, disableTime=None):
            if  disableTime is None:
                disableTime = SFTime.DEFAULT_VALUE
            isValidSFTime(disableTime)
            self.__disableTime = disableTime
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def finiteRotationAxis(self):
            return self.__finiteRotationAxis
        @finiteRotationAxis.setter
        def finiteRotationAxis(self, finiteRotationAxis=None):
            if  finiteRotationAxis is None:
                finiteRotationAxis = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(finiteRotationAxis)
            self.__finiteRotationAxis = finiteRotationAxis
        @property # - - - - - - - - - - - - -
        def fixed(self):
            return self.__fixed
        @fixed.setter
        def fixed(self, fixed=None):
            if  fixed is None:
                fixed = SFBool.DEFAULT_VALUE
            isValidSFBool(fixed)
            self.__fixed = fixed
        @property # - - - - - - - - - - - - -
        def forces(self):
            return self.__forces
        @forces.setter
        def forces(self, forces=None):
            if  forces is None:
                forces = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(forces)
            self.__forces = forces
        @property # - - - - - - - - - - - - -
        def inertia(self):
            return self.__inertia
        @inertia.setter
        def inertia(self, inertia=None):
            if  inertia is None:
                inertia = SFMatrix3f.DEFAULT_VALUE
            isValidSFMatrix3f(inertia)
            self.__inertia = inertia
        @property # - - - - - - - - - - - - -
        def linearDampingFactor(self):
            return self.__linearDampingFactor
        @linearDampingFactor.setter
        def linearDampingFactor(self, linearDampingFactor=None):
            if  linearDampingFactor is None:
                linearDampingFactor = SFFloat.DEFAULT_VALUE
            isValidSFFloat(linearDampingFactor)
            self.__linearDampingFactor = linearDampingFactor
        @property # - - - - - - - - - - - - -
        def linearVelocity(self):
            return self.__linearVelocity
        @linearVelocity.setter
        def linearVelocity(self, linearVelocity=None):
            if  linearVelocity is None:
                linearVelocity = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(linearVelocity)
            self.__linearVelocity = linearVelocity
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def orientation(self):
            return self.__orientation
        @orientation.setter
        def orientation(self, orientation=None):
            if  orientation is None:
                orientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(orientation)
            self.__orientation = orientation
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def torques(self):
            return self.__torques
        @torques.setter
        def torques(self, torques=None):
            if  torques is None:
                torques = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(torques)
            self.__torques = torques
        @property # - - - - - - - - - - - - -
        def useFiniteRotation(self):
            return self.__useFiniteRotation
        @useFiniteRotation.setter
        def useFiniteRotation(self, useFiniteRotation=None):
            if  useFiniteRotation is None:
                useFiniteRotation = SFBool.DEFAULT_VALUE
            isValidSFBool(useFiniteRotation)
            self.__useFiniteRotation = useFiniteRotation
        @property # - - - - - - - - - - - - -
        def useGlobalGravity(self):
            return self.__useGlobalGravity
        @useGlobalGravity.setter
        def useGlobalGravity(self, useGlobalGravity=None):
            if  useGlobalGravity is None:
                useGlobalGravity = SFBool.DEFAULT_VALUE
            isValidSFBool(useGlobalGravity)
            self.__useGlobalGravity = useGlobalGravity
        @property # - - - - - - - - - - - - -
        def massDensityModel(self):
            return self.__massDensityModel
        @massDensityModel.setter
        def massDensityModel(self, massDensityModel=None):
            if  massDensityModel is None:
                massDensityModel = SFNode.DEFAULT_VALUE
            isValidSFNode(massDensityModel)
            if not isinstance(massDensityModel, object):
                raise RuntimeError(str(massDensityModel) + ' does not have a valid node type object')
            self.__massDensityModel = massDensityModel
        @property # - - - - - - - - - - - - -
        def geometry(self):
            return self.__geometry
        @geometry.setter
        def geometry(self, geometry=None):
            if  geometry is None:
                geometry = MFNode.DEFAULT_VALUE
            isValidMFNode(geometry)
            self.__geometry = geometry

class RigidBodyCollection(_X3DChildNode):
    """
    RigidBodyCollection represents a system of bodies that interact within a single physics model.
    """
    __name__ = 'RigidBodyCollection'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#RigidBodyCollection'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#RigidBodyCollection'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('autoDisable', False, 'SFBool', 'inputOutput'),
                          ('constantForceMix', 0.0001, 'SFFloat', 'inputOutput'),
                          ('contactSurfaceThickness', 0, 'SFFloat', 'inputOutput'),
                          ('disableAngularSpeed', 0, 'SFFloat', 'inputOutput'),
                          ('disableLinearSpeed', 0, 'SFFloat', 'inputOutput'),
                          ('disableTime', 0, 'SFTime', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('errorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('gravity', (0, -9.8, 0), 'SFVec3f', 'inputOutput'),
                          ('iterations', 10, 'SFInt32', 'inputOutput'),
                          ('maxCorrectionSpeed', -1, 'SFFloat', 'inputOutput'),
                          ('preferAccuracy', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('collider', None, 'SFNode', 'initializeOnly'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('bodies', list(), 'MFNode', 'inputOutput'),
                          ('joints', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 autoDisable=False,
                 constantForceMix=0.0001,
                 contactSurfaceThickness=0,
                 disableAngularSpeed=0,
                 disableLinearSpeed=0,
                 disableTime=0,
                 enabled=True,
                 errorCorrection=0.8,
                 gravity=(0, -9.8, 0),
                 iterations=10,
                 maxCorrectionSpeed=-1,
                 preferAccuracy=False,
                 USE='',
                 class_='',
                 collider=None,
                 IS=None,
                 metadata=None,
                 bodies=list(),
                 joints=list()):
        # if _DEBUG: print ('... in ConcreteNode RigidBodyCollection __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.autoDisable = autoDisable
        self.constantForceMix = constantForceMix
        self.contactSurfaceThickness = contactSurfaceThickness
        self.disableAngularSpeed = disableAngularSpeed
        self.disableLinearSpeed = disableLinearSpeed
        self.disableTime = disableTime
        self.enabled = enabled
        self.errorCorrection = errorCorrection
        self.gravity = gravity
        self.iterations = iterations
        self.maxCorrectionSpeed = maxCorrectionSpeed
        self.preferAccuracy = preferAccuracy
        self.collider = collider
        self.bodies = bodies
        self.joints = joints
        @property # - - - - - - - - - - - - -
        def autoDisable(self):
            return self.__autoDisable
        @autoDisable.setter
        def autoDisable(self, autoDisable=None):
            if  autoDisable is None:
                autoDisable = SFBool.DEFAULT_VALUE
            isValidSFBool(autoDisable)
            self.__autoDisable = autoDisable
        @property # - - - - - - - - - - - - -
        def constantForceMix(self):
            return self.__constantForceMix
        @constantForceMix.setter
        def constantForceMix(self, constantForceMix=None):
            if  constantForceMix is None:
                constantForceMix = SFFloat.DEFAULT_VALUE
            isValidSFFloat(constantForceMix)
            self.__constantForceMix = constantForceMix
        @property # - - - - - - - - - - - - -
        def contactSurfaceThickness(self):
            return self.__contactSurfaceThickness
        @contactSurfaceThickness.setter
        def contactSurfaceThickness(self, contactSurfaceThickness=None):
            if  contactSurfaceThickness is None:
                contactSurfaceThickness = SFFloat.DEFAULT_VALUE
            isValidSFFloat(contactSurfaceThickness)
            self.__contactSurfaceThickness = contactSurfaceThickness
        @property # - - - - - - - - - - - - -
        def disableAngularSpeed(self):
            return self.__disableAngularSpeed
        @disableAngularSpeed.setter
        def disableAngularSpeed(self, disableAngularSpeed=None):
            if  disableAngularSpeed is None:
                disableAngularSpeed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(disableAngularSpeed)
            self.__disableAngularSpeed = disableAngularSpeed
        @property # - - - - - - - - - - - - -
        def disableLinearSpeed(self):
            return self.__disableLinearSpeed
        @disableLinearSpeed.setter
        def disableLinearSpeed(self, disableLinearSpeed=None):
            if  disableLinearSpeed is None:
                disableLinearSpeed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(disableLinearSpeed)
            self.__disableLinearSpeed = disableLinearSpeed
        @property # - - - - - - - - - - - - -
        def disableTime(self):
            return self.__disableTime
        @disableTime.setter
        def disableTime(self, disableTime=None):
            if  disableTime is None:
                disableTime = SFTime.DEFAULT_VALUE
            isValidSFTime(disableTime)
            self.__disableTime = disableTime
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def errorCorrection(self):
            return self.__errorCorrection
        @errorCorrection.setter
        def errorCorrection(self, errorCorrection=None):
            if  errorCorrection is None:
                errorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(errorCorrection)
            self.__errorCorrection = errorCorrection
        @property # - - - - - - - - - - - - -
        def gravity(self):
            return self.__gravity
        @gravity.setter
        def gravity(self, gravity=None):
            if  gravity is None:
                gravity = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(gravity)
            self.__gravity = gravity
        @property # - - - - - - - - - - - - -
        def iterations(self):
            return self.__iterations
        @iterations.setter
        def iterations(self, iterations=None):
            if  iterations is None:
                iterations = SFInt32.DEFAULT_VALUE
            isValidSFInt32(iterations)
            self.__iterations = iterations
        @property # - - - - - - - - - - - - -
        def maxCorrectionSpeed(self):
            return self.__maxCorrectionSpeed
        @maxCorrectionSpeed.setter
        def maxCorrectionSpeed(self, maxCorrectionSpeed=None):
            if  maxCorrectionSpeed is None:
                maxCorrectionSpeed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxCorrectionSpeed)
            self.__maxCorrectionSpeed = maxCorrectionSpeed
        @property # - - - - - - - - - - - - -
        def preferAccuracy(self):
            return self.__preferAccuracy
        @preferAccuracy.setter
        def preferAccuracy(self, preferAccuracy=None):
            if  preferAccuracy is None:
                preferAccuracy = SFBool.DEFAULT_VALUE
            isValidSFBool(preferAccuracy)
            self.__preferAccuracy = preferAccuracy
        @property # - - - - - - - - - - - - -
        def collider(self):
            return self.__collider
        @collider.setter
        def collider(self, collider=None):
            if  collider is None:
                collider = SFNode.DEFAULT_VALUE
            isValidSFNode(collider)
            if not isinstance(collider, object):
                raise RuntimeError(str(collider) + ' does not have a valid node type object')
            self.__collider = collider
        @property # - - - - - - - - - - - - -
        def bodies(self):
            return self.__bodies
        @bodies.setter
        def bodies(self, bodies=None):
            if  bodies is None:
                bodies = MFNode.DEFAULT_VALUE
            isValidMFNode(bodies)
            self.__bodies = bodies
        @property # - - - - - - - - - - - - -
        def joints(self):
            return self.__joints
        @joints.setter
        def joints(self, joints=None):
            if  joints is None:
                joints = MFNode.DEFAULT_VALUE
            isValidMFNode(joints)
            self.__joints = joints

class ScalarChaser(_X3DChaserNode):
    """
    X3D element
    """
    __name__ = 'ScalarChaser'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#ScalarChaser'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ScalarChaser'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('duration', 1, 'SFTime', 'initializeOnly'),
                          ('initialDestination', 0, 'SFFloat', 'initializeOnly'),
                          ('initialValue', 0, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 duration=1,
                 initialDestination=0,
                 initialValue=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ScalarChaser __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.duration = duration
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def duration(self):
            return self.__duration
        @duration.setter
        def duration(self, duration=None):
            if  duration is None:
                duration = SFTime.DEFAULT_VALUE
            isValidSFTime(duration)
            self.__duration = duration
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFFloat.DEFAULT_VALUE
            isValidSFFloat(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFFloat.DEFAULT_VALUE
            isValidSFFloat(initialValue)
            self.__initialValue = initialValue

class ScalarDamper(_X3DDamperNode):
    """
    X3D element
    """
    __name__ = 'ScalarDamper'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#ScalarDamper'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ScalarDamper'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('initialDestination', 0, 'SFFloat', 'initializeOnly'),
                          ('initialValue', 0, 'SFFloat', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tau', 0.3, 'SFTime', 'inputOutput'),
                          ('tolerance', -1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 initialDestination=0,
                 initialValue=0,
                 order=3,
                 tau=0.3,
                 tolerance=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ScalarDamper __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        self.order = order
        self.tau = tau
        self.tolerance = tolerance
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = SFFloat.DEFAULT_VALUE
            isValidSFFloat(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = SFFloat.DEFAULT_VALUE
            isValidSFFloat(initialValue)
            self.__initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tau(self):
            return self.__tau
        @tau.setter
        def tau(self, tau=None):
            if  tau is None:
                tau = SFTime.DEFAULT_VALUE
            isValidSFTime(tau)
            self.__tau = tau
        @property # - - - - - - - - - - - - -
        def tolerance(self):
            return self.__tolerance
        @tolerance.setter
        def tolerance(self, tolerance=None):
            if  tolerance is None:
                tolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tolerance)
            self.__tolerance = tolerance

class ScalarInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'ScalarInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#ScalarInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ScalarInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ScalarInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFFloat.DEFAULT_VALUE
            isValidMFFloat(keyValue)
            self.__keyValue = keyValue

class ScreenFontStyle(_X3DFontStyleNode):
    """
    X3D element
    """
    __name__ = 'ScreenFontStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layout.html#ScreenFontStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ScreenFontStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('family', ["SERIF"], 'MFString', 'initializeOnly'),
                          ('horizontal', True, 'SFBool', 'initializeOnly'),
                          ('justify', ["BEGIN"], 'MFString', 'initializeOnly'),
                          ('language', '', 'SFString', 'initializeOnly'),
                          ('leftToRight', True, 'SFBool', 'initializeOnly'),
                          ('pointSize', 12.0, 'SFFloat', 'initializeOnly'),
                          ('spacing', 1.0, 'SFFloat', 'initializeOnly'),
                          ('style', 'PLAIN', 'SFString', 'initializeOnly'),
                          ('topToBottom', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 family=["SERIF"],
                 horizontal=True,
                 justify=["BEGIN"],
                 language='',
                 leftToRight=True,
                 pointSize=12.0,
                 spacing=1.0,
                 style='PLAIN',
                 topToBottom=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ScreenFontStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.family = family
        self.horizontal = horizontal
        self.justify = justify
        self.language = language
        self.leftToRight = leftToRight
        self.pointSize = pointSize
        self.spacing = spacing
        self.style = style
        self.topToBottom = topToBottom
        @property # - - - - - - - - - - - - -
        def family(self):
            return self.__family
        @family.setter
        def family(self, family=None):
            if  family is None:
                family = MFString.DEFAULT_VALUE
            isValidMFString(family)
            self.__family = family
        @property # - - - - - - - - - - - - -
        def horizontal(self):
            return self.__horizontal
        @horizontal.setter
        def horizontal(self, horizontal=None):
            if  horizontal is None:
                horizontal = SFBool.DEFAULT_VALUE
            isValidSFBool(horizontal)
            self.__horizontal = horizontal
        @property # - - - - - - - - - - - - -
        def justify(self):
            return self.__justify
        @justify.setter
        def justify(self, justify=None):
            if  justify is None:
                justify = MFString.DEFAULT_VALUE
            isValidMFString(justify)
            self.__justify = justify
        @property # - - - - - - - - - - - - -
        def language(self):
            return self.__language
        @language.setter
        def language(self, language=None):
            if  language is None:
                language = SFString.DEFAULT_VALUE
            isValidSFString(language)
            self.__language = language
        @property # - - - - - - - - - - - - -
        def leftToRight(self):
            return self.__leftToRight
        @leftToRight.setter
        def leftToRight(self, leftToRight=None):
            if  leftToRight is None:
                leftToRight = SFBool.DEFAULT_VALUE
            isValidSFBool(leftToRight)
            self.__leftToRight = leftToRight
        @property # - - - - - - - - - - - - -
        def pointSize(self):
            return self.__pointSize
        @pointSize.setter
        def pointSize(self, pointSize=None):
            if  pointSize is None:
                pointSize = SFFloat.DEFAULT_VALUE
            isValidSFFloat(pointSize)
            self.__pointSize = pointSize
        @property # - - - - - - - - - - - - -
        def spacing(self):
            return self.__spacing
        @spacing.setter
        def spacing(self, spacing=None):
            if  spacing is None:
                spacing = SFFloat.DEFAULT_VALUE
            isValidSFFloat(spacing)
            self.__spacing = spacing
        @property # - - - - - - - - - - - - -
        def style(self):
            return self.__style
        @style.setter
        def style(self, style=None):
            if  style is None:
                style = SFString.DEFAULT_VALUE
            isValidSFString(style)
            self.__style = style
        @property # - - - - - - - - - - - - -
        def topToBottom(self):
            return self.__topToBottom
        @topToBottom.setter
        def topToBottom(self, topToBottom=None):
            if  topToBottom is None:
                topToBottom = SFBool.DEFAULT_VALUE
            isValidSFBool(topToBottom)
            self.__topToBottom = topToBottom

class ScreenGroup(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'ScreenGroup'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layout.html#ScreenGroup'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ScreenGroup'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode ScreenGroup __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class Script(_X3DScriptNode):
    """
    X3D element
    """
    __name__ = 'Script'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/scripting.html#Script'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Script'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('directOutput', False, 'SFBool', 'initializeOnly'),
                          ('mustEvaluate', False, 'SFBool', 'initializeOnly'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('field', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 directOutput=False,
                 mustEvaluate=False,
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 field=list()):
        # if _DEBUG: print ('... in ConcreteNode Script __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.directOutput = directOutput
        self.mustEvaluate = mustEvaluate
        self.url = url
        self.field = field
        @property # - - - - - - - - - - - - -
        def directOutput(self):
            return self.__directOutput
        @directOutput.setter
        def directOutput(self, directOutput=None):
            if  directOutput is None:
                directOutput = SFBool.DEFAULT_VALUE
            isValidSFBool(directOutput)
            self.__directOutput = directOutput
        @property # - - - - - - - - - - - - -
        def mustEvaluate(self):
            return self.__mustEvaluate
        @mustEvaluate.setter
        def mustEvaluate(self, mustEvaluate=None):
            if  mustEvaluate is None:
                mustEvaluate = SFBool.DEFAULT_VALUE
            isValidSFBool(mustEvaluate)
            self.__mustEvaluate = mustEvaluate
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def field(self):
            return self.__field
        @field.setter
        def field(self, field=None):
            if  field is None:
                field = MFNode.DEFAULT_VALUE
            isValidMFNode(field)
            self.__field = field

class SegmentedVolumeData(_X3DVolumeDataNode):
    """
    X3D element
    """
    __name__ = 'SegmentedVolumeData'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#SegmentedVolumeData'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SegmentedVolumeData'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('dimensions', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('segmentEnabled', list(), 'MFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('segmentIdentifiers', None, 'SFNode', 'inputOutput'),
                          ('voxels', None, 'SFNode', 'inputOutput'),
                          ('renderStyle', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 dimensions=(1, 1, 1),
                 segmentEnabled=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 segmentIdentifiers=None,
                 voxels=None,
                 renderStyle=list()):
        # if _DEBUG: print ('... in ConcreteNode SegmentedVolumeData __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.dimensions = dimensions
        self.segmentEnabled = segmentEnabled
        self.segmentIdentifiers = segmentIdentifiers
        self.voxels = voxels
        self.renderStyle = renderStyle
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def dimensions(self):
            return self.__dimensions
        @dimensions.setter
        def dimensions(self, dimensions=None):
            if  dimensions is None:
                dimensions = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(dimensions)
            self.__dimensions = dimensions
        @property # - - - - - - - - - - - - -
        def segmentEnabled(self):
            return self.__segmentEnabled
        @segmentEnabled.setter
        def segmentEnabled(self, segmentEnabled=None):
            if  segmentEnabled is None:
                segmentEnabled = MFBool.DEFAULT_VALUE
            isValidMFBool(segmentEnabled)
            self.__segmentEnabled = segmentEnabled
        @property # - - - - - - - - - - - - -
        def segmentIdentifiers(self):
            return self.__segmentIdentifiers
        @segmentIdentifiers.setter
        def segmentIdentifiers(self, segmentIdentifiers=None):
            if  segmentIdentifiers is None:
                segmentIdentifiers = SFNode.DEFAULT_VALUE
            isValidSFNode(segmentIdentifiers)
            if not isinstance(segmentIdentifiers, object):
                raise RuntimeError(str(segmentIdentifiers) + ' does not have a valid node type object')
            self.__segmentIdentifiers = segmentIdentifiers
        @property # - - - - - - - - - - - - -
        def voxels(self):
            return self.__voxels
        @voxels.setter
        def voxels(self, voxels=None):
            if  voxels is None:
                voxels = SFNode.DEFAULT_VALUE
            isValidSFNode(voxels)
            if not isinstance(voxels, object):
                raise RuntimeError(str(voxels) + ' does not have a valid node type object')
            self.__voxels = voxels
        @property # - - - - - - - - - - - - -
        def renderStyle(self):
            return self.__renderStyle
        @renderStyle.setter
        def renderStyle(self, renderStyle=None):
            if  renderStyle is None:
                renderStyle = MFNode.DEFAULT_VALUE
            isValidMFNode(renderStyle)
            self.__renderStyle = renderStyle

class ShadedVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    All fields fully supported except shadows supported with at least Phong shading at level 3. All fields fully supported with at least Phong shading and Henyey-Greenstein phase function, shadows fully supported at level 4.
    """
    __name__ = 'ShadedVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#ShadedVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ShadedVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('lighting', False, 'SFBool', 'inputOutput'),
                          ('phaseFunction', 'Henyey-Greenstein', 'SFString', 'initializeOnly'),
                          ('shadows', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('material', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('surfaceNormals', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 lighting=False,
                 phaseFunction='Henyey-Greenstein',
                 shadows=False,
                 USE='',
                 class_='',
                 IS=None,
                 material=None,
                 metadata=None,
                 surfaceNormals=None):
        # if _DEBUG: print ('... in ConcreteNode ShadedVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.lighting = lighting
        self.phaseFunction = phaseFunction
        self.shadows = shadows
        self.material = material
        self.surfaceNormals = surfaceNormals
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def lighting(self):
            return self.__lighting
        @lighting.setter
        def lighting(self, lighting=None):
            if  lighting is None:
                lighting = SFBool.DEFAULT_VALUE
            isValidSFBool(lighting)
            self.__lighting = lighting
        @property # - - - - - - - - - - - - -
        def phaseFunction(self):
            return self.__phaseFunction
        @phaseFunction.setter
        def phaseFunction(self, phaseFunction=None):
            if  phaseFunction is None:
                phaseFunction = SFString.DEFAULT_VALUE
            isValidSFString(phaseFunction)
            self.__phaseFunction = phaseFunction
        @property # - - - - - - - - - - - - -
        def shadows(self):
            return self.__shadows
        @shadows.setter
        def shadows(self, shadows=None):
            if  shadows is None:
                shadows = SFBool.DEFAULT_VALUE
            isValidSFBool(shadows)
            self.__shadows = shadows
        @property # - - - - - - - - - - - - -
        def material(self):
            return self.__material
        @material.setter
        def material(self, material=None):
            if  material is None:
                material = SFNode.DEFAULT_VALUE
            isValidSFNode(material)
            if not isinstance(material, object):
                raise RuntimeError(str(material) + ' does not have a valid node type object')
            self.__material = material
        @property # - - - - - - - - - - - - -
        def surfaceNormals(self):
            return self.__surfaceNormals
        @surfaceNormals.setter
        def surfaceNormals(self, surfaceNormals=None):
            if  surfaceNormals is None:
                surfaceNormals = SFNode.DEFAULT_VALUE
            isValidSFNode(surfaceNormals)
            if not isinstance(surfaceNormals, object):
                raise RuntimeError(str(surfaceNormals) + ' does not have a valid node type object')
            self.__surfaceNormals = surfaceNormals

class ShaderPart(_X3DNode):
    """
    ShaderPart can contain a CDATA section of plain-text source code.
    """
    __name__ = 'ShaderPart'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#ShaderPart'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ShaderPart'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('type', 'VERTEX', 'SFString', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 type='VERTEX',
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode ShaderPart __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.type = type
        self.url = url
        @property # - - - - - - - - - - - - -
        def type(self):
            return self.__type
        @type.setter
        def type(self, type=None):
            if  type is None:
                type = SFString.DEFAULT_VALUE
            isValidSFString(type)
            self.__type = type
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url

class ShaderProgram(_X3DNode):
    """
    ShaderProgram can contain field declarations and a CDATA section of plain-text source code.
    """
    __name__ = 'ShaderProgram'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shaders.html#ShaderProgram'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ShaderProgram'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('type', 'VERTEX', 'SFString', 'inputOutput'),
                          ('url', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('field', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 type='VERTEX',
                 url=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 field=list()):
        # if _DEBUG: print ('... in ConcreteNode ShaderProgram __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.type = type
        self.url = url
        self.field = field
        @property # - - - - - - - - - - - - -
        def type(self):
            return self.__type
        @type.setter
        def type(self, type=None):
            if  type is None:
                type = SFString.DEFAULT_VALUE
            isValidSFString(type)
            self.__type = type
        @property # - - - - - - - - - - - - -
        def url(self):
            return self.__url
        @url.setter
        def url(self, url=None):
            if  url is None:
                url = MFString.DEFAULT_VALUE
            isValidMFString(url)
            self.__url = url
        @property # - - - - - - - - - - - - -
        def field(self):
            return self.__field
        @field.setter
        def field(self, field=None):
            if  field is None:
                field = MFNode.DEFAULT_VALUE
            isValidMFNode(field)
            self.__field = field

class Shape(_X3DShapeNode):
    """
    X3D element
    """
    __name__ = 'Shape'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#Shape'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Shape'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('appearance', None, 'SFNode', 'inputOutput'),
                          ('geometry', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 USE='',
                 class_='',
                 appearance=None,
                 geometry=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Shape __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.appearance = appearance
        self.geometry = geometry
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def appearance(self):
            return self.__appearance
        @appearance.setter
        def appearance(self, appearance=None):
            if  appearance is None:
                appearance = SFNode.DEFAULT_VALUE
            isValidSFNode(appearance)
            if not isinstance(appearance, object):
                raise RuntimeError(str(appearance) + ' does not have a valid node type object')
            self.__appearance = appearance
        @property # - - - - - - - - - - - - -
        def geometry(self):
            return self.__geometry
        @geometry.setter
        def geometry(self, geometry=None):
            if  geometry is None:
                geometry = SFNode.DEFAULT_VALUE
            isValidSFNode(geometry)
            if not isinstance(geometry, object):
                raise RuntimeError(str(geometry) + ' does not have a valid node type object')
            self.__geometry = geometry

class SignalPdu(_X3DNetworkSensorNode):
    """
    X3D element
    """
    __name__ = 'SignalPdu'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/dis.html#SignalPdu'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SignalPdu'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('address', 'localhost', 'SFString', 'inputOutput'),
                          ('applicationID', 0, 'SFInt32', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('data', list(), 'MFInt32', 'inputOutput'),
                          ('dataLength', 0, 'SFInt32', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('encodingScheme', 0, 'SFInt32', 'inputOutput'),
                          ('entityID', 0, 'SFInt32', 'inputOutput'),
                          ('geoCoords', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('multicastRelayHost', '', 'SFString', 'inputOutput'),
                          ('multicastRelayPort', 0, 'SFInt32', 'inputOutput'),
                          ('networkMode', 'standAlone', 'SFString', 'inputOutput'),
                          ('port', 0, 'SFInt32', 'inputOutput'),
                          ('radioID', 0, 'SFInt32', 'inputOutput'),
                          ('readInterval', 0.1, 'SFTime', 'inputOutput'),
                          ('rtpHeaderExpected', False, 'SFBool', 'initializeOnly'),
                          ('sampleRate', 0, 'SFInt32', 'inputOutput'),
                          ('samples', 0, 'SFInt32', 'inputOutput'),
                          ('siteID', 0, 'SFInt32', 'inputOutput'),
                          ('tdlType', 0, 'SFInt32', 'inputOutput'),
                          ('whichGeometry', 1, 'SFInt32', 'inputOutput'),
                          ('writeInterval', 1.0, 'SFTime', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 address='localhost',
                 applicationID=0,
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 data=list(),
                 dataLength=0,
                 enabled=True,
                 encodingScheme=0,
                 entityID=0,
                 geoCoords=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 multicastRelayHost='',
                 multicastRelayPort=0,
                 networkMode='standAlone',
                 port=0,
                 radioID=0,
                 readInterval=0.1,
                 rtpHeaderExpected=False,
                 sampleRate=0,
                 samples=0,
                 siteID=0,
                 tdlType=0,
                 whichGeometry=1,
                 writeInterval=1.0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SignalPdu __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.address = address
        self.applicationID = applicationID
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.data = data
        self.dataLength = dataLength
        self.enabled = enabled
        self.encodingScheme = encodingScheme
        self.entityID = entityID
        self.geoCoords = geoCoords
        self.geoSystem = geoSystem
        self.multicastRelayHost = multicastRelayHost
        self.multicastRelayPort = multicastRelayPort
        self.networkMode = networkMode
        self.port = port
        self.radioID = radioID
        self.readInterval = readInterval
        self.rtpHeaderExpected = rtpHeaderExpected
        self.sampleRate = sampleRate
        self.samples = samples
        self.siteID = siteID
        self.tdlType = tdlType
        self.whichGeometry = whichGeometry
        self.writeInterval = writeInterval
        @property # - - - - - - - - - - - - -
        def address(self):
            return self.__address
        @address.setter
        def address(self, address=None):
            if  address is None:
                address = SFString.DEFAULT_VALUE
            isValidSFString(address)
            self.__address = address
        @property # - - - - - - - - - - - - -
        def applicationID(self):
            return self.__applicationID
        @applicationID.setter
        def applicationID(self, applicationID=None):
            if  applicationID is None:
                applicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(applicationID)
            self.__applicationID = applicationID
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def data(self):
            return self.__data
        @data.setter
        def data(self, data=None):
            if  data is None:
                data = MFInt32.DEFAULT_VALUE
            isValidMFInt32(data)
            self.__data = data
        @property # - - - - - - - - - - - - -
        def dataLength(self):
            return self.__dataLength
        @dataLength.setter
        def dataLength(self, dataLength=None):
            if  dataLength is None:
                dataLength = SFInt32.DEFAULT_VALUE
            isValidSFInt32(dataLength)
            self.__dataLength = dataLength
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def encodingScheme(self):
            return self.__encodingScheme
        @encodingScheme.setter
        def encodingScheme(self, encodingScheme=None):
            if  encodingScheme is None:
                encodingScheme = SFInt32.DEFAULT_VALUE
            isValidSFInt32(encodingScheme)
            self.__encodingScheme = encodingScheme
        @property # - - - - - - - - - - - - -
        def entityID(self):
            return self.__entityID
        @entityID.setter
        def entityID(self, entityID=None):
            if  entityID is None:
                entityID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityID)
            self.__entityID = entityID
        @property # - - - - - - - - - - - - -
        def geoCoords(self):
            return self.__geoCoords
        @geoCoords.setter
        def geoCoords(self, geoCoords=None):
            if  geoCoords is None:
                geoCoords = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCoords)
            self.__geoCoords = geoCoords
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def multicastRelayHost(self):
            return self.__multicastRelayHost
        @multicastRelayHost.setter
        def multicastRelayHost(self, multicastRelayHost=None):
            if  multicastRelayHost is None:
                multicastRelayHost = SFString.DEFAULT_VALUE
            isValidSFString(multicastRelayHost)
            self.__multicastRelayHost = multicastRelayHost
        @property # - - - - - - - - - - - - -
        def multicastRelayPort(self):
            return self.__multicastRelayPort
        @multicastRelayPort.setter
        def multicastRelayPort(self, multicastRelayPort=None):
            if  multicastRelayPort is None:
                multicastRelayPort = SFInt32.DEFAULT_VALUE
            isValidSFInt32(multicastRelayPort)
            self.__multicastRelayPort = multicastRelayPort
        @property # - - - - - - - - - - - - -
        def networkMode(self):
            return self.__networkMode
        @networkMode.setter
        def networkMode(self, networkMode=None):
            if  networkMode is None:
                networkMode = SFString.DEFAULT_VALUE
            isValidSFString(networkMode)
            self.__networkMode = networkMode
        @property # - - - - - - - - - - - - -
        def port(self):
            return self.__port
        @port.setter
        def port(self, port=None):
            if  port is None:
                port = SFInt32.DEFAULT_VALUE
            isValidSFInt32(port)
            self.__port = port
        @property # - - - - - - - - - - - - -
        def radioID(self):
            return self.__radioID
        @radioID.setter
        def radioID(self, radioID=None):
            if  radioID is None:
                radioID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioID)
            self.__radioID = radioID
        @property # - - - - - - - - - - - - -
        def readInterval(self):
            return self.__readInterval
        @readInterval.setter
        def readInterval(self, readInterval=None):
            if  readInterval is None:
                readInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(readInterval)
            self.__readInterval = readInterval
        @property # - - - - - - - - - - - - -
        def rtpHeaderExpected(self):
            return self.__rtpHeaderExpected
        @rtpHeaderExpected.setter
        def rtpHeaderExpected(self, rtpHeaderExpected=None):
            if  rtpHeaderExpected is None:
                rtpHeaderExpected = SFBool.DEFAULT_VALUE
            isValidSFBool(rtpHeaderExpected)
            self.__rtpHeaderExpected = rtpHeaderExpected
        @property # - - - - - - - - - - - - -
        def sampleRate(self):
            return self.__sampleRate
        @sampleRate.setter
        def sampleRate(self, sampleRate=None):
            if  sampleRate is None:
                sampleRate = SFInt32.DEFAULT_VALUE
            isValidSFInt32(sampleRate)
            self.__sampleRate = sampleRate
        @property # - - - - - - - - - - - - -
        def samples(self):
            return self.__samples
        @samples.setter
        def samples(self, samples=None):
            if  samples is None:
                samples = SFInt32.DEFAULT_VALUE
            isValidSFInt32(samples)
            self.__samples = samples
        @property # - - - - - - - - - - - - -
        def siteID(self):
            return self.__siteID
        @siteID.setter
        def siteID(self, siteID=None):
            if  siteID is None:
                siteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(siteID)
            self.__siteID = siteID
        @property # - - - - - - - - - - - - -
        def tdlType(self):
            return self.__tdlType
        @tdlType.setter
        def tdlType(self, tdlType=None):
            if  tdlType is None:
                tdlType = SFInt32.DEFAULT_VALUE
            isValidSFInt32(tdlType)
            self.__tdlType = tdlType
        @property # - - - - - - - - - - - - -
        def whichGeometry(self):
            return self.__whichGeometry
        @whichGeometry.setter
        def whichGeometry(self, whichGeometry=None):
            if  whichGeometry is None:
                whichGeometry = SFInt32.DEFAULT_VALUE
            isValidSFInt32(whichGeometry)
            self.__whichGeometry = whichGeometry
        @property # - - - - - - - - - - - - -
        def writeInterval(self):
            return self.__writeInterval
        @writeInterval.setter
        def writeInterval(self, writeInterval=None):
            if  writeInterval is None:
                writeInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(writeInterval)
            self.__writeInterval = writeInterval

class SilhouetteEnhancementVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'SilhouetteEnhancementVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#SilhouetteEnhancementVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SilhouetteEnhancementVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('silhouetteBoundaryOpacity', 0, 'SFFloat', 'inputOutput'),
                          ('silhouetteRetainedOpacity', 1, 'SFFloat', 'inputOutput'),
                          ('silhouetteSharpness', 0.5, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('surfaceNormals', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 silhouetteBoundaryOpacity=0,
                 silhouetteRetainedOpacity=1,
                 silhouetteSharpness=0.5,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 surfaceNormals=None):
        # if _DEBUG: print ('... in ConcreteNode SilhouetteEnhancementVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.silhouetteBoundaryOpacity = silhouetteBoundaryOpacity
        self.silhouetteRetainedOpacity = silhouetteRetainedOpacity
        self.silhouetteSharpness = silhouetteSharpness
        self.surfaceNormals = surfaceNormals
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def silhouetteBoundaryOpacity(self):
            return self.__silhouetteBoundaryOpacity
        @silhouetteBoundaryOpacity.setter
        def silhouetteBoundaryOpacity(self, silhouetteBoundaryOpacity=None):
            if  silhouetteBoundaryOpacity is None:
                silhouetteBoundaryOpacity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(silhouetteBoundaryOpacity)
            self.__silhouetteBoundaryOpacity = silhouetteBoundaryOpacity
        @property # - - - - - - - - - - - - -
        def silhouetteRetainedOpacity(self):
            return self.__silhouetteRetainedOpacity
        @silhouetteRetainedOpacity.setter
        def silhouetteRetainedOpacity(self, silhouetteRetainedOpacity=None):
            if  silhouetteRetainedOpacity is None:
                silhouetteRetainedOpacity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(silhouetteRetainedOpacity)
            self.__silhouetteRetainedOpacity = silhouetteRetainedOpacity
        @property # - - - - - - - - - - - - -
        def silhouetteSharpness(self):
            return self.__silhouetteSharpness
        @silhouetteSharpness.setter
        def silhouetteSharpness(self, silhouetteSharpness=None):
            if  silhouetteSharpness is None:
                silhouetteSharpness = SFFloat.DEFAULT_VALUE
            isValidSFFloat(silhouetteSharpness)
            self.__silhouetteSharpness = silhouetteSharpness
        @property # - - - - - - - - - - - - -
        def surfaceNormals(self):
            return self.__surfaceNormals
        @surfaceNormals.setter
        def surfaceNormals(self, surfaceNormals=None):
            if  surfaceNormals is None:
                surfaceNormals = SFNode.DEFAULT_VALUE
            isValidSFNode(surfaceNormals)
            if not isinstance(surfaceNormals, object):
                raise RuntimeError(str(surfaceNormals) + ' does not have a valid node type object')
            self.__surfaceNormals = surfaceNormals

class SingleAxisHingeJoint(_X3DRigidJointNode):
    """
    SingleAxisHingeJoint has single axis about which to rotate, similar to a traditional door hinge. Contains two RigidBody nodes (containerField values body1, body2).
    """
    __name__ = 'SingleAxisHingeJoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#SingleAxisHingeJoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SingleAxisHingeJoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('anchorPoint', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('axis', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('forceOutput', ["NONE"], 'MFString', 'inputOutput'),
                          ('maxAngle', 3.141592653, 'SFFloat', 'inputOutput'),
                          ('minAngle', -3.141592653, 'SFFloat', 'inputOutput'),
                          ('stopBounce', 0, 'SFFloat', 'inputOutput'),
                          ('stopErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('body1', None, 'SFNode', 'inputOutput'),
                          ('body2', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 anchorPoint=(0, 0, 0),
                 axis=(0, 0, 0),
                 forceOutput=["NONE"],
                 maxAngle=3.141592653,
                 minAngle=-3.141592653,
                 stopBounce=0,
                 stopErrorCorrection=0.8,
                 USE='',
                 class_='',
                 body1=None,
                 body2=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SingleAxisHingeJoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.anchorPoint = anchorPoint
        self.axis = axis
        self.forceOutput = forceOutput
        self.maxAngle = maxAngle
        self.minAngle = minAngle
        self.stopBounce = stopBounce
        self.stopErrorCorrection = stopErrorCorrection
        self.body1 = body1
        self.body2 = body2
        @property # - - - - - - - - - - - - -
        def anchorPoint(self):
            return self.__anchorPoint
        @anchorPoint.setter
        def anchorPoint(self, anchorPoint=None):
            if  anchorPoint is None:
                anchorPoint = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(anchorPoint)
            self.__anchorPoint = anchorPoint
        @property # - - - - - - - - - - - - -
        def axis(self):
            return self.__axis
        @axis.setter
        def axis(self, axis=None):
            if  axis is None:
                axis = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(axis)
            self.__axis = axis
        @property # - - - - - - - - - - - - -
        def forceOutput(self):
            return self.__forceOutput
        @forceOutput.setter
        def forceOutput(self, forceOutput=None):
            if  forceOutput is None:
                forceOutput = MFString.DEFAULT_VALUE
            isValidMFString(forceOutput)
            self.__forceOutput = forceOutput
        @property # - - - - - - - - - - - - -
        def maxAngle(self):
            return self.__maxAngle
        @maxAngle.setter
        def maxAngle(self, maxAngle=None):
            if  maxAngle is None:
                maxAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxAngle)
            self.__maxAngle = maxAngle
        @property # - - - - - - - - - - - - -
        def minAngle(self):
            return self.__minAngle
        @minAngle.setter
        def minAngle(self, minAngle=None):
            if  minAngle is None:
                minAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minAngle)
            self.__minAngle = minAngle
        @property # - - - - - - - - - - - - -
        def stopBounce(self):
            return self.__stopBounce
        @stopBounce.setter
        def stopBounce(self, stopBounce=None):
            if  stopBounce is None:
                stopBounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stopBounce)
            self.__stopBounce = stopBounce
        @property # - - - - - - - - - - - - -
        def stopErrorCorrection(self):
            return self.__stopErrorCorrection
        @stopErrorCorrection.setter
        def stopErrorCorrection(self, stopErrorCorrection=None):
            if  stopErrorCorrection is None:
                stopErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stopErrorCorrection)
            self.__stopErrorCorrection = stopErrorCorrection
        @property # - - - - - - - - - - - - -
        def body1(self):
            return self.__body1
        @body1.setter
        def body1(self, body1=None):
            if  body1 is None:
                body1 = SFNode.DEFAULT_VALUE
            isValidSFNode(body1)
            if not isinstance(body1, object):
                raise RuntimeError(str(body1) + ' does not have a valid node type object')
            self.__body1 = body1
        @property # - - - - - - - - - - - - -
        def body2(self):
            return self.__body2
        @body2.setter
        def body2(self, body2=None):
            if  body2 is None:
                body2 = SFNode.DEFAULT_VALUE
            isValidSFNode(body2)
            if not isinstance(body2, object):
                raise RuntimeError(str(body2) + ' does not have a valid node type object')
            self.__body2 = body2

class SliderJoint(_X3DRigidJointNode):
    """
    SliderJoint constrains all movement between body1 and body2 along a single axis. Contains two RigidBody nodes (containerField values body1, body2).
    """
    __name__ = 'SliderJoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#SliderJoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SliderJoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('axis', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('forceOutput', ["NONE"], 'MFString', 'inputOutput'),
                          ('maxSeparation', 1, 'SFFloat', 'inputOutput'),
                          ('minSeparation', 0, 'SFFloat', 'inputOutput'),
                          ('sliderForce', 0, 'SFFloat', 'inputOutput'),
                          ('stopBounce', 0, 'SFFloat', 'inputOutput'),
                          ('stopErrorCorrection', 1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('body1', None, 'SFNode', 'inputOutput'),
                          ('body2', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 axis=(0, 1, 0),
                 forceOutput=["NONE"],
                 maxSeparation=1,
                 minSeparation=0,
                 sliderForce=0,
                 stopBounce=0,
                 stopErrorCorrection=1,
                 USE='',
                 class_='',
                 body1=None,
                 body2=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SliderJoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.axis = axis
        self.forceOutput = forceOutput
        self.maxSeparation = maxSeparation
        self.minSeparation = minSeparation
        self.sliderForce = sliderForce
        self.stopBounce = stopBounce
        self.stopErrorCorrection = stopErrorCorrection
        self.body1 = body1
        self.body2 = body2
        @property # - - - - - - - - - - - - -
        def axis(self):
            return self.__axis
        @axis.setter
        def axis(self, axis=None):
            if  axis is None:
                axis = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(axis)
            self.__axis = axis
        @property # - - - - - - - - - - - - -
        def forceOutput(self):
            return self.__forceOutput
        @forceOutput.setter
        def forceOutput(self, forceOutput=None):
            if  forceOutput is None:
                forceOutput = MFString.DEFAULT_VALUE
            isValidMFString(forceOutput)
            self.__forceOutput = forceOutput
        @property # - - - - - - - - - - - - -
        def maxSeparation(self):
            return self.__maxSeparation
        @maxSeparation.setter
        def maxSeparation(self, maxSeparation=None):
            if  maxSeparation is None:
                maxSeparation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxSeparation)
            self.__maxSeparation = maxSeparation
        @property # - - - - - - - - - - - - -
        def minSeparation(self):
            return self.__minSeparation
        @minSeparation.setter
        def minSeparation(self, minSeparation=None):
            if  minSeparation is None:
                minSeparation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minSeparation)
            self.__minSeparation = minSeparation
        @property # - - - - - - - - - - - - -
        def sliderForce(self):
            return self.__sliderForce
        @sliderForce.setter
        def sliderForce(self, sliderForce=None):
            if  sliderForce is None:
                sliderForce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(sliderForce)
            self.__sliderForce = sliderForce
        @property # - - - - - - - - - - - - -
        def stopBounce(self):
            return self.__stopBounce
        @stopBounce.setter
        def stopBounce(self, stopBounce=None):
            if  stopBounce is None:
                stopBounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stopBounce)
            self.__stopBounce = stopBounce
        @property # - - - - - - - - - - - - -
        def stopErrorCorrection(self):
            return self.__stopErrorCorrection
        @stopErrorCorrection.setter
        def stopErrorCorrection(self, stopErrorCorrection=None):
            if  stopErrorCorrection is None:
                stopErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stopErrorCorrection)
            self.__stopErrorCorrection = stopErrorCorrection
        @property # - - - - - - - - - - - - -
        def body1(self):
            return self.__body1
        @body1.setter
        def body1(self, body1=None):
            if  body1 is None:
                body1 = SFNode.DEFAULT_VALUE
            isValidSFNode(body1)
            if not isinstance(body1, object):
                raise RuntimeError(str(body1) + ' does not have a valid node type object')
            self.__body1 = body1
        @property # - - - - - - - - - - - - -
        def body2(self):
            return self.__body2
        @body2.setter
        def body2(self, body2=None):
            if  body2 is None:
                body2 = SFNode.DEFAULT_VALUE
            isValidSFNode(body2)
            if not isinstance(body2, object):
                raise RuntimeError(str(body2) + ' does not have a valid node type object')
            self.__body2 = body2

class Sound(_X3DSoundNode):
    """
    X3D element
    """
    __name__ = 'Sound'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/sound.html#Sound'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Sound'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('direction', (0, 0, 1), 'SFVec3f', 'inputOutput'),
                          ('intensity', 1, 'SFFloat', 'inputOutput'),
                          ('location', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('maxBack', 10, 'SFFloat', 'inputOutput'),
                          ('maxFront', 10, 'SFFloat', 'inputOutput'),
                          ('minBack', 1, 'SFFloat', 'inputOutput'),
                          ('minFront', 1, 'SFFloat', 'inputOutput'),
                          ('priority', 0, 'SFFloat', 'inputOutput'),
                          ('spatialize', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('source', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 direction=(0, 0, 1),
                 intensity=1,
                 location=(0, 0, 0),
                 maxBack=10,
                 maxFront=10,
                 minBack=1,
                 minFront=1,
                 priority=0,
                 spatialize=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 source=None):
        # if _DEBUG: print ('... in ConcreteNode Sound __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.direction = direction
        self.intensity = intensity
        self.location = location
        self.maxBack = maxBack
        self.maxFront = maxFront
        self.minBack = minBack
        self.minFront = minFront
        self.priority = priority
        self.spatialize = spatialize
        self.source = source
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def intensity(self):
            return self.__intensity
        @intensity.setter
        def intensity(self, intensity=None):
            if  intensity is None:
                intensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(intensity)
            self.__intensity = intensity
        @property # - - - - - - - - - - - - -
        def location(self):
            return self.__location
        @location.setter
        def location(self, location=None):
            if  location is None:
                location = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(location)
            self.__location = location
        @property # - - - - - - - - - - - - -
        def maxBack(self):
            return self.__maxBack
        @maxBack.setter
        def maxBack(self, maxBack=None):
            if  maxBack is None:
                maxBack = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxBack)
            self.__maxBack = maxBack
        @property # - - - - - - - - - - - - -
        def maxFront(self):
            return self.__maxFront
        @maxFront.setter
        def maxFront(self, maxFront=None):
            if  maxFront is None:
                maxFront = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxFront)
            self.__maxFront = maxFront
        @property # - - - - - - - - - - - - -
        def minBack(self):
            return self.__minBack
        @minBack.setter
        def minBack(self, minBack=None):
            if  minBack is None:
                minBack = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minBack)
            self.__minBack = minBack
        @property # - - - - - - - - - - - - -
        def minFront(self):
            return self.__minFront
        @minFront.setter
        def minFront(self, minFront=None):
            if  minFront is None:
                minFront = SFFloat.DEFAULT_VALUE
            isValidSFFloat(minFront)
            self.__minFront = minFront
        @property # - - - - - - - - - - - - -
        def priority(self):
            return self.__priority
        @priority.setter
        def priority(self, priority=None):
            if  priority is None:
                priority = SFFloat.DEFAULT_VALUE
            isValidSFFloat(priority)
            self.__priority = priority
        @property # - - - - - - - - - - - - -
        def spatialize(self):
            return self.__spatialize
        @spatialize.setter
        def spatialize(self, spatialize=None):
            if  spatialize is None:
                spatialize = SFBool.DEFAULT_VALUE
            isValidSFBool(spatialize)
            self.__spatialize = spatialize
        @property # - - - - - - - - - - - - -
        def source(self):
            return self.__source
        @source.setter
        def source(self, source=None):
            if  source is None:
                source = SFNode.DEFAULT_VALUE
            isValidSFNode(source)
            if not isinstance(source, object):
                raise RuntimeError(str(source) + ' does not have a valid node type object')
            self.__source = source

class Sphere(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Sphere'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry3D.html#Sphere'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Sphere'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('radius', 1, 'SFFloat', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 radius=1,
                 solid=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Sphere __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.radius = radius
        self.solid = solid
        @property # - - - - - - - - - - - - -
        def radius(self):
            return self.__radius
        @radius.setter
        def radius(self, radius=None):
            if  radius is None:
                radius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(radius)
            self.__radius = radius
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid

class SphereSensor(_X3DDragSensorNode):
    """
    X3D element
    """
    __name__ = 'SphereSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/pointingsensor.html#SphereSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SphereSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('autoOffset', True, 'SFBool', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('offset', (0, 1, 0, 0), 'SFRotation', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 autoOffset=True,
                 description='',
                 enabled=True,
                 offset=(0, 1, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SphereSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.autoOffset = autoOffset
        self.description = description
        self.enabled = enabled
        self.offset = offset
        @property # - - - - - - - - - - - - -
        def autoOffset(self):
            return self.__autoOffset
        @autoOffset.setter
        def autoOffset(self, autoOffset=None):
            if  autoOffset is None:
                autoOffset = SFBool.DEFAULT_VALUE
            isValidSFBool(autoOffset)
            self.__autoOffset = autoOffset
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def offset(self):
            return self.__offset
        @offset.setter
        def offset(self, offset=None):
            if  offset is None:
                offset = SFRotation.DEFAULT_VALUE
            isValidSFRotation(offset)
            self.__offset = offset

class SplinePositionInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'SplinePositionInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#SplinePositionInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SplinePositionInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('closed', False, 'SFBool', 'initializeOnly'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec3f', 'inputOutput'),
                          ('keyVelocity', (list()), 'MFVec3f', 'inputOutput'),
                          ('normalizeVelocity', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 closed=False,
                 key=list(),
                 keyValue=(list()),
                 keyVelocity=(list()),
                 normalizeVelocity=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SplinePositionInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.closed = closed
        self.key = key
        self.keyValue = keyValue
        self.keyVelocity = keyVelocity
        self.normalizeVelocity = normalizeVelocity
        @property # - - - - - - - - - - - - -
        def closed(self):
            return self.__closed
        @closed.setter
        def closed(self, closed=None):
            if  closed is None:
                closed = SFBool.DEFAULT_VALUE
            isValidSFBool(closed)
            self.__closed = closed
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(keyValue)
            self.__keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def keyVelocity(self):
            return self.__keyVelocity
        @keyVelocity.setter
        def keyVelocity(self, keyVelocity=None):
            if  keyVelocity is None:
                keyVelocity = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(keyVelocity)
            self.__keyVelocity = keyVelocity
        @property # - - - - - - - - - - - - -
        def normalizeVelocity(self):
            return self.__normalizeVelocity
        @normalizeVelocity.setter
        def normalizeVelocity(self, normalizeVelocity=None):
            if  normalizeVelocity is None:
                normalizeVelocity = SFBool.DEFAULT_VALUE
            isValidSFBool(normalizeVelocity)
            self.__normalizeVelocity = normalizeVelocity

class SplinePositionInterpolator2D(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'SplinePositionInterpolator2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#SplinePositionInterpolator2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SplinePositionInterpolator2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('closed', False, 'SFBool', 'initializeOnly'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFVec2f', 'inputOutput'),
                          ('keyVelocity', (list()), 'MFVec2f', 'inputOutput'),
                          ('normalizeVelocity', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 closed=False,
                 key=list(),
                 keyValue=(list()),
                 keyVelocity=(list()),
                 normalizeVelocity=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SplinePositionInterpolator2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.closed = closed
        self.key = key
        self.keyValue = keyValue
        self.keyVelocity = keyVelocity
        self.normalizeVelocity = normalizeVelocity
        @property # - - - - - - - - - - - - -
        def closed(self):
            return self.__closed
        @closed.setter
        def closed(self, closed=None):
            if  closed is None:
                closed = SFBool.DEFAULT_VALUE
            isValidSFBool(closed)
            self.__closed = closed
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(keyValue)
            self.__keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def keyVelocity(self):
            return self.__keyVelocity
        @keyVelocity.setter
        def keyVelocity(self, keyVelocity=None):
            if  keyVelocity is None:
                keyVelocity = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(keyVelocity)
            self.__keyVelocity = keyVelocity
        @property # - - - - - - - - - - - - -
        def normalizeVelocity(self):
            return self.__normalizeVelocity
        @normalizeVelocity.setter
        def normalizeVelocity(self, normalizeVelocity=None):
            if  normalizeVelocity is None:
                normalizeVelocity = SFBool.DEFAULT_VALUE
            isValidSFBool(normalizeVelocity)
            self.__normalizeVelocity = normalizeVelocity

class SplineScalarInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'SplineScalarInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#SplineScalarInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SplineScalarInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('closed', False, 'SFBool', 'initializeOnly'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', list(), 'MFFloat', 'inputOutput'),
                          ('keyVelocity', list(), 'MFFloat', 'inputOutput'),
                          ('normalizeVelocity', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 closed=False,
                 key=list(),
                 keyValue=list(),
                 keyVelocity=list(),
                 normalizeVelocity=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SplineScalarInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.closed = closed
        self.key = key
        self.keyValue = keyValue
        self.keyVelocity = keyVelocity
        self.normalizeVelocity = normalizeVelocity
        @property # - - - - - - - - - - - - -
        def closed(self):
            return self.__closed
        @closed.setter
        def closed(self, closed=None):
            if  closed is None:
                closed = SFBool.DEFAULT_VALUE
            isValidSFBool(closed)
            self.__closed = closed
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFFloat.DEFAULT_VALUE
            isValidMFFloat(keyValue)
            self.__keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def keyVelocity(self):
            return self.__keyVelocity
        @keyVelocity.setter
        def keyVelocity(self, keyVelocity=None):
            if  keyVelocity is None:
                keyVelocity = MFFloat.DEFAULT_VALUE
            isValidMFFloat(keyVelocity)
            self.__keyVelocity = keyVelocity
        @property # - - - - - - - - - - - - -
        def normalizeVelocity(self):
            return self.__normalizeVelocity
        @normalizeVelocity.setter
        def normalizeVelocity(self, normalizeVelocity=None):
            if  normalizeVelocity is None:
                normalizeVelocity = SFBool.DEFAULT_VALUE
            isValidSFBool(normalizeVelocity)
            self.__normalizeVelocity = normalizeVelocity

class SpotLight(_X3DLightNode):
    """
    Linear attenuation may occur at level 2, full support at level 3.
    """
    __name__ = 'SpotLight'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/lighting.html#SpotLight'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SpotLight'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ambientIntensity', 0, 'SFFloat', 'inputOutput'),
                          ('attenuation', (1, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('beamWidth', 0.7854, 'SFFloat', 'inputOutput'),
                          ('color', (1, 1, 1), 'SFColor', 'inputOutput'),
                          ('cutOffAngle', 1.570796, 'SFFloat', 'inputOutput'),
                          ('direction', (0, 0, -1), 'SFVec3f', 'inputOutput'),
                          ('global_', True, 'SFBool', 'inputOutput'),
                          ('intensity', 1, 'SFFloat', 'inputOutput'),
                          ('location', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('on', True, 'SFBool', 'inputOutput'),
                          ('radius', 100, 'SFFloat', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ambientIntensity=0,
                 attenuation=(1, 0, 0),
                 beamWidth=0.7854,
                 color=(1, 1, 1),
                 cutOffAngle=1.570796,
                 direction=(0, 0, -1),
                 global_=True,
                 intensity=1,
                 location=(0, 0, 0),
                 on=True,
                 radius=100,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SpotLight __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ambientIntensity = ambientIntensity
        self.attenuation = attenuation
        self.beamWidth = beamWidth
        self.color = color
        self.cutOffAngle = cutOffAngle
        self.direction = direction
        self.global_ = global_
        self.intensity = intensity
        self.location = location
        self.on = on
        self.radius = radius
        @property # - - - - - - - - - - - - -
        def ambientIntensity(self):
            return self.__ambientIntensity
        @ambientIntensity.setter
        def ambientIntensity(self, ambientIntensity=None):
            if  ambientIntensity is None:
                ambientIntensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(ambientIntensity)
            self.__ambientIntensity = ambientIntensity
        @property # - - - - - - - - - - - - -
        def attenuation(self):
            return self.__attenuation
        @attenuation.setter
        def attenuation(self, attenuation=None):
            if  attenuation is None:
                attenuation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(attenuation)
            self.__attenuation = attenuation
        @property # - - - - - - - - - - - - -
        def beamWidth(self):
            return self.__beamWidth
        @beamWidth.setter
        def beamWidth(self, beamWidth=None):
            if  beamWidth is None:
                beamWidth = SFFloat.DEFAULT_VALUE
            isValidSFFloat(beamWidth)
            self.__beamWidth = beamWidth
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFColor.DEFAULT_VALUE
            isValidSFColor(color)
            self.__color = color
        @property # - - - - - - - - - - - - -
        def cutOffAngle(self):
            return self.__cutOffAngle
        @cutOffAngle.setter
        def cutOffAngle(self, cutOffAngle=None):
            if  cutOffAngle is None:
                cutOffAngle = SFFloat.DEFAULT_VALUE
            isValidSFFloat(cutOffAngle)
            self.__cutOffAngle = cutOffAngle
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def global_(self):
            return self.__global_
        @global_.setter
        def global_(self, global_=None):
            if  global_ is None:
                global_ = SFBool.DEFAULT_VALUE
            isValidSFBool(global_)
            self.__global_ = global_
        @property # - - - - - - - - - - - - -
        def intensity(self):
            return self.__intensity
        @intensity.setter
        def intensity(self, intensity=None):
            if  intensity is None:
                intensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(intensity)
            self.__intensity = intensity
        @property # - - - - - - - - - - - - -
        def location(self):
            return self.__location
        @location.setter
        def location(self, location=None):
            if  location is None:
                location = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(location)
            self.__location = location
        @property # - - - - - - - - - - - - -
        def on(self):
            return self.__on
        @on.setter
        def on(self, on=None):
            if  on is None:
                on = SFBool.DEFAULT_VALUE
            isValidSFBool(on)
            self.__on = on
        @property # - - - - - - - - - - - - -
        def radius(self):
            return self.__radius
        @radius.setter
        def radius(self, radius=None):
            if  radius is None:
                radius = SFFloat.DEFAULT_VALUE
            isValidSFFloat(radius)
            self.__radius = radius

class SquadOrientationInterpolator(_X3DInterpolatorNode):
    """
    X3D element
    """
    __name__ = 'SquadOrientationInterpolator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/interp.html#SquadOrientationInterpolator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SquadOrientationInterpolator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('key', list(), 'MFFloat', 'inputOutput'),
                          ('keyValue', (list()), 'MFRotation', 'inputOutput'),
                          ('normalizeVelocity', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 key=list(),
                 keyValue=(list()),
                 normalizeVelocity=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode SquadOrientationInterpolator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.key = key
        self.keyValue = keyValue
        self.normalizeVelocity = normalizeVelocity
        @property # - - - - - - - - - - - - -
        def key(self):
            return self.__key
        @key.setter
        def key(self, key=None):
            if  key is None:
                key = MFFloat.DEFAULT_VALUE
            isValidMFFloat(key)
            self.__key = key
        @property # - - - - - - - - - - - - -
        def keyValue(self):
            return self.__keyValue
        @keyValue.setter
        def keyValue(self, keyValue=None):
            if  keyValue is None:
                keyValue = MFRotation.DEFAULT_VALUE
            isValidMFRotation(keyValue)
            self.__keyValue = keyValue
        @property # - - - - - - - - - - - - -
        def normalizeVelocity(self):
            return self.__normalizeVelocity
        @normalizeVelocity.setter
        def normalizeVelocity(self, normalizeVelocity=None):
            if  normalizeVelocity is None:
                normalizeVelocity = SFBool.DEFAULT_VALUE
            isValidSFBool(normalizeVelocity)
            self.__normalizeVelocity = normalizeVelocity

class StaticGroup(_X3DChildNode):
    """
    StaticGroup is similar to Group node but does not allow access to children after creation time.
    """
    __name__ = 'StaticGroup'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/group.html#StaticGroup'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#StaticGroup'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode StaticGroup __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class StringSensor(_X3DKeyDeviceSensorNode):
    """
    X3D element
    """
    __name__ = 'StringSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/keyboard.html#StringSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#StringSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('deletionAllowed', True, 'SFBool', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 deletionAllowed=True,
                 enabled=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode StringSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.deletionAllowed = deletionAllowed
        self.enabled = enabled
        @property # - - - - - - - - - - - - -
        def deletionAllowed(self):
            return self.__deletionAllowed
        @deletionAllowed.setter
        def deletionAllowed(self, deletionAllowed=None):
            if  deletionAllowed is None:
                deletionAllowed = SFBool.DEFAULT_VALUE
            isValidSFBool(deletionAllowed)
            self.__deletionAllowed = deletionAllowed
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled

class SurfaceEmitter(_X3DParticleEmitterNode):
    """
    X3D element
    """
    __name__ = 'SurfaceEmitter'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#SurfaceEmitter'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#SurfaceEmitter'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('coordIndex', [-1], 'MFInt32', 'initializeOnly'),
                          ('mass', 0, 'SFFloat', 'inputOutput'),
                          ('speed', 0, 'SFFloat', 'inputOutput'),
                          ('surfaceArea', 0, 'SFFloat', 'initializeOnly'),
                          ('variation', 0.25, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('surface', None, 'SFNode', 'initializeOnly')]
    def __init__(self,
                 DEF='',
                 coordIndex=[-1],
                 mass=0,
                 speed=0,
                 surfaceArea=0,
                 variation=0.25,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 surface=None):
        # if _DEBUG: print ('... in ConcreteNode SurfaceEmitter __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.coordIndex = coordIndex
        self.mass = mass
        self.speed = speed
        self.surfaceArea = surfaceArea
        self.variation = variation
        self.surface = surface
        @property # - - - - - - - - - - - - -
        def coordIndex(self):
            return self.__coordIndex
        @coordIndex.setter
        def coordIndex(self, coordIndex=None):
            if  coordIndex is None:
                coordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(coordIndex)
            self.__coordIndex = coordIndex
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def surfaceArea(self):
            return self.__surfaceArea
        @surfaceArea.setter
        def surfaceArea(self, surfaceArea=None):
            if  surfaceArea is None:
                surfaceArea = SFFloat.DEFAULT_VALUE
            isValidSFFloat(surfaceArea)
            self.__surfaceArea = surfaceArea
        @property # - - - - - - - - - - - - -
        def variation(self):
            return self.__variation
        @variation.setter
        def variation(self, variation=None):
            if  variation is None:
                variation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(variation)
            self.__variation = variation
        @property # - - - - - - - - - - - - -
        def surface(self):
            return self.__surface
        @surface.setter
        def surface(self, surface=None):
            if  surface is None:
                surface = SFNode.DEFAULT_VALUE
            isValidSFNode(surface)
            if not isinstance(surface, object):
                raise RuntimeError(str(surface) + ' does not have a valid node type object')
            self.__surface = surface

class Switch(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'Switch'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/group.html#Switch'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Switch'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('whichChoice', -1, 'SFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 whichChoice=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Switch __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.whichChoice = whichChoice
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def whichChoice(self):
            return self.__whichChoice
        @whichChoice.setter
        def whichChoice(self, whichChoice=None):
            if  whichChoice is None:
                whichChoice = SFInt32.DEFAULT_VALUE
            isValidSFInt32(whichChoice)
            self.__whichChoice = whichChoice
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class TexCoordChaser2D(_X3DChaserNode):
    """
    X3D element
    """
    __name__ = 'TexCoordChaser2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#TexCoordChaser2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TexCoordChaser2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('duration', 1, 'SFTime', 'initializeOnly'),
                          ('initialDestination', (list()), 'MFVec2f', 'initializeOnly'),
                          ('initialValue', (list()), 'MFVec2f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 duration=1,
                 initialDestination=(list()),
                 initialValue=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TexCoordChaser2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.duration = duration
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def duration(self):
            return self.__duration
        @duration.setter
        def duration(self, duration=None):
            if  duration is None:
                duration = SFTime.DEFAULT_VALUE
            isValidSFTime(duration)
            self.__duration = duration
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(initialValue)
            self.__initialValue = initialValue

class TexCoordDamper2D(_X3DDamperNode):
    """
    X3D element
    """
    __name__ = 'TexCoordDamper2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/followers.html#TexCoordDamper2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TexCoordDamper2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('initialDestination', (list()), 'MFVec2f', 'initializeOnly'),
                          ('initialValue', (list()), 'MFVec2f', 'initializeOnly'),
                          ('order', 3, 'SFInt32', 'initializeOnly'),
                          ('tau', 0.3, 'SFTime', 'inputOutput'),
                          ('tolerance', -1, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 initialDestination=(list()),
                 initialValue=(list()),
                 order=3,
                 tau=0.3,
                 tolerance=-1,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TexCoordDamper2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.initialDestination = initialDestination
        self.initialValue = initialValue
        self.order = order
        self.tau = tau
        self.tolerance = tolerance
        @property # - - - - - - - - - - - - -
        def initialDestination(self):
            return self.__initialDestination
        @initialDestination.setter
        def initialDestination(self, initialDestination=None):
            if  initialDestination is None:
                initialDestination = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(initialDestination)
            self.__initialDestination = initialDestination
        @property # - - - - - - - - - - - - -
        def initialValue(self):
            return self.__initialValue
        @initialValue.setter
        def initialValue(self, initialValue=None):
            if  initialValue is None:
                initialValue = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(initialValue)
            self.__initialValue = initialValue
        @property # - - - - - - - - - - - - -
        def order(self):
            return self.__order
        @order.setter
        def order(self, order=None):
            if  order is None:
                order = SFInt32.DEFAULT_VALUE
            isValidSFInt32(order)
            self.__order = order
        @property # - - - - - - - - - - - - -
        def tau(self):
            return self.__tau
        @tau.setter
        def tau(self, tau=None):
            if  tau is None:
                tau = SFTime.DEFAULT_VALUE
            isValidSFTime(tau)
            self.__tau = tau
        @property # - - - - - - - - - - - - -
        def tolerance(self):
            return self.__tolerance
        @tolerance.setter
        def tolerance(self, tolerance=None):
            if  tolerance is None:
                tolerance = SFFloat.DEFAULT_VALUE
            isValidSFFloat(tolerance)
            self.__tolerance = tolerance

class Text(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'Text'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/text.html#Text'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Text'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('length', list(), 'MFFloat', 'inputOutput'),
                          ('maxExtent', 0.0, 'SFFloat', 'inputOutput'),
                          ('solid', False, 'SFBool', 'initializeOnly'),
                          ('string', list(), 'MFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('fontStyle', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 length=list(),
                 maxExtent=0.0,
                 solid=False,
                 string=list(),
                 USE='',
                 class_='',
                 fontStyle=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Text __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.length = length
        self.maxExtent = maxExtent
        self.solid = solid
        self.string = string
        self.fontStyle = fontStyle
        @property # - - - - - - - - - - - - -
        def length(self):
            return self.__length
        @length.setter
        def length(self, length=None):
            if  length is None:
                length = MFFloat.DEFAULT_VALUE
            isValidMFFloat(length)
            self.__length = length
        @property # - - - - - - - - - - - - -
        def maxExtent(self):
            return self.__maxExtent
        @maxExtent.setter
        def maxExtent(self, maxExtent=None):
            if  maxExtent is None:
                maxExtent = SFFloat.DEFAULT_VALUE
            isValidSFFloat(maxExtent)
            self.__maxExtent = maxExtent
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def string(self):
            return self.__string
        @string.setter
        def string(self, string=None):
            if  string is None:
                string = MFString.DEFAULT_VALUE
            isValidMFString(string)
            self.__string = string
        @property # - - - - - - - - - - - - -
        def fontStyle(self):
            return self.__fontStyle
        @fontStyle.setter
        def fontStyle(self, fontStyle=None):
            if  fontStyle is None:
                fontStyle = SFNode.DEFAULT_VALUE
            isValidSFNode(fontStyle)
            if not isinstance(fontStyle, object):
                raise RuntimeError(str(fontStyle) + ' does not have a valid node type object')
            self.__fontStyle = fontStyle

class TextureBackground(_X3DBackgroundNode):
    """
    X3D element
    """
    __name__ = 'TextureBackground'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/enveffects.html#TextureBackground'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureBackground'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('groundAngle', list(), 'MFFloat', 'inputOutput'),
                          ('groundColor', (list()), 'MFColor', 'inputOutput'),
                          ('skyAngle', list(), 'MFFloat', 'inputOutput'),
                          ('skyColor', [0, 0, 0], 'MFColor', 'inputOutput'),
                          ('transparency', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('backTexture', None, 'SFNode', 'inputOutput'),
                          ('bottomTexture', None, 'SFNode', 'inputOutput'),
                          ('frontTexture', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('leftTexture', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('rightTexture', None, 'SFNode', 'inputOutput'),
                          ('topTexture', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 groundAngle=list(),
                 groundColor=(list()),
                 skyAngle=list(),
                 skyColor=[0, 0, 0],
                 transparency=0,
                 USE='',
                 class_='',
                 backTexture=None,
                 bottomTexture=None,
                 frontTexture=None,
                 IS=None,
                 leftTexture=None,
                 metadata=None,
                 rightTexture=None,
                 topTexture=None):
        # if _DEBUG: print ('... in ConcreteNode TextureBackground __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.groundAngle = groundAngle
        self.groundColor = groundColor
        self.skyAngle = skyAngle
        self.skyColor = skyColor
        self.transparency = transparency
        self.backTexture = backTexture
        self.bottomTexture = bottomTexture
        self.frontTexture = frontTexture
        self.leftTexture = leftTexture
        self.rightTexture = rightTexture
        self.topTexture = topTexture
        @property # - - - - - - - - - - - - -
        def groundAngle(self):
            return self.__groundAngle
        @groundAngle.setter
        def groundAngle(self, groundAngle=None):
            if  groundAngle is None:
                groundAngle = MFFloat.DEFAULT_VALUE
            isValidMFFloat(groundAngle)
            self.__groundAngle = groundAngle
        @property # - - - - - - - - - - - - -
        def groundColor(self):
            return self.__groundColor
        @groundColor.setter
        def groundColor(self, groundColor=None):
            if  groundColor is None:
                groundColor = MFColor.DEFAULT_VALUE
            isValidMFColor(groundColor)
            self.__groundColor = groundColor
        @property # - - - - - - - - - - - - -
        def skyAngle(self):
            return self.__skyAngle
        @skyAngle.setter
        def skyAngle(self, skyAngle=None):
            if  skyAngle is None:
                skyAngle = MFFloat.DEFAULT_VALUE
            isValidMFFloat(skyAngle)
            self.__skyAngle = skyAngle
        @property # - - - - - - - - - - - - -
        def skyColor(self):
            return self.__skyColor
        @skyColor.setter
        def skyColor(self, skyColor=None):
            if  skyColor is None:
                skyColor = MFColor.DEFAULT_VALUE
            isValidMFColor(skyColor)
            self.__skyColor = skyColor
        @property # - - - - - - - - - - - - -
        def transparency(self):
            return self.__transparency
        @transparency.setter
        def transparency(self, transparency=None):
            if  transparency is None:
                transparency = SFFloat.DEFAULT_VALUE
            isValidSFFloat(transparency)
            self.__transparency = transparency
        @property # - - - - - - - - - - - - -
        def backTexture(self):
            return self.__backTexture
        @backTexture.setter
        def backTexture(self, backTexture=None):
            if  backTexture is None:
                backTexture = SFNode.DEFAULT_VALUE
            isValidSFNode(backTexture)
            if not isinstance(backTexture, object):
                raise RuntimeError(str(backTexture) + ' does not have a valid node type object')
            self.__backTexture = backTexture
        @property # - - - - - - - - - - - - -
        def bottomTexture(self):
            return self.__bottomTexture
        @bottomTexture.setter
        def bottomTexture(self, bottomTexture=None):
            if  bottomTexture is None:
                bottomTexture = SFNode.DEFAULT_VALUE
            isValidSFNode(bottomTexture)
            if not isinstance(bottomTexture, object):
                raise RuntimeError(str(bottomTexture) + ' does not have a valid node type object')
            self.__bottomTexture = bottomTexture
        @property # - - - - - - - - - - - - -
        def frontTexture(self):
            return self.__frontTexture
        @frontTexture.setter
        def frontTexture(self, frontTexture=None):
            if  frontTexture is None:
                frontTexture = SFNode.DEFAULT_VALUE
            isValidSFNode(frontTexture)
            if not isinstance(frontTexture, object):
                raise RuntimeError(str(frontTexture) + ' does not have a valid node type object')
            self.__frontTexture = frontTexture
        @property # - - - - - - - - - - - - -
        def leftTexture(self):
            return self.__leftTexture
        @leftTexture.setter
        def leftTexture(self, leftTexture=None):
            if  leftTexture is None:
                leftTexture = SFNode.DEFAULT_VALUE
            isValidSFNode(leftTexture)
            if not isinstance(leftTexture, object):
                raise RuntimeError(str(leftTexture) + ' does not have a valid node type object')
            self.__leftTexture = leftTexture
        @property # - - - - - - - - - - - - -
        def rightTexture(self):
            return self.__rightTexture
        @rightTexture.setter
        def rightTexture(self, rightTexture=None):
            if  rightTexture is None:
                rightTexture = SFNode.DEFAULT_VALUE
            isValidSFNode(rightTexture)
            if not isinstance(rightTexture, object):
                raise RuntimeError(str(rightTexture) + ' does not have a valid node type object')
            self.__rightTexture = rightTexture
        @property # - - - - - - - - - - - - -
        def topTexture(self):
            return self.__topTexture
        @topTexture.setter
        def topTexture(self, topTexture=None):
            if  topTexture is None:
                topTexture = SFNode.DEFAULT_VALUE
            isValidSFNode(topTexture)
            if not isinstance(topTexture, object):
                raise RuntimeError(str(topTexture) + ' does not have a valid node type object')
            self.__topTexture = topTexture

class TextureCoordinate(_X3DTextureCoordinateNode):
    """
    X3D element
    """
    __name__ = 'TextureCoordinate'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#TextureCoordinate'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureCoordinate'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('point', (list()), 'MFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 point=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureCoordinate __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.point = point
        @property # - - - - - - - - - - - - -
        def point(self):
            return self.__point
        @point.setter
        def point(self, point=None):
            if  point is None:
                point = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(point)
            self.__point = point

class TextureCoordinate3D(_X3DTextureCoordinateNode):
    """
    X3D element
    """
    __name__ = 'TextureCoordinate3D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#TextureCoordinate3D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureCoordinate3D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('point', (list()), 'MFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 point=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureCoordinate3D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.point = point
        @property # - - - - - - - - - - - - -
        def point(self):
            return self.__point
        @point.setter
        def point(self, point=None):
            if  point is None:
                point = MFVec3f.DEFAULT_VALUE
            isValidMFVec3f(point)
            self.__point = point

class TextureCoordinate4D(_X3DTextureCoordinateNode):
    """
    X3D element
    """
    __name__ = 'TextureCoordinate4D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#TextureCoordinate4D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureCoordinate4D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('point', (list()), 'MFVec4f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 point=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureCoordinate4D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.point = point
        @property # - - - - - - - - - - - - -
        def point(self):
            return self.__point
        @point.setter
        def point(self, point=None):
            if  point is None:
                point = MFVec4f.DEFAULT_VALUE
            isValidMFVec4f(point)
            self.__point = point

class TextureCoordinateGenerator(_X3DTextureCoordinateNode):
    """
    X3D element
    """
    __name__ = 'TextureCoordinateGenerator'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#TextureCoordinateGenerator'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureCoordinateGenerator'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('mode', 'SPHERE', 'SFString', 'inputOutput'),
                          ('parameter', list(), 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 mode='SPHERE',
                 parameter=list(),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureCoordinateGenerator __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.mode = mode
        self.parameter = parameter
        @property # - - - - - - - - - - - - -
        def mode(self):
            return self.__mode
        @mode.setter
        def mode(self, mode=None):
            if  mode is None:
                mode = SFString.DEFAULT_VALUE
            isValidSFString(mode)
            self.__mode = mode
        @property # - - - - - - - - - - - - -
        def parameter(self):
            return self.__parameter
        @parameter.setter
        def parameter(self, parameter=None):
            if  parameter is None:
                parameter = MFFloat.DEFAULT_VALUE
            isValidMFFloat(parameter)
            self.__parameter = parameter

class TextureProperties(_X3DNode):
    """
    X3D element
    """
    __name__ = 'TextureProperties'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#TextureProperties'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureProperties'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('anisotropicDegree', 1, 'SFFloat', 'inputOutput'),
                          ('borderColor', (0, 0, 0, 0), 'SFColorRGBA', 'inputOutput'),
                          ('borderWidth', 0, 'SFInt32', 'inputOutput'),
                          ('boundaryModeR', 'REPEAT', 'SFString', 'inputOutput'),
                          ('boundaryModeS', 'REPEAT', 'SFString', 'inputOutput'),
                          ('boundaryModeT', 'REPEAT', 'SFString', 'inputOutput'),
                          ('generateMipMaps', False, 'SFBool', 'initializeOnly'),
                          ('magnificationFilter', 'FASTEST', 'SFString', 'inputOutput'),
                          ('minificationFilter', 'FASTEST', 'SFString', 'inputOutput'),
                          ('textureCompression', 'FASTEST', 'SFString', 'inputOutput'),
                          ('texturePriority', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 anisotropicDegree=1,
                 borderColor=(0, 0, 0, 0),
                 borderWidth=0,
                 boundaryModeR='REPEAT',
                 boundaryModeS='REPEAT',
                 boundaryModeT='REPEAT',
                 generateMipMaps=False,
                 magnificationFilter='FASTEST',
                 minificationFilter='FASTEST',
                 textureCompression='FASTEST',
                 texturePriority=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureProperties __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.anisotropicDegree = anisotropicDegree
        self.borderColor = borderColor
        self.borderWidth = borderWidth
        self.boundaryModeR = boundaryModeR
        self.boundaryModeS = boundaryModeS
        self.boundaryModeT = boundaryModeT
        self.generateMipMaps = generateMipMaps
        self.magnificationFilter = magnificationFilter
        self.minificationFilter = minificationFilter
        self.textureCompression = textureCompression
        self.texturePriority = texturePriority
        @property # - - - - - - - - - - - - -
        def anisotropicDegree(self):
            return self.__anisotropicDegree
        @anisotropicDegree.setter
        def anisotropicDegree(self, anisotropicDegree=None):
            if  anisotropicDegree is None:
                anisotropicDegree = SFFloat.DEFAULT_VALUE
            isValidSFFloat(anisotropicDegree)
            self.__anisotropicDegree = anisotropicDegree
        @property # - - - - - - - - - - - - -
        def borderColor(self):
            return self.__borderColor
        @borderColor.setter
        def borderColor(self, borderColor=None):
            if  borderColor is None:
                borderColor = SFColorRGBA.DEFAULT_VALUE
            isValidSFColorRGBA(borderColor)
            self.__borderColor = borderColor
        @property # - - - - - - - - - - - - -
        def borderWidth(self):
            return self.__borderWidth
        @borderWidth.setter
        def borderWidth(self, borderWidth=None):
            if  borderWidth is None:
                borderWidth = SFInt32.DEFAULT_VALUE
            isValidSFInt32(borderWidth)
            self.__borderWidth = borderWidth
        @property # - - - - - - - - - - - - -
        def boundaryModeR(self):
            return self.__boundaryModeR
        @boundaryModeR.setter
        def boundaryModeR(self, boundaryModeR=None):
            if  boundaryModeR is None:
                boundaryModeR = SFString.DEFAULT_VALUE
            isValidSFString(boundaryModeR)
            self.__boundaryModeR = boundaryModeR
        @property # - - - - - - - - - - - - -
        def boundaryModeS(self):
            return self.__boundaryModeS
        @boundaryModeS.setter
        def boundaryModeS(self, boundaryModeS=None):
            if  boundaryModeS is None:
                boundaryModeS = SFString.DEFAULT_VALUE
            isValidSFString(boundaryModeS)
            self.__boundaryModeS = boundaryModeS
        @property # - - - - - - - - - - - - -
        def boundaryModeT(self):
            return self.__boundaryModeT
        @boundaryModeT.setter
        def boundaryModeT(self, boundaryModeT=None):
            if  boundaryModeT is None:
                boundaryModeT = SFString.DEFAULT_VALUE
            isValidSFString(boundaryModeT)
            self.__boundaryModeT = boundaryModeT
        @property # - - - - - - - - - - - - -
        def generateMipMaps(self):
            return self.__generateMipMaps
        @generateMipMaps.setter
        def generateMipMaps(self, generateMipMaps=None):
            if  generateMipMaps is None:
                generateMipMaps = SFBool.DEFAULT_VALUE
            isValidSFBool(generateMipMaps)
            self.__generateMipMaps = generateMipMaps
        @property # - - - - - - - - - - - - -
        def magnificationFilter(self):
            return self.__magnificationFilter
        @magnificationFilter.setter
        def magnificationFilter(self, magnificationFilter=None):
            if  magnificationFilter is None:
                magnificationFilter = SFString.DEFAULT_VALUE
            isValidSFString(magnificationFilter)
            self.__magnificationFilter = magnificationFilter
        @property # - - - - - - - - - - - - -
        def minificationFilter(self):
            return self.__minificationFilter
        @minificationFilter.setter
        def minificationFilter(self, minificationFilter=None):
            if  minificationFilter is None:
                minificationFilter = SFString.DEFAULT_VALUE
            isValidSFString(minificationFilter)
            self.__minificationFilter = minificationFilter
        @property # - - - - - - - - - - - - -
        def textureCompression(self):
            return self.__textureCompression
        @textureCompression.setter
        def textureCompression(self, textureCompression=None):
            if  textureCompression is None:
                textureCompression = SFString.DEFAULT_VALUE
            isValidSFString(textureCompression)
            self.__textureCompression = textureCompression
        @property # - - - - - - - - - - - - -
        def texturePriority(self):
            return self.__texturePriority
        @texturePriority.setter
        def texturePriority(self, texturePriority=None):
            if  texturePriority is None:
                texturePriority = SFFloat.DEFAULT_VALUE
            isValidSFFloat(texturePriority)
            self.__texturePriority = texturePriority

class TextureTransform(_X3DTextureTransformNode):
    """
    X3D element
    """
    __name__ = 'TextureTransform'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texturing.html#TextureTransform'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureTransform'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('center', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('rotation', 0, 'SFFloat', 'inputOutput'),
                          ('scale', (1, 1), 'SFVec2f', 'inputOutput'),
                          ('translation', (0, 0), 'SFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 center=(0, 0),
                 rotation=0,
                 scale=(1, 1),
                 translation=(0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureTransform __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.center = center
        self.rotation = rotation
        self.scale = scale
        self.translation = translation
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec2f.DEFAULT_VALUE
            isValidSFVec2f(translation)
            self.__translation = translation

class TextureTransform3D(_X3DTextureTransformNode):
    """
    X3D element
    """
    __name__ = 'TextureTransform3D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#TextureTransform3D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureTransform3D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 center=(0, 0, 0),
                 rotation=(0, 0, 1, 0),
                 scale=(1, 1, 1),
                 translation=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureTransform3D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.center = center
        self.rotation = rotation
        self.scale = scale
        self.translation = translation
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation

class TextureTransformMatrix3D(_X3DTextureTransformNode):
    """
    X3D element
    """
    __name__ = 'TextureTransformMatrix3D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/texture3D.html#TextureTransformMatrix3D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TextureTransformMatrix3D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('matrix', (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1), 'SFMatrix4f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 matrix=(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TextureTransformMatrix3D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.matrix = matrix
        @property # - - - - - - - - - - - - -
        def matrix(self):
            return self.__matrix
        @matrix.setter
        def matrix(self, matrix=None):
            if  matrix is None:
                matrix = SFMatrix4f.DEFAULT_VALUE
            isValidSFMatrix4f(matrix)
            self.__matrix = matrix

class TimeSensor(_X3DTimeDependentNode):
    """
    X3D element
    """
    __name__ = 'TimeSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/time.html#TimeSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TimeSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('cycleInterval', 1.0, 'SFTime', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('loop', False, 'SFBool', 'inputOutput'),
                          ('pauseTime', 0, 'SFTime', 'inputOutput'),
                          ('resumeTime', 0, 'SFTime', 'inputOutput'),
                          ('startTime', 0, 'SFTime', 'inputOutput'),
                          ('stopTime', 0, 'SFTime', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 cycleInterval=1.0,
                 enabled=True,
                 loop=False,
                 pauseTime=0,
                 resumeTime=0,
                 startTime=0,
                 stopTime=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TimeSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.cycleInterval = cycleInterval
        self.enabled = enabled
        self.loop = loop
        self.pauseTime = pauseTime
        self.resumeTime = resumeTime
        self.startTime = startTime
        self.stopTime = stopTime
        @property # - - - - - - - - - - - - -
        def cycleInterval(self):
            return self.__cycleInterval
        @cycleInterval.setter
        def cycleInterval(self, cycleInterval=None):
            if  cycleInterval is None:
                cycleInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(cycleInterval)
            self.__cycleInterval = cycleInterval
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def loop(self):
            return self.__loop
        @loop.setter
        def loop(self, loop=None):
            if  loop is None:
                loop = SFBool.DEFAULT_VALUE
            isValidSFBool(loop)
            self.__loop = loop
        @property # - - - - - - - - - - - - -
        def pauseTime(self):
            return self.__pauseTime
        @pauseTime.setter
        def pauseTime(self, pauseTime=None):
            if  pauseTime is None:
                pauseTime = SFTime.DEFAULT_VALUE
            isValidSFTime(pauseTime)
            self.__pauseTime = pauseTime
        @property # - - - - - - - - - - - - -
        def resumeTime(self):
            return self.__resumeTime
        @resumeTime.setter
        def resumeTime(self, resumeTime=None):
            if  resumeTime is None:
                resumeTime = SFTime.DEFAULT_VALUE
            isValidSFTime(resumeTime)
            self.__resumeTime = resumeTime
        @property # - - - - - - - - - - - - -
        def startTime(self):
            return self.__startTime
        @startTime.setter
        def startTime(self, startTime=None):
            if  startTime is None:
                startTime = SFTime.DEFAULT_VALUE
            isValidSFTime(startTime)
            self.__startTime = startTime
        @property # - - - - - - - - - - - - -
        def stopTime(self):
            return self.__stopTime
        @stopTime.setter
        def stopTime(self, stopTime=None):
            if  stopTime is None:
                stopTime = SFTime.DEFAULT_VALUE
            isValidSFTime(stopTime)
            self.__stopTime = stopTime

class TimeTrigger(_X3DTriggerNode):
    """
    X3D element
    """
    __name__ = 'TimeTrigger'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/utils.html#TimeTrigger'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TimeTrigger'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TimeTrigger __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only

class ToneMappedVolumeStyle(_X3DComposableVolumeRenderStyleNode):
    """
    X3D element
    """
    __name__ = 'ToneMappedVolumeStyle'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#ToneMappedVolumeStyle'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ToneMappedVolumeStyle'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('coolColor', (0, 0, 1, 0), 'SFColorRGBA', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('warmColor', (1, 1, 0, 0), 'SFColorRGBA', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('surfaceNormals', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 coolColor=(0, 0, 1, 0),
                 enabled=True,
                 warmColor=(1, 1, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 surfaceNormals=None):
        # if _DEBUG: print ('... in ConcreteNode ToneMappedVolumeStyle __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.coolColor = coolColor
        self.enabled = enabled
        self.warmColor = warmColor
        self.surfaceNormals = surfaceNormals
        @property # - - - - - - - - - - - - -
        def coolColor(self):
            return self.__coolColor
        @coolColor.setter
        def coolColor(self, coolColor=None):
            if  coolColor is None:
                coolColor = SFColorRGBA.DEFAULT_VALUE
            isValidSFColorRGBA(coolColor)
            self.__coolColor = coolColor
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def warmColor(self):
            return self.__warmColor
        @warmColor.setter
        def warmColor(self, warmColor=None):
            if  warmColor is None:
                warmColor = SFColorRGBA.DEFAULT_VALUE
            isValidSFColorRGBA(warmColor)
            self.__warmColor = warmColor
        @property # - - - - - - - - - - - - -
        def surfaceNormals(self):
            return self.__surfaceNormals
        @surfaceNormals.setter
        def surfaceNormals(self, surfaceNormals=None):
            if  surfaceNormals is None:
                surfaceNormals = SFNode.DEFAULT_VALUE
            isValidSFNode(surfaceNormals)
            if not isinstance(surfaceNormals, object):
                raise RuntimeError(str(surfaceNormals) + ' does not have a valid node type object')
            self.__surfaceNormals = surfaceNormals

class TouchSensor(_X3DTouchSensorNode):
    """
    X3D element
    """
    __name__ = 'TouchSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/pointingsensor.html#TouchSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TouchSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 description='',
                 enabled=True,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TouchSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.description = description
        self.enabled = enabled
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled

class Transform(_X3DGroupingNode):
    """
    X3D element
    """
    __name__ = 'Transform'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/group.html#Transform'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Transform'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('rotation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('scale', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('scaleOrientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('translation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 center=(0, 0, 0),
                 rotation=(0, 0, 1, 0),
                 scale=(1, 1, 1),
                 scaleOrientation=(0, 0, 1, 0),
                 translation=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Transform __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.center = center
        self.rotation = rotation
        self.scale = scale
        self.scaleOrientation = scaleOrientation
        self.translation = translation
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def rotation(self):
            return self.__rotation
        @rotation.setter
        def rotation(self, rotation=None):
            if  rotation is None:
                rotation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(rotation)
            self.__rotation = rotation
        @property # - - - - - - - - - - - - -
        def scale(self):
            return self.__scale
        @scale.setter
        def scale(self, scale=None):
            if  scale is None:
                scale = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(scale)
            self.__scale = scale
        @property # - - - - - - - - - - - - -
        def scaleOrientation(self):
            return self.__scaleOrientation
        @scaleOrientation.setter
        def scaleOrientation(self, scaleOrientation=None):
            if  scaleOrientation is None:
                scaleOrientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(scaleOrientation)
            self.__scaleOrientation = scaleOrientation
        @property # - - - - - - - - - - - - -
        def translation(self):
            return self.__translation
        @translation.setter
        def translation(self, translation=None):
            if  translation is None:
                translation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(translation)
            self.__translation = translation
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class TransformSensor(_X3DEnvironmentalSensorNode):
    """
    X3D element
    """
    __name__ = 'TransformSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/envsensor.html#TransformSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TransformSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('size', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('targetObject', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 center=(0, 0, 0),
                 enabled=True,
                 size=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 targetObject=None):
        # if _DEBUG: print ('... in ConcreteNode TransformSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.center = center
        self.enabled = enabled
        self.size = size
        self.targetObject = targetObject
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def targetObject(self):
            return self.__targetObject
        @targetObject.setter
        def targetObject(self, targetObject=None):
            if  targetObject is None:
                targetObject = SFNode.DEFAULT_VALUE
            isValidSFNode(targetObject)
            if not isinstance(targetObject, object):
                raise RuntimeError(str(targetObject) + ' does not have a valid node type object')
            self.__targetObject = targetObject

class TransmitterPdu(_X3DNetworkSensorNode):
    """
    X3D element
    """
    __name__ = 'TransmitterPdu'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/dis.html#TransmitterPdu'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TransmitterPdu'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('address', 'localhost', 'SFString', 'inputOutput'),
                          ('antennaLocation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('antennaPatternLength', 0, 'SFInt32', 'inputOutput'),
                          ('antennaPatternType', 0, 'SFInt32', 'inputOutput'),
                          ('applicationID', 0, 'SFInt32', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('cryptoKeyID', 0, 'SFInt32', 'inputOutput'),
                          ('cryptoSystem', 0, 'SFInt32', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('entityID', 0, 'SFInt32', 'inputOutput'),
                          ('frequency', 0, 'SFInt32', 'inputOutput'),
                          ('geoCoords', (0, 0, 0), 'SFVec3d', 'inputOutput'),
                          ('geoSystem', ["GD", "WE"], 'MFString', 'initializeOnly'),
                          ('inputSource', 0, 'SFInt32', 'inputOutput'),
                          ('lengthOfModulationParameters', 0, 'SFInt32', 'inputOutput'),
                          ('modulationTypeDetail', 0, 'SFInt32', 'inputOutput'),
                          ('modulationTypeMajor', 0, 'SFInt32', 'inputOutput'),
                          ('modulationTypeSpreadSpectrum', 0, 'SFInt32', 'inputOutput'),
                          ('modulationTypeSystem', 0, 'SFInt32', 'inputOutput'),
                          ('multicastRelayHost', '', 'SFString', 'inputOutput'),
                          ('multicastRelayPort', 0, 'SFInt32', 'inputOutput'),
                          ('networkMode', 'standAlone', 'SFString', 'inputOutput'),
                          ('port', 0, 'SFInt32', 'inputOutput'),
                          ('power', 0.0, 'SFFloat', 'inputOutput'),
                          ('radioEntityTypeCategory', 0, 'SFInt32', 'inputOutput'),
                          ('radioEntityTypeCountry', 0, 'SFInt32', 'inputOutput'),
                          ('radioEntityTypeDomain', 0, 'SFInt32', 'inputOutput'),
                          ('radioEntityTypeKind', 0, 'SFInt32', 'inputOutput'),
                          ('radioEntityTypeNomenclature', 0, 'SFInt32', 'inputOutput'),
                          ('radioEntityTypeNomenclatureVersion', 0, 'SFInt32', 'inputOutput'),
                          ('radioID', 0, 'SFInt32', 'inputOutput'),
                          ('readInterval', 0.1, 'SFTime', 'inputOutput'),
                          ('relativeAntennaLocation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('rtpHeaderExpected', False, 'SFBool', 'initializeOnly'),
                          ('siteID', 0, 'SFInt32', 'inputOutput'),
                          ('transmitFrequencyBandwidth', 0, 'SFFloat', 'inputOutput'),
                          ('transmitState', 0, 'SFInt32', 'inputOutput'),
                          ('whichGeometry', 1, 'SFInt32', 'inputOutput'),
                          ('writeInterval', 1.0, 'SFTime', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 address='localhost',
                 antennaLocation=(0, 0, 0),
                 antennaPatternLength=0,
                 antennaPatternType=0,
                 applicationID=0,
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 cryptoKeyID=0,
                 cryptoSystem=0,
                 enabled=True,
                 entityID=0,
                 frequency=0,
                 geoCoords=(0, 0, 0),
                 geoSystem=["GD", "WE"],
                 inputSource=0,
                 lengthOfModulationParameters=0,
                 modulationTypeDetail=0,
                 modulationTypeMajor=0,
                 modulationTypeSpreadSpectrum=0,
                 modulationTypeSystem=0,
                 multicastRelayHost='',
                 multicastRelayPort=0,
                 networkMode='standAlone',
                 port=0,
                 power=0.0,
                 radioEntityTypeCategory=0,
                 radioEntityTypeCountry=0,
                 radioEntityTypeDomain=0,
                 radioEntityTypeKind=0,
                 radioEntityTypeNomenclature=0,
                 radioEntityTypeNomenclatureVersion=0,
                 radioID=0,
                 readInterval=0.1,
                 relativeAntennaLocation=(0, 0, 0),
                 rtpHeaderExpected=False,
                 siteID=0,
                 transmitFrequencyBandwidth=0,
                 transmitState=0,
                 whichGeometry=1,
                 writeInterval=1.0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TransmitterPdu __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.address = address
        self.antennaLocation = antennaLocation
        self.antennaPatternLength = antennaPatternLength
        self.antennaPatternType = antennaPatternType
        self.applicationID = applicationID
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.cryptoKeyID = cryptoKeyID
        self.cryptoSystem = cryptoSystem
        self.enabled = enabled
        self.entityID = entityID
        self.frequency = frequency
        self.geoCoords = geoCoords
        self.geoSystem = geoSystem
        self.inputSource = inputSource
        self.lengthOfModulationParameters = lengthOfModulationParameters
        self.modulationTypeDetail = modulationTypeDetail
        self.modulationTypeMajor = modulationTypeMajor
        self.modulationTypeSpreadSpectrum = modulationTypeSpreadSpectrum
        self.modulationTypeSystem = modulationTypeSystem
        self.multicastRelayHost = multicastRelayHost
        self.multicastRelayPort = multicastRelayPort
        self.networkMode = networkMode
        self.port = port
        self.power = power
        self.radioEntityTypeCategory = radioEntityTypeCategory
        self.radioEntityTypeCountry = radioEntityTypeCountry
        self.radioEntityTypeDomain = radioEntityTypeDomain
        self.radioEntityTypeKind = radioEntityTypeKind
        self.radioEntityTypeNomenclature = radioEntityTypeNomenclature
        self.radioEntityTypeNomenclatureVersion = radioEntityTypeNomenclatureVersion
        self.radioID = radioID
        self.readInterval = readInterval
        self.relativeAntennaLocation = relativeAntennaLocation
        self.rtpHeaderExpected = rtpHeaderExpected
        self.siteID = siteID
        self.transmitFrequencyBandwidth = transmitFrequencyBandwidth
        self.transmitState = transmitState
        self.whichGeometry = whichGeometry
        self.writeInterval = writeInterval
        @property # - - - - - - - - - - - - -
        def address(self):
            return self.__address
        @address.setter
        def address(self, address=None):
            if  address is None:
                address = SFString.DEFAULT_VALUE
            isValidSFString(address)
            self.__address = address
        @property # - - - - - - - - - - - - -
        def antennaLocation(self):
            return self.__antennaLocation
        @antennaLocation.setter
        def antennaLocation(self, antennaLocation=None):
            if  antennaLocation is None:
                antennaLocation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(antennaLocation)
            self.__antennaLocation = antennaLocation
        @property # - - - - - - - - - - - - -
        def antennaPatternLength(self):
            return self.__antennaPatternLength
        @antennaPatternLength.setter
        def antennaPatternLength(self, antennaPatternLength=None):
            if  antennaPatternLength is None:
                antennaPatternLength = SFInt32.DEFAULT_VALUE
            isValidSFInt32(antennaPatternLength)
            self.__antennaPatternLength = antennaPatternLength
        @property # - - - - - - - - - - - - -
        def antennaPatternType(self):
            return self.__antennaPatternType
        @antennaPatternType.setter
        def antennaPatternType(self, antennaPatternType=None):
            if  antennaPatternType is None:
                antennaPatternType = SFInt32.DEFAULT_VALUE
            isValidSFInt32(antennaPatternType)
            self.__antennaPatternType = antennaPatternType
        @property # - - - - - - - - - - - - -
        def applicationID(self):
            return self.__applicationID
        @applicationID.setter
        def applicationID(self, applicationID=None):
            if  applicationID is None:
                applicationID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(applicationID)
            self.__applicationID = applicationID
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def cryptoKeyID(self):
            return self.__cryptoKeyID
        @cryptoKeyID.setter
        def cryptoKeyID(self, cryptoKeyID=None):
            if  cryptoKeyID is None:
                cryptoKeyID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(cryptoKeyID)
            self.__cryptoKeyID = cryptoKeyID
        @property # - - - - - - - - - - - - -
        def cryptoSystem(self):
            return self.__cryptoSystem
        @cryptoSystem.setter
        def cryptoSystem(self, cryptoSystem=None):
            if  cryptoSystem is None:
                cryptoSystem = SFInt32.DEFAULT_VALUE
            isValidSFInt32(cryptoSystem)
            self.__cryptoSystem = cryptoSystem
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def entityID(self):
            return self.__entityID
        @entityID.setter
        def entityID(self, entityID=None):
            if  entityID is None:
                entityID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(entityID)
            self.__entityID = entityID
        @property # - - - - - - - - - - - - -
        def frequency(self):
            return self.__frequency
        @frequency.setter
        def frequency(self, frequency=None):
            if  frequency is None:
                frequency = SFInt32.DEFAULT_VALUE
            isValidSFInt32(frequency)
            self.__frequency = frequency
        @property # - - - - - - - - - - - - -
        def geoCoords(self):
            return self.__geoCoords
        @geoCoords.setter
        def geoCoords(self, geoCoords=None):
            if  geoCoords is None:
                geoCoords = SFVec3d.DEFAULT_VALUE
            isValidSFVec3d(geoCoords)
            self.__geoCoords = geoCoords
        @property # - - - - - - - - - - - - -
        def geoSystem(self):
            return self.__geoSystem
        @geoSystem.setter
        def geoSystem(self, geoSystem=None):
            if  geoSystem is None:
                geoSystem = MFString.DEFAULT_VALUE
            isValidMFString(geoSystem)
            self.__geoSystem = geoSystem
        @property # - - - - - - - - - - - - -
        def inputSource(self):
            return self.__inputSource
        @inputSource.setter
        def inputSource(self, inputSource=None):
            if  inputSource is None:
                inputSource = SFInt32.DEFAULT_VALUE
            isValidSFInt32(inputSource)
            self.__inputSource = inputSource
        @property # - - - - - - - - - - - - -
        def lengthOfModulationParameters(self):
            return self.__lengthOfModulationParameters
        @lengthOfModulationParameters.setter
        def lengthOfModulationParameters(self, lengthOfModulationParameters=None):
            if  lengthOfModulationParameters is None:
                lengthOfModulationParameters = SFInt32.DEFAULT_VALUE
            isValidSFInt32(lengthOfModulationParameters)
            self.__lengthOfModulationParameters = lengthOfModulationParameters
        @property # - - - - - - - - - - - - -
        def modulationTypeDetail(self):
            return self.__modulationTypeDetail
        @modulationTypeDetail.setter
        def modulationTypeDetail(self, modulationTypeDetail=None):
            if  modulationTypeDetail is None:
                modulationTypeDetail = SFInt32.DEFAULT_VALUE
            isValidSFInt32(modulationTypeDetail)
            self.__modulationTypeDetail = modulationTypeDetail
        @property # - - - - - - - - - - - - -
        def modulationTypeMajor(self):
            return self.__modulationTypeMajor
        @modulationTypeMajor.setter
        def modulationTypeMajor(self, modulationTypeMajor=None):
            if  modulationTypeMajor is None:
                modulationTypeMajor = SFInt32.DEFAULT_VALUE
            isValidSFInt32(modulationTypeMajor)
            self.__modulationTypeMajor = modulationTypeMajor
        @property # - - - - - - - - - - - - -
        def modulationTypeSpreadSpectrum(self):
            return self.__modulationTypeSpreadSpectrum
        @modulationTypeSpreadSpectrum.setter
        def modulationTypeSpreadSpectrum(self, modulationTypeSpreadSpectrum=None):
            if  modulationTypeSpreadSpectrum is None:
                modulationTypeSpreadSpectrum = SFInt32.DEFAULT_VALUE
            isValidSFInt32(modulationTypeSpreadSpectrum)
            self.__modulationTypeSpreadSpectrum = modulationTypeSpreadSpectrum
        @property # - - - - - - - - - - - - -
        def modulationTypeSystem(self):
            return self.__modulationTypeSystem
        @modulationTypeSystem.setter
        def modulationTypeSystem(self, modulationTypeSystem=None):
            if  modulationTypeSystem is None:
                modulationTypeSystem = SFInt32.DEFAULT_VALUE
            isValidSFInt32(modulationTypeSystem)
            self.__modulationTypeSystem = modulationTypeSystem
        @property # - - - - - - - - - - - - -
        def multicastRelayHost(self):
            return self.__multicastRelayHost
        @multicastRelayHost.setter
        def multicastRelayHost(self, multicastRelayHost=None):
            if  multicastRelayHost is None:
                multicastRelayHost = SFString.DEFAULT_VALUE
            isValidSFString(multicastRelayHost)
            self.__multicastRelayHost = multicastRelayHost
        @property # - - - - - - - - - - - - -
        def multicastRelayPort(self):
            return self.__multicastRelayPort
        @multicastRelayPort.setter
        def multicastRelayPort(self, multicastRelayPort=None):
            if  multicastRelayPort is None:
                multicastRelayPort = SFInt32.DEFAULT_VALUE
            isValidSFInt32(multicastRelayPort)
            self.__multicastRelayPort = multicastRelayPort
        @property # - - - - - - - - - - - - -
        def networkMode(self):
            return self.__networkMode
        @networkMode.setter
        def networkMode(self, networkMode=None):
            if  networkMode is None:
                networkMode = SFString.DEFAULT_VALUE
            isValidSFString(networkMode)
            self.__networkMode = networkMode
        @property # - - - - - - - - - - - - -
        def port(self):
            return self.__port
        @port.setter
        def port(self, port=None):
            if  port is None:
                port = SFInt32.DEFAULT_VALUE
            isValidSFInt32(port)
            self.__port = port
        @property # - - - - - - - - - - - - -
        def power(self):
            return self.__power
        @power.setter
        def power(self, power=None):
            if  power is None:
                power = SFFloat.DEFAULT_VALUE
            isValidSFFloat(power)
            self.__power = power
        @property # - - - - - - - - - - - - -
        def radioEntityTypeCategory(self):
            return self.__radioEntityTypeCategory
        @radioEntityTypeCategory.setter
        def radioEntityTypeCategory(self, radioEntityTypeCategory=None):
            if  radioEntityTypeCategory is None:
                radioEntityTypeCategory = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioEntityTypeCategory)
            self.__radioEntityTypeCategory = radioEntityTypeCategory
        @property # - - - - - - - - - - - - -
        def radioEntityTypeCountry(self):
            return self.__radioEntityTypeCountry
        @radioEntityTypeCountry.setter
        def radioEntityTypeCountry(self, radioEntityTypeCountry=None):
            if  radioEntityTypeCountry is None:
                radioEntityTypeCountry = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioEntityTypeCountry)
            self.__radioEntityTypeCountry = radioEntityTypeCountry
        @property # - - - - - - - - - - - - -
        def radioEntityTypeDomain(self):
            return self.__radioEntityTypeDomain
        @radioEntityTypeDomain.setter
        def radioEntityTypeDomain(self, radioEntityTypeDomain=None):
            if  radioEntityTypeDomain is None:
                radioEntityTypeDomain = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioEntityTypeDomain)
            self.__radioEntityTypeDomain = radioEntityTypeDomain
        @property # - - - - - - - - - - - - -
        def radioEntityTypeKind(self):
            return self.__radioEntityTypeKind
        @radioEntityTypeKind.setter
        def radioEntityTypeKind(self, radioEntityTypeKind=None):
            if  radioEntityTypeKind is None:
                radioEntityTypeKind = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioEntityTypeKind)
            self.__radioEntityTypeKind = radioEntityTypeKind
        @property # - - - - - - - - - - - - -
        def radioEntityTypeNomenclature(self):
            return self.__radioEntityTypeNomenclature
        @radioEntityTypeNomenclature.setter
        def radioEntityTypeNomenclature(self, radioEntityTypeNomenclature=None):
            if  radioEntityTypeNomenclature is None:
                radioEntityTypeNomenclature = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioEntityTypeNomenclature)
            self.__radioEntityTypeNomenclature = radioEntityTypeNomenclature
        @property # - - - - - - - - - - - - -
        def radioEntityTypeNomenclatureVersion(self):
            return self.__radioEntityTypeNomenclatureVersion
        @radioEntityTypeNomenclatureVersion.setter
        def radioEntityTypeNomenclatureVersion(self, radioEntityTypeNomenclatureVersion=None):
            if  radioEntityTypeNomenclatureVersion is None:
                radioEntityTypeNomenclatureVersion = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioEntityTypeNomenclatureVersion)
            self.__radioEntityTypeNomenclatureVersion = radioEntityTypeNomenclatureVersion
        @property # - - - - - - - - - - - - -
        def radioID(self):
            return self.__radioID
        @radioID.setter
        def radioID(self, radioID=None):
            if  radioID is None:
                radioID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(radioID)
            self.__radioID = radioID
        @property # - - - - - - - - - - - - -
        def readInterval(self):
            return self.__readInterval
        @readInterval.setter
        def readInterval(self, readInterval=None):
            if  readInterval is None:
                readInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(readInterval)
            self.__readInterval = readInterval
        @property # - - - - - - - - - - - - -
        def relativeAntennaLocation(self):
            return self.__relativeAntennaLocation
        @relativeAntennaLocation.setter
        def relativeAntennaLocation(self, relativeAntennaLocation=None):
            if  relativeAntennaLocation is None:
                relativeAntennaLocation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(relativeAntennaLocation)
            self.__relativeAntennaLocation = relativeAntennaLocation
        @property # - - - - - - - - - - - - -
        def rtpHeaderExpected(self):
            return self.__rtpHeaderExpected
        @rtpHeaderExpected.setter
        def rtpHeaderExpected(self, rtpHeaderExpected=None):
            if  rtpHeaderExpected is None:
                rtpHeaderExpected = SFBool.DEFAULT_VALUE
            isValidSFBool(rtpHeaderExpected)
            self.__rtpHeaderExpected = rtpHeaderExpected
        @property # - - - - - - - - - - - - -
        def siteID(self):
            return self.__siteID
        @siteID.setter
        def siteID(self, siteID=None):
            if  siteID is None:
                siteID = SFInt32.DEFAULT_VALUE
            isValidSFInt32(siteID)
            self.__siteID = siteID
        @property # - - - - - - - - - - - - -
        def transmitFrequencyBandwidth(self):
            return self.__transmitFrequencyBandwidth
        @transmitFrequencyBandwidth.setter
        def transmitFrequencyBandwidth(self, transmitFrequencyBandwidth=None):
            if  transmitFrequencyBandwidth is None:
                transmitFrequencyBandwidth = SFFloat.DEFAULT_VALUE
            isValidSFFloat(transmitFrequencyBandwidth)
            self.__transmitFrequencyBandwidth = transmitFrequencyBandwidth
        @property # - - - - - - - - - - - - -
        def transmitState(self):
            return self.__transmitState
        @transmitState.setter
        def transmitState(self, transmitState=None):
            if  transmitState is None:
                transmitState = SFInt32.DEFAULT_VALUE
            isValidSFInt32(transmitState)
            self.__transmitState = transmitState
        @property # - - - - - - - - - - - - -
        def whichGeometry(self):
            return self.__whichGeometry
        @whichGeometry.setter
        def whichGeometry(self, whichGeometry=None):
            if  whichGeometry is None:
                whichGeometry = SFInt32.DEFAULT_VALUE
            isValidSFInt32(whichGeometry)
            self.__whichGeometry = whichGeometry
        @property # - - - - - - - - - - - - -
        def writeInterval(self):
            return self.__writeInterval
        @writeInterval.setter
        def writeInterval(self, writeInterval=None):
            if  writeInterval is None:
                writeInterval = SFTime.DEFAULT_VALUE
            isValidSFTime(writeInterval)
            self.__writeInterval = writeInterval

class TriangleFanSet(_X3DComposedGeometryNode):
    """
    X3D element
    """
    __name__ = 'TriangleFanSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#TriangleFanSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TriangleFanSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('fanCount', list(), 'MFInt32', 'inputOutput'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 fanCount=list(),
                 normalPerVertex=True,
                 solid=True,
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode TriangleFanSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.fanCount = fanCount
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def fanCount(self):
            return self.__fanCount
        @fanCount.setter
        def fanCount(self, fanCount=None):
            if  fanCount is None:
                fanCount = MFInt32.DEFAULT_VALUE
            isValidMFInt32(fanCount)
            self.__fanCount = fanCount
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class TriangleSet(_X3DComposedGeometryNode):
    """
    X3D element
    """
    __name__ = 'TriangleSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#TriangleSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TriangleSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 normalPerVertex=True,
                 solid=True,
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode TriangleSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class TriangleSet2D(_X3DGeometryNode):
    """
    X3D element
    """
    __name__ = 'TriangleSet2D'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/geometry2D.html#TriangleSet2D'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TriangleSet2D'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('solid', False, 'SFBool', 'initializeOnly'),
                          ('vertices', (list()), 'MFVec2f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 solid=False,
                 vertices=(list()),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TriangleSet2D __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.solid = solid
        self.vertices = vertices
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def vertices(self):
            return self.__vertices
        @vertices.setter
        def vertices(self, vertices=None):
            if  vertices is None:
                vertices = MFVec2f.DEFAULT_VALUE
            isValidMFVec2f(vertices)
            self.__vertices = vertices

class TriangleStripSet(_X3DComposedGeometryNode):
    """
    X3D element
    """
    __name__ = 'TriangleStripSet'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rendering.html#TriangleStripSet'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TriangleStripSet'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ccw', True, 'SFBool', 'initializeOnly'),
                          ('colorPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('normalPerVertex', True, 'SFBool', 'initializeOnly'),
                          ('solid', True, 'SFBool', 'initializeOnly'),
                          ('stripCount', list(), 'MFInt32', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('color', None, 'SFNode', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('fogCoord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('normal', None, 'SFNode', 'inputOutput'),
                          ('texCoord', None, 'SFNode', 'inputOutput'),
                          ('attrib', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ccw=True,
                 colorPerVertex=True,
                 normalPerVertex=True,
                 solid=True,
                 stripCount=list(),
                 USE='',
                 class_='',
                 color=None,
                 coord=None,
                 fogCoord=None,
                 IS=None,
                 metadata=None,
                 normal=None,
                 texCoord=None,
                 attrib=list()):
        # if _DEBUG: print ('... in ConcreteNode TriangleStripSet __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ccw = ccw
        self.colorPerVertex = colorPerVertex
        self.normalPerVertex = normalPerVertex
        self.solid = solid
        self.stripCount = stripCount
        self.color = color
        self.coord = coord
        self.fogCoord = fogCoord
        self.normal = normal
        self.texCoord = texCoord
        self.attrib = attrib
        @property # - - - - - - - - - - - - -
        def ccw(self):
            return self.__ccw
        @ccw.setter
        def ccw(self, ccw=None):
            if  ccw is None:
                ccw = SFBool.DEFAULT_VALUE
            isValidSFBool(ccw)
            self.__ccw = ccw
        @property # - - - - - - - - - - - - -
        def colorPerVertex(self):
            return self.__colorPerVertex
        @colorPerVertex.setter
        def colorPerVertex(self, colorPerVertex=None):
            if  colorPerVertex is None:
                colorPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(colorPerVertex)
            self.__colorPerVertex = colorPerVertex
        @property # - - - - - - - - - - - - -
        def normalPerVertex(self):
            return self.__normalPerVertex
        @normalPerVertex.setter
        def normalPerVertex(self, normalPerVertex=None):
            if  normalPerVertex is None:
                normalPerVertex = SFBool.DEFAULT_VALUE
            isValidSFBool(normalPerVertex)
            self.__normalPerVertex = normalPerVertex
        @property # - - - - - - - - - - - - -
        def solid(self):
            return self.__solid
        @solid.setter
        def solid(self, solid=None):
            if  solid is None:
                solid = SFBool.DEFAULT_VALUE
            isValidSFBool(solid)
            self.__solid = solid
        @property # - - - - - - - - - - - - -
        def stripCount(self):
            return self.__stripCount
        @stripCount.setter
        def stripCount(self, stripCount=None):
            if  stripCount is None:
                stripCount = MFInt32.DEFAULT_VALUE
            isValidMFInt32(stripCount)
            self.__stripCount = stripCount
        @property # - - - - - - - - - - - - -
        def color(self):
            return self.__color
        @color.setter
        def color(self, color=None):
            if  color is None:
                color = SFNode.DEFAULT_VALUE
            isValidSFNode(color)
            if not isinstance(color, object):
                raise RuntimeError(str(color) + ' does not have a valid node type object')
            self.__color = color
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord
        @property # - - - - - - - - - - - - -
        def fogCoord(self):
            return self.__fogCoord
        @fogCoord.setter
        def fogCoord(self, fogCoord=None):
            if  fogCoord is None:
                fogCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(fogCoord)
            if not isinstance(fogCoord, object):
                raise RuntimeError(str(fogCoord) + ' does not have a valid node type object')
            self.__fogCoord = fogCoord
        @property # - - - - - - - - - - - - -
        def normal(self):
            return self.__normal
        @normal.setter
        def normal(self, normal=None):
            if  normal is None:
                normal = SFNode.DEFAULT_VALUE
            isValidSFNode(normal)
            if not isinstance(normal, object):
                raise RuntimeError(str(normal) + ' does not have a valid node type object')
            self.__normal = normal
        @property # - - - - - - - - - - - - -
        def texCoord(self):
            return self.__texCoord
        @texCoord.setter
        def texCoord(self, texCoord=None):
            if  texCoord is None:
                texCoord = SFNode.DEFAULT_VALUE
            isValidSFNode(texCoord)
            if not isinstance(texCoord, object):
                raise RuntimeError(str(texCoord) + ' does not have a valid node type object')
            self.__texCoord = texCoord
        @property # - - - - - - - - - - - - -
        def attrib(self):
            return self.__attrib
        @attrib.setter
        def attrib(self, attrib=None):
            if  attrib is None:
                attrib = MFNode.DEFAULT_VALUE
            isValidMFNode(attrib)
            self.__attrib = attrib

class TwoSidedMaterial(_X3DMaterialNode):
    """
    X3D element
    """
    __name__ = 'TwoSidedMaterial'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/shape.html#Material'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#TwoSidedMaterial'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('ambientIntensity', 0.2, 'SFFloat', 'inputOutput'),
                          ('backAmbientIntensity', 0.2, 'SFFloat', 'inputOutput'),
                          ('backDiffuseColor', (0.8, 0.8, 0.8), 'SFColor', 'inputOutput'),
                          ('backEmissiveColor', (0, 0, 0), 'SFColor', 'inputOutput'),
                          ('backShininess', 0.2, 'SFFloat', 'inputOutput'),
                          ('backSpecularColor', (0, 0, 0), 'SFColor', 'inputOutput'),
                          ('backTransparency', 0, 'SFFloat', 'inputOutput'),
                          ('diffuseColor', (0.8, 0.8, 0.8), 'SFColor', 'inputOutput'),
                          ('emissiveColor', (0, 0, 0), 'SFColor', 'inputOutput'),
                          ('separateBackColor', False, 'SFBool', 'inputOutput'),
                          ('shininess', 0.2, 'SFFloat', 'inputOutput'),
                          ('specularColor', (0, 0, 0), 'SFColor', 'inputOutput'),
                          ('transparency', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 ambientIntensity=0.2,
                 backAmbientIntensity=0.2,
                 backDiffuseColor=(0.8, 0.8, 0.8),
                 backEmissiveColor=(0, 0, 0),
                 backShininess=0.2,
                 backSpecularColor=(0, 0, 0),
                 backTransparency=0,
                 diffuseColor=(0.8, 0.8, 0.8),
                 emissiveColor=(0, 0, 0),
                 separateBackColor=False,
                 shininess=0.2,
                 specularColor=(0, 0, 0),
                 transparency=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode TwoSidedMaterial __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.ambientIntensity = ambientIntensity
        self.backAmbientIntensity = backAmbientIntensity
        self.backDiffuseColor = backDiffuseColor
        self.backEmissiveColor = backEmissiveColor
        self.backShininess = backShininess
        self.backSpecularColor = backSpecularColor
        self.backTransparency = backTransparency
        self.diffuseColor = diffuseColor
        self.emissiveColor = emissiveColor
        self.separateBackColor = separateBackColor
        self.shininess = shininess
        self.specularColor = specularColor
        self.transparency = transparency
        @property # - - - - - - - - - - - - -
        def ambientIntensity(self):
            return self.__ambientIntensity
        @ambientIntensity.setter
        def ambientIntensity(self, ambientIntensity=None):
            if  ambientIntensity is None:
                ambientIntensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(ambientIntensity)
            self.__ambientIntensity = ambientIntensity
        @property # - - - - - - - - - - - - -
        def backAmbientIntensity(self):
            return self.__backAmbientIntensity
        @backAmbientIntensity.setter
        def backAmbientIntensity(self, backAmbientIntensity=None):
            if  backAmbientIntensity is None:
                backAmbientIntensity = SFFloat.DEFAULT_VALUE
            isValidSFFloat(backAmbientIntensity)
            self.__backAmbientIntensity = backAmbientIntensity
        @property # - - - - - - - - - - - - -
        def backDiffuseColor(self):
            return self.__backDiffuseColor
        @backDiffuseColor.setter
        def backDiffuseColor(self, backDiffuseColor=None):
            if  backDiffuseColor is None:
                backDiffuseColor = SFColor.DEFAULT_VALUE
            isValidSFColor(backDiffuseColor)
            self.__backDiffuseColor = backDiffuseColor
        @property # - - - - - - - - - - - - -
        def backEmissiveColor(self):
            return self.__backEmissiveColor
        @backEmissiveColor.setter
        def backEmissiveColor(self, backEmissiveColor=None):
            if  backEmissiveColor is None:
                backEmissiveColor = SFColor.DEFAULT_VALUE
            isValidSFColor(backEmissiveColor)
            self.__backEmissiveColor = backEmissiveColor
        @property # - - - - - - - - - - - - -
        def backShininess(self):
            return self.__backShininess
        @backShininess.setter
        def backShininess(self, backShininess=None):
            if  backShininess is None:
                backShininess = SFFloat.DEFAULT_VALUE
            isValidSFFloat(backShininess)
            self.__backShininess = backShininess
        @property # - - - - - - - - - - - - -
        def backSpecularColor(self):
            return self.__backSpecularColor
        @backSpecularColor.setter
        def backSpecularColor(self, backSpecularColor=None):
            if  backSpecularColor is None:
                backSpecularColor = SFColor.DEFAULT_VALUE
            isValidSFColor(backSpecularColor)
            self.__backSpecularColor = backSpecularColor
        @property # - - - - - - - - - - - - -
        def backTransparency(self):
            return self.__backTransparency
        @backTransparency.setter
        def backTransparency(self, backTransparency=None):
            if  backTransparency is None:
                backTransparency = SFFloat.DEFAULT_VALUE
            isValidSFFloat(backTransparency)
            self.__backTransparency = backTransparency
        @property # - - - - - - - - - - - - -
        def diffuseColor(self):
            return self.__diffuseColor
        @diffuseColor.setter
        def diffuseColor(self, diffuseColor=None):
            if  diffuseColor is None:
                diffuseColor = SFColor.DEFAULT_VALUE
            isValidSFColor(diffuseColor)
            self.__diffuseColor = diffuseColor
        @property # - - - - - - - - - - - - -
        def emissiveColor(self):
            return self.__emissiveColor
        @emissiveColor.setter
        def emissiveColor(self, emissiveColor=None):
            if  emissiveColor is None:
                emissiveColor = SFColor.DEFAULT_VALUE
            isValidSFColor(emissiveColor)
            self.__emissiveColor = emissiveColor
        @property # - - - - - - - - - - - - -
        def separateBackColor(self):
            return self.__separateBackColor
        @separateBackColor.setter
        def separateBackColor(self, separateBackColor=None):
            if  separateBackColor is None:
                separateBackColor = SFBool.DEFAULT_VALUE
            isValidSFBool(separateBackColor)
            self.__separateBackColor = separateBackColor
        @property # - - - - - - - - - - - - -
        def shininess(self):
            return self.__shininess
        @shininess.setter
        def shininess(self, shininess=None):
            if  shininess is None:
                shininess = SFFloat.DEFAULT_VALUE
            isValidSFFloat(shininess)
            self.__shininess = shininess
        @property # - - - - - - - - - - - - -
        def specularColor(self):
            return self.__specularColor
        @specularColor.setter
        def specularColor(self, specularColor=None):
            if  specularColor is None:
                specularColor = SFColor.DEFAULT_VALUE
            isValidSFColor(specularColor)
            self.__specularColor = specularColor
        @property # - - - - - - - - - - - - -
        def transparency(self):
            return self.__transparency
        @transparency.setter
        def transparency(self, transparency=None):
            if  transparency is None:
                transparency = SFFloat.DEFAULT_VALUE
            isValidSFFloat(transparency)
            self.__transparency = transparency

class UniversalJoint(_X3DRigidJointNode):
    """
    UniversalJoint is like a BallJoint that constrains an extra degree of rotational freedom.
    """
    __name__ = 'UniversalJoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/rigid_physics.html#UniversalJoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#UniversalJoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('anchorPoint', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('axis1', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('axis2', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('forceOutput', ["NONE"], 'MFString', 'inputOutput'),
                          ('stop1Bounce', 0, 'SFFloat', 'inputOutput'),
                          ('stop1ErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('stop2Bounce', 0, 'SFFloat', 'inputOutput'),
                          ('stop2ErrorCorrection', 0.8, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('body1', None, 'SFNode', 'inputOutput'),
                          ('body2', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 anchorPoint=(0, 0, 0),
                 axis1=(0, 0, 0),
                 axis2=(0, 0, 0),
                 forceOutput=["NONE"],
                 stop1Bounce=0,
                 stop1ErrorCorrection=0.8,
                 stop2Bounce=0,
                 stop2ErrorCorrection=0.8,
                 USE='',
                 class_='',
                 body1=None,
                 body2=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode UniversalJoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.anchorPoint = anchorPoint
        self.axis1 = axis1
        self.axis2 = axis2
        self.forceOutput = forceOutput
        self.stop1Bounce = stop1Bounce
        self.stop1ErrorCorrection = stop1ErrorCorrection
        self.stop2Bounce = stop2Bounce
        self.stop2ErrorCorrection = stop2ErrorCorrection
        self.body1 = body1
        self.body2 = body2
        @property # - - - - - - - - - - - - -
        def anchorPoint(self):
            return self.__anchorPoint
        @anchorPoint.setter
        def anchorPoint(self, anchorPoint=None):
            if  anchorPoint is None:
                anchorPoint = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(anchorPoint)
            self.__anchorPoint = anchorPoint
        @property # - - - - - - - - - - - - -
        def axis1(self):
            return self.__axis1
        @axis1.setter
        def axis1(self, axis1=None):
            if  axis1 is None:
                axis1 = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(axis1)
            self.__axis1 = axis1
        @property # - - - - - - - - - - - - -
        def axis2(self):
            return self.__axis2
        @axis2.setter
        def axis2(self, axis2=None):
            if  axis2 is None:
                axis2 = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(axis2)
            self.__axis2 = axis2
        @property # - - - - - - - - - - - - -
        def forceOutput(self):
            return self.__forceOutput
        @forceOutput.setter
        def forceOutput(self, forceOutput=None):
            if  forceOutput is None:
                forceOutput = MFString.DEFAULT_VALUE
            isValidMFString(forceOutput)
            self.__forceOutput = forceOutput
        @property # - - - - - - - - - - - - -
        def stop1Bounce(self):
            return self.__stop1Bounce
        @stop1Bounce.setter
        def stop1Bounce(self, stop1Bounce=None):
            if  stop1Bounce is None:
                stop1Bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop1Bounce)
            self.__stop1Bounce = stop1Bounce
        @property # - - - - - - - - - - - - -
        def stop1ErrorCorrection(self):
            return self.__stop1ErrorCorrection
        @stop1ErrorCorrection.setter
        def stop1ErrorCorrection(self, stop1ErrorCorrection=None):
            if  stop1ErrorCorrection is None:
                stop1ErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop1ErrorCorrection)
            self.__stop1ErrorCorrection = stop1ErrorCorrection
        @property # - - - - - - - - - - - - -
        def stop2Bounce(self):
            return self.__stop2Bounce
        @stop2Bounce.setter
        def stop2Bounce(self, stop2Bounce=None):
            if  stop2Bounce is None:
                stop2Bounce = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop2Bounce)
            self.__stop2Bounce = stop2Bounce
        @property # - - - - - - - - - - - - -
        def stop2ErrorCorrection(self):
            return self.__stop2ErrorCorrection
        @stop2ErrorCorrection.setter
        def stop2ErrorCorrection(self, stop2ErrorCorrection=None):
            if  stop2ErrorCorrection is None:
                stop2ErrorCorrection = SFFloat.DEFAULT_VALUE
            isValidSFFloat(stop2ErrorCorrection)
            self.__stop2ErrorCorrection = stop2ErrorCorrection
        @property # - - - - - - - - - - - - -
        def body1(self):
            return self.__body1
        @body1.setter
        def body1(self, body1=None):
            if  body1 is None:
                body1 = SFNode.DEFAULT_VALUE
            isValidSFNode(body1)
            if not isinstance(body1, object):
                raise RuntimeError(str(body1) + ' does not have a valid node type object')
            self.__body1 = body1
        @property # - - - - - - - - - - - - -
        def body2(self):
            return self.__body2
        @body2.setter
        def body2(self, body2=None):
            if  body2 is None:
                body2 = SFNode.DEFAULT_VALUE
            isValidSFNode(body2)
            if not isinstance(body2, object):
                raise RuntimeError(str(body2) + ' does not have a valid node type object')
            self.__body2 = body2

class Viewpoint(_X3DViewpointNode):
    """
    X3D element
    """
    __name__ = 'Viewpoint'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#Viewpoint'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Viewpoint'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('centerOfRotation', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('fieldOfView', 0.7854, 'SFFloat', 'inputOutput'),
                          ('jump', True, 'SFBool', 'inputOutput'),
                          ('orientation', (0, 0, 1, 0), 'SFRotation', 'inputOutput'),
                          ('position', (0, 0, 10), 'SFVec3f', 'inputOutput'),
                          ('retainUserOffsets', False, 'SFBool', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 centerOfRotation=(0, 0, 0),
                 description='',
                 fieldOfView=0.7854,
                 jump=True,
                 orientation=(0, 0, 1, 0),
                 position=(0, 0, 10),
                 retainUserOffsets=False,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode Viewpoint __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.centerOfRotation = centerOfRotation
        self.description = description
        self.fieldOfView = fieldOfView
        self.jump = jump
        self.orientation = orientation
        self.position = position
        self.retainUserOffsets = retainUserOffsets
        @property # - - - - - - - - - - - - -
        def centerOfRotation(self):
            return self.__centerOfRotation
        @centerOfRotation.setter
        def centerOfRotation(self, centerOfRotation=None):
            if  centerOfRotation is None:
                centerOfRotation = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(centerOfRotation)
            self.__centerOfRotation = centerOfRotation
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def fieldOfView(self):
            return self.__fieldOfView
        @fieldOfView.setter
        def fieldOfView(self, fieldOfView=None):
            if  fieldOfView is None:
                fieldOfView = SFFloat.DEFAULT_VALUE
            isValidSFFloat(fieldOfView)
            self.__fieldOfView = fieldOfView
        @property # - - - - - - - - - - - - -
        def jump(self):
            return self.__jump
        @jump.setter
        def jump(self, jump=None):
            if  jump is None:
                jump = SFBool.DEFAULT_VALUE
            isValidSFBool(jump)
            self.__jump = jump
        @property # - - - - - - - - - - - - -
        def orientation(self):
            return self.__orientation
        @orientation.setter
        def orientation(self, orientation=None):
            if  orientation is None:
                orientation = SFRotation.DEFAULT_VALUE
            isValidSFRotation(orientation)
            self.__orientation = orientation
        @property # - - - - - - - - - - - - -
        def position(self):
            return self.__position
        @position.setter
        def position(self, position=None):
            if  position is None:
                position = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(position)
            self.__position = position
        @property # - - - - - - - - - - - - -
        def retainUserOffsets(self):
            return self.__retainUserOffsets
        @retainUserOffsets.setter
        def retainUserOffsets(self, retainUserOffsets=None):
            if  retainUserOffsets is None:
                retainUserOffsets = SFBool.DEFAULT_VALUE
            isValidSFBool(retainUserOffsets)
            self.__retainUserOffsets = retainUserOffsets

class ViewpointGroup(_X3DChildNode):
    """
    X3D element
    """
    __name__ = 'ViewpointGroup'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/navigation.html#ViewpointGroup'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#ViewpointGroup'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('description', '', 'SFString', 'inputOutput'),
                          ('displayed', True, 'SFBool', 'inputOutput'),
                          ('retainUserOffsets', False, 'SFBool', 'inputOutput'),
                          ('size', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 center=(0, 0, 0),
                 description='',
                 displayed=True,
                 retainUserOffsets=False,
                 size=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode ViewpointGroup __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.center = center
        self.description = description
        self.displayed = displayed
        self.retainUserOffsets = retainUserOffsets
        self.size = size
        self.children = children
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def description(self):
            return self.__description
        @description.setter
        def description(self, description=None):
            if  description is None:
                description = SFString.DEFAULT_VALUE
            isValidSFString(description)
            self.__description = description
        @property # - - - - - - - - - - - - -
        def displayed(self):
            return self.__displayed
        @displayed.setter
        def displayed(self, displayed=None):
            if  displayed is None:
                displayed = SFBool.DEFAULT_VALUE
            isValidSFBool(displayed)
            self.__displayed = displayed
        @property # - - - - - - - - - - - - -
        def retainUserOffsets(self):
            return self.__retainUserOffsets
        @retainUserOffsets.setter
        def retainUserOffsets(self, retainUserOffsets=None):
            if  retainUserOffsets is None:
                retainUserOffsets = SFBool.DEFAULT_VALUE
            isValidSFBool(retainUserOffsets)
            self.__retainUserOffsets = retainUserOffsets
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(size)
            self.__size = size
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class Viewport(_X3DViewportNode):
    """
    X3D element
    """
    __name__ = 'Viewport'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/layering.html#Viewport'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#Viewport'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('clipBoundary', [0, 1, 0, 1], 'MFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('children', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 clipBoundary=[0, 1, 0, 1],
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 children=list()):
        # if _DEBUG: print ('... in ConcreteNode Viewport __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.clipBoundary = clipBoundary
        self.children = children
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def clipBoundary(self):
            return self.__clipBoundary
        @clipBoundary.setter
        def clipBoundary(self, clipBoundary=None):
            if  clipBoundary is None:
                clipBoundary = MFFloat.DEFAULT_VALUE
            isValidMFFloat(clipBoundary)
            self.__clipBoundary = clipBoundary
        @property # - - - - - - - - - - - - -
        def children(self):
            return self.__children
        @children.setter
        def children(self, children=None):
            if  children is None:
                children = MFNode.DEFAULT_VALUE
            isValidMFNode(children)
            self.__children = children

class VisibilitySensor(_X3DEnvironmentalSensorNode):
    """
    X3D element
    """
    __name__ = 'VisibilitySensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/envsensor.html#VisibilitySensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#VisibilitySensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('center', (0, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('size', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 center=(0, 0, 0),
                 enabled=True,
                 size=(0, 0, 0),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode VisibilitySensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.center = center
        self.enabled = enabled
        self.size = size
        @property # - - - - - - - - - - - - -
        def center(self):
            return self.__center
        @center.setter
        def center(self, center=None):
            if  center is None:
                center = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(center)
            self.__center = center
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def size(self):
            return self.__size
        @size.setter
        def size(self, size=None):
            if  size is None:
                size = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(size)
            self.__size = size

class VolumeData(_X3DVolumeDataNode):
    """
    X3D element
    """
    __name__ = 'VolumeData'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/volume.html#VolumeData'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#VolumeData'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('bboxCenter', (0, 0, 0), 'SFVec3f', 'initializeOnly'),
                          ('bboxSize', (-1, -1, -1), 'SFVec3f', 'initializeOnly'),
                          ('dimensions', (1, 1, 1), 'SFVec3f', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('renderStyle', None, 'SFNode', 'inputOutput'),
                          ('voxels', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 bboxCenter=(0, 0, 0),
                 bboxSize=(-1, -1, -1),
                 dimensions=(1, 1, 1),
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 renderStyle=None,
                 voxels=None):
        # if _DEBUG: print ('... in ConcreteNode VolumeData __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.bboxCenter = bboxCenter
        self.bboxSize = bboxSize
        self.dimensions = dimensions
        self.renderStyle = renderStyle
        self.voxels = voxels
        @property # - - - - - - - - - - - - -
        def bboxCenter(self):
            return self.__bboxCenter
        @bboxCenter.setter
        def bboxCenter(self, bboxCenter=None):
            if  bboxCenter is None:
                bboxCenter = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxCenter)
            self.__bboxCenter = bboxCenter
        @property # - - - - - - - - - - - - -
        def bboxSize(self):
            return self.__bboxSize
        @bboxSize.setter
        def bboxSize(self, bboxSize=None):
            if  bboxSize is None:
                bboxSize = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(bboxSize)
            self.__bboxSize = bboxSize
        @property # - - - - - - - - - - - - -
        def dimensions(self):
            return self.__dimensions
        @dimensions.setter
        def dimensions(self, dimensions=None):
            if  dimensions is None:
                dimensions = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(dimensions)
            self.__dimensions = dimensions
        @property # - - - - - - - - - - - - -
        def renderStyle(self):
            return self.__renderStyle
        @renderStyle.setter
        def renderStyle(self, renderStyle=None):
            if  renderStyle is None:
                renderStyle = SFNode.DEFAULT_VALUE
            isValidSFNode(renderStyle)
            if not isinstance(renderStyle, object):
                raise RuntimeError(str(renderStyle) + ' does not have a valid node type object')
            self.__renderStyle = renderStyle
        @property # - - - - - - - - - - - - -
        def voxels(self):
            return self.__voxels
        @voxels.setter
        def voxels(self, voxels=None):
            if  voxels is None:
                voxels = SFNode.DEFAULT_VALUE
            isValidSFNode(voxels)
            if not isinstance(voxels, object):
                raise RuntimeError(str(voxels) + ' does not have a valid node type object')
            self.__voxels = voxels

class VolumeEmitter(_X3DParticleEmitterNode):
    """
    X3D element
    """
    __name__ = 'VolumeEmitter'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#VolumeEmitter'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#VolumeEmitter'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('coordIndex', [-1], 'MFInt32', 'initializeOnly'),
                          ('direction', (0, 1, 0), 'SFVec3f', 'inputOutput'),
                          ('internal', True, 'SFBool', 'initializeOnly'),
                          ('mass', 0, 'SFFloat', 'inputOutput'),
                          ('speed', 0, 'SFFloat', 'inputOutput'),
                          ('surfaceArea', 0, 'SFFloat', 'initializeOnly'),
                          ('variation', 0.25, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('coord', None, 'SFNode', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 coordIndex=[-1],
                 direction=(0, 1, 0),
                 internal=True,
                 mass=0,
                 speed=0,
                 surfaceArea=0,
                 variation=0.25,
                 USE='',
                 class_='',
                 coord=None,
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode VolumeEmitter __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.coordIndex = coordIndex
        self.direction = direction
        self.internal = internal
        self.mass = mass
        self.speed = speed
        self.surfaceArea = surfaceArea
        self.variation = variation
        self.coord = coord
        @property # - - - - - - - - - - - - -
        def coordIndex(self):
            return self.__coordIndex
        @coordIndex.setter
        def coordIndex(self, coordIndex=None):
            if  coordIndex is None:
                coordIndex = MFInt32.DEFAULT_VALUE
            isValidMFInt32(coordIndex)
            self.__coordIndex = coordIndex
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def internal(self):
            return self.__internal
        @internal.setter
        def internal(self, internal=None):
            if  internal is None:
                internal = SFBool.DEFAULT_VALUE
            isValidSFBool(internal)
            self.__internal = internal
        @property # - - - - - - - - - - - - -
        def mass(self):
            return self.__mass
        @mass.setter
        def mass(self, mass=None):
            if  mass is None:
                mass = SFFloat.DEFAULT_VALUE
            isValidSFFloat(mass)
            self.__mass = mass
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def surfaceArea(self):
            return self.__surfaceArea
        @surfaceArea.setter
        def surfaceArea(self, surfaceArea=None):
            if  surfaceArea is None:
                surfaceArea = SFFloat.DEFAULT_VALUE
            isValidSFFloat(surfaceArea)
            self.__surfaceArea = surfaceArea
        @property # - - - - - - - - - - - - -
        def variation(self):
            return self.__variation
        @variation.setter
        def variation(self, variation=None):
            if  variation is None:
                variation = SFFloat.DEFAULT_VALUE
            isValidSFFloat(variation)
            self.__variation = variation
        @property # - - - - - - - - - - - - -
        def coord(self):
            return self.__coord
        @coord.setter
        def coord(self, coord=None):
            if  coord is None:
                coord = SFNode.DEFAULT_VALUE
            isValidSFNode(coord)
            if not isinstance(coord, object):
                raise RuntimeError(str(coord) + ' does not have a valid node type object')
            self.__coord = coord

class VolumePickSensor(_X3DPickSensorNode):
    """
    X3D element
    """
    __name__ = 'VolumePickSensor'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/picking.html#VolumePickSensor'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#VolumePickSensor'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('intersectionType', 'BOUNDS', 'SFString', 'initializeOnly'),
                          ('matchCriterion', 'MATCH_ANY', 'SFString', 'inputOutput'),
                          ('objectType', ["ALL"], 'MFString', 'inputOutput'),
                          ('sortOrder', 'CLOSEST', 'SFString', 'initializeOnly'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput'),
                          ('pickingGeometry', None, 'SFNode', 'inputOutput'),
                          ('pickTarget', list(), 'MFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 enabled=True,
                 intersectionType='BOUNDS',
                 matchCriterion='MATCH_ANY',
                 objectType=["ALL"],
                 sortOrder='CLOSEST',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None,
                 pickingGeometry=None,
                 pickTarget=list()):
        # if _DEBUG: print ('... in ConcreteNode VolumePickSensor __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.enabled = enabled
        self.intersectionType = intersectionType
        self.matchCriterion = matchCriterion
        self.objectType = objectType
        self.sortOrder = sortOrder
        self.pickingGeometry = pickingGeometry
        self.pickTarget = pickTarget
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def intersectionType(self):
            return self.__intersectionType
        @intersectionType.setter
        def intersectionType(self, intersectionType=None):
            if  intersectionType is None:
                intersectionType = SFString.DEFAULT_VALUE
            isValidSFString(intersectionType)
            self.__intersectionType = intersectionType
        @property # - - - - - - - - - - - - -
        def matchCriterion(self):
            return self.__matchCriterion
        @matchCriterion.setter
        def matchCriterion(self, matchCriterion=None):
            if  matchCriterion is None:
                matchCriterion = SFString.DEFAULT_VALUE
            isValidSFString(matchCriterion)
            self.__matchCriterion = matchCriterion
        @property # - - - - - - - - - - - - -
        def objectType(self):
            return self.__objectType
        @objectType.setter
        def objectType(self, objectType=None):
            if  objectType is None:
                objectType = MFString.DEFAULT_VALUE
            isValidMFString(objectType)
            self.__objectType = objectType
        @property # - - - - - - - - - - - - -
        def sortOrder(self):
            return self.__sortOrder
        @sortOrder.setter
        def sortOrder(self, sortOrder=None):
            if  sortOrder is None:
                sortOrder = SFString.DEFAULT_VALUE
            isValidSFString(sortOrder)
            self.__sortOrder = sortOrder
        @property # - - - - - - - - - - - - -
        def pickingGeometry(self):
            return self.__pickingGeometry
        @pickingGeometry.setter
        def pickingGeometry(self, pickingGeometry=None):
            if  pickingGeometry is None:
                pickingGeometry = SFNode.DEFAULT_VALUE
            isValidSFNode(pickingGeometry)
            if not isinstance(pickingGeometry, object):
                raise RuntimeError(str(pickingGeometry) + ' does not have a valid node type object')
            self.__pickingGeometry = pickingGeometry
        @property # - - - - - - - - - - - - -
        def pickTarget(self):
            return self.__pickTarget
        @pickTarget.setter
        def pickTarget(self, pickTarget=None):
            if  pickTarget is None:
                pickTarget = MFNode.DEFAULT_VALUE
            isValidMFNode(pickTarget)
            self.__pickTarget = pickTarget

class WindPhysicsModel(_X3DParticlePhysicsModelNode):
    """
    X3D element
    """
    __name__ = 'WindPhysicsModel'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/particle_systems.html#WindPhysicsModel'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#WindPhysicsModel'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('direction', (1, 0, 0), 'SFVec3f', 'inputOutput'),
                          ('enabled', True, 'SFBool', 'inputOutput'),
                          ('gustiness', 0.1, 'SFFloat', 'inputOutput'),
                          ('speed', 0.1, 'SFFloat', 'inputOutput'),
                          ('turbulence', 0, 'SFFloat', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 direction=(1, 0, 0),
                 enabled=True,
                 gustiness=0.1,
                 speed=0.1,
                 turbulence=0,
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode WindPhysicsModel __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.direction = direction
        self.enabled = enabled
        self.gustiness = gustiness
        self.speed = speed
        self.turbulence = turbulence
        @property # - - - - - - - - - - - - -
        def direction(self):
            return self.__direction
        @direction.setter
        def direction(self, direction=None):
            if  direction is None:
                direction = SFVec3f.DEFAULT_VALUE
            isValidSFVec3f(direction)
            self.__direction = direction
        @property # - - - - - - - - - - - - -
        def enabled(self):
            return self.__enabled
        @enabled.setter
        def enabled(self, enabled=None):
            if  enabled is None:
                enabled = SFBool.DEFAULT_VALUE
            isValidSFBool(enabled)
            self.__enabled = enabled
        @property # - - - - - - - - - - - - -
        def gustiness(self):
            return self.__gustiness
        @gustiness.setter
        def gustiness(self, gustiness=None):
            if  gustiness is None:
                gustiness = SFFloat.DEFAULT_VALUE
            isValidSFFloat(gustiness)
            self.__gustiness = gustiness
        @property # - - - - - - - - - - - - -
        def speed(self):
            return self.__speed
        @speed.setter
        def speed(self, speed=None):
            if  speed is None:
                speed = SFFloat.DEFAULT_VALUE
            isValidSFFloat(speed)
            self.__speed = speed
        @property # - - - - - - - - - - - - -
        def turbulence(self):
            return self.__turbulence
        @turbulence.setter
        def turbulence(self, turbulence=None):
            if  turbulence is None:
                turbulence = SFFloat.DEFAULT_VALUE
            isValidSFFloat(turbulence)
            self.__turbulence = turbulence

class WorldInfo(_X3DInfoNode):
    """
    WorldInfo contains a title and simple persistent metadata information about an X3D scene. This node is strictly for documentation purposes and has no effect on the visual appearance or behaviour of the world.
    """
    __name__ = 'WorldInfo'
    specificationUrl = 'https://www.web3d.org/documents/specifications/19775-1/V3.3/Part01/components/core.html#WorldInfo'
    tooltip = 'https://www.web3d.org/x3d/tooltips/X3dTooltips.html#WorldInfo'
    FIELD_DECLARATIONS = [('DEF', '', 'SFString', 'inputOutput'),
                          ('info', list(), 'MFString', 'inputOutput'),
                          ('title', '', 'SFString', 'inputOutput'),
                          ('USE', '', 'SFString', 'inputOutput'),
                          ('class_', '', 'SFString', 'inputOutput'),
                          ('IS', None, 'SFNode', 'inputOutput'),
                          ('metadata', None, 'SFNode', 'inputOutput')]
    def __init__(self,
                 DEF='',
                 info=list(),
                 title='',
                 USE='',
                 class_='',
                 IS=None,
                 metadata=None):
        # if _DEBUG: print ('... in ConcreteNode WorldInfo __init__ calling super.__init__(' + str(DEF) + ',' + str(USE) + ',' + str(class_) + ',' + str(metadata) + ',' + str(IS) + ')')
        super().__init__(DEF, USE, class_, IS, metadata) # fields for X3DNode only
        self.info = info
        self.title = title
        @property # - - - - - - - - - - - - -
        def info(self):
            return self.__info
        @info.setter
        def info(self, info=None):
            if  info is None:
                info = MFString.DEFAULT_VALUE
            isValidMFString(info)
            self.__info = info
        @property # - - - - - - - - - - - - -
        def title(self):
            return self.__title
        @title.setter
        def title(self, title=None):
            if  title is None:
                title = SFString.DEFAULT_VALUE
            isValidSFString(title)
            self.__title = title

###############################################

# Python x3d Package Loading Complete

print("x3d package loaded, have fun with X3D Graphics!")

###############################################
