fake-bpy-module 20240320__py3-none-any.whl → 20240322__py3-none-any.whl

freestyle/types/__init__.pyi

@@ -17,10 +17,10 @@ False otherwise.
     :type: bool
     """
 
-    object: "ViewEdge"
+    object: ViewEdge
     """ The ViewEdge object currently pointed to by this iterator.
 
-    :type: 'ViewEdge'
+    :type: ViewEdge
     """
 
     def __init__(self):
@@ -30,18 +30,18 @@ False otherwise.
         """
         ...
 
-    def __init__(self, brother: "AdjacencyIterator"):
+    def __init__(self, brother: AdjacencyIterator):
         """Builds an `AdjacencyIterator` using the default constructor,
         copy constructor or the overloaded constructor.
 
                 :param brother: An AdjacencyIterator object.
-                :type brother: 'AdjacencyIterator'
+                :type brother: AdjacencyIterator
         """
         ...
 
     def __init__(
         self,
-        vertex: "ViewVertex",
+        vertex: ViewVertex,
         restrict_to_selection: bool = True,
         restrict_to_unvisited: bool = True,
     ):
@@ -49,7 +49,7 @@ False otherwise.
         copy constructor or the overloaded constructor.
 
                 :param vertex: The vertex which is the next crossing.
-                :type vertex: 'ViewVertex'
+                :type vertex: ViewVertex
                 :param restrict_to_selection: Indicates whether to force the chaining
         to stay within the set of selected ViewEdges or not.
                 :type restrict_to_selection: bool
@@ -84,16 +84,16 @@ class BinaryPredicate0D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter1: "Interface0D", inter2: "Interface0D") -> bool:
+    def __call__(self, inter1: Interface0D, inter2: Interface0D) -> Interface0D:
         """Must be overload by inherited classes. It evaluates a relation
         between two Interface0D objects.
 
                 :param inter1: The first Interface0D object.
-                :type inter1: 'Interface0D'
+                :type inter1: Interface0D
                 :param inter2: The second Interface0D object.
-                :type inter2: 'Interface0D'
-                :rtype: bool
+                :type inter2: Interface0D
                 :return: True or false.
+                :rtype: bool
         """
         ...
 
@@ -115,16 +115,16 @@ class BinaryPredicate1D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter1: "Interface1D", inter2: "Interface1D") -> bool:
+    def __call__(self, inter1: Interface1D, inter2: Interface1D) -> Interface1D:
         """Must be overload by inherited classes. It evaluates a relation
         between two Interface1D objects.
 
                 :param inter1: The first Interface1D object.
-                :type inter1: 'Interface1D'
+                :type inter1: Interface1D
                 :param inter2: The second Interface1D object.
-                :type inter2: 'Interface1D'
-                :rtype: bool
+                :type inter2: Interface1D
                 :return: True or false.
+                :rtype: bool
         """
         ...
 
@@ -141,40 +141,40 @@ class Chain:
         """
         ...
 
-    def __init__(self, brother: "Chain"):
+    def __init__(self, brother: Chain):
         """Builds a `Chain` using the default constructor,
         copy constructor or from an `Id`.
 
                 :param brother: A Chain object.
-                :type brother: 'Chain'
+                :type brother: Chain
         """
         ...
 
-    def __init__(self, id: "Id"):
+    def __init__(self, id: Id):
         """Builds a `Chain` using the default constructor,
         copy constructor or from an `Id`.
 
                 :param id: An Id object.
-                :type id: 'Id'
+                :type id: Id
         """
         ...
 
-    def push_viewedge_back(self, viewedge: "ViewEdge", orientation: bool):
+    def push_viewedge_back(self, viewedge: ViewEdge, orientation: bool):
         """Adds a ViewEdge at the end of the Chain.
 
                 :param viewedge: The ViewEdge that must be added.
-                :type viewedge: 'ViewEdge'
+                :type viewedge: ViewEdge
                 :param orientation: The orientation with which the ViewEdge must be
         processed.
                 :type orientation: bool
         """
         ...
 
-    def push_viewedge_front(self, viewedge: "ViewEdge", orientation: bool):
+    def push_viewedge_front(self, viewedge: ViewEdge, orientation: bool):
         """Adds a ViewEdge at the beginning of the Chain.
 
                 :param viewedge: The ViewEdge that must be added.
-                :type viewedge: 'ViewEdge'
+                :type viewedge: ViewEdge
                 :param orientation: The orientation with which the ViewEdge must be
         processed.
                 :type orientation: bool
@@ -198,23 +198,23 @@ class ChainingIterator:
     :type: bool
     """
 
-    next_vertex: "ViewVertex"
+    next_vertex: ViewVertex
     """ The ViewVertex that is the next crossing.
 
-    :type: 'ViewVertex'
+    :type: ViewVertex
     """
 
-    object: "ViewEdge"
+    object: ViewEdge
     """ The ViewEdge object currently pointed by this iterator.
 
-    :type: 'ViewEdge'
+    :type: ViewEdge
     """
 
     def __init__(
         self,
         restrict_to_selection: bool = True,
         restrict_to_unvisited: bool = True,
-        begin: typing.Optional["ViewEdge"] = None,
+        begin=None,
         orientation: bool = True,
     ):
         """Builds a Chaining Iterator from the first ViewEdge used for
@@ -227,19 +227,18 @@ class ChainingIterator:
         already been chained must be ignored ot not.
                 :type restrict_to_unvisited: bool
                 :param begin: The ViewEdge from which to start the chain.
-                :type begin: typing.Optional['ViewEdge']
                 :param orientation: The direction to follow to explore the graph. If
         true, the direction indicated by the first ViewEdge is used.
                 :type orientation: bool
         """
         ...
 
-    def __init__(self, brother: "ChainingIterator"):
+    def __init__(self, brother: ChainingIterator):
         """Builds a Chaining Iterator from the first ViewEdge used for
         iteration and its orientation or by using the copy constructor.
 
                 :param brother:
-                :type brother: 'ChainingIterator'
+                :type brother: ChainingIterator
         """
         ...
 
@@ -251,7 +250,7 @@ class ChainingIterator:
         """
         ...
 
-    def traverse(self, it: "AdjacencyIterator") -> "ViewEdge":
+    def traverse(self, it: AdjacencyIterator) -> AdjacencyIterator:
         """This method iterates over the potential next ViewEdges and returns
         the one that will be followed next. Returns the next ViewEdge to
         follow or None when the end of the chain is reached.
@@ -259,8 +258,7 @@ class ChainingIterator:
                 :param it: The iterator over the ViewEdges adjacent to the end vertex
         of the current ViewEdge. The adjacency iterator reflects the
         restriction rules by only iterating over the valid ViewEdges.
-                :type it: 'AdjacencyIterator'
-                :rtype: 'ViewEdge'
+                :type it: AdjacencyIterator
                 :return: Returns the next ViewEdge to follow, or None if chaining ends.
         """
         ...
@@ -290,37 +288,37 @@ class Curve:
         """
         ...
 
-    def __init__(self, brother: "Curve"):
+    def __init__(self, brother: Curve):
         """Builds a `FrsCurve` using a default constructor,
         copy constructor or from an `Id`.
 
                 :param brother: A Curve object.
-                :type brother: 'Curve'
+                :type brother: Curve
         """
         ...
 
-    def __init__(self, id: "Id"):
+    def __init__(self, id: Id):
         """Builds a `FrsCurve` using a default constructor,
         copy constructor or from an `Id`.
 
                 :param id: An Id object.
-                :type id: 'Id'
+                :type id: Id
         """
         ...
 
-    def push_vertex_back(self, vertex: typing.Union["CurvePoint", "SVertex"]):
+    def push_vertex_back(self, vertex: typing.Union[SVertex, CurvePoint]):
         """Adds a single vertex at the end of the Curve.
 
         :param vertex: A vertex object.
-        :type vertex: typing.Union['CurvePoint', 'SVertex']
+        :type vertex: typing.Union[SVertex, CurvePoint]
         """
         ...
 
-    def push_vertex_front(self, vertex: typing.Union["CurvePoint", "SVertex"]):
+    def push_vertex_front(self, vertex: typing.Union[SVertex, CurvePoint]):
         """Adds a single vertex at the front of the Curve.
 
         :param vertex: A vertex object.
-        :type vertex: typing.Union['CurvePoint', 'SVertex']
+        :type vertex: typing.Union[SVertex, CurvePoint]
         """
         ...
 
@@ -335,23 +333,23 @@ class CurvePoint:
     given resolution.
     """
 
-    fedge: "FEdge"
+    fedge: FEdge
     """ Gets the FEdge for the two SVertices that given CurvePoints consists out of.
 A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).
 
-    :type: 'FEdge'
+    :type: FEdge
     """
 
-    first_svertex: "SVertex"
+    first_svertex: SVertex
     """ The first SVertex upon which the CurvePoint is built.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
-    second_svertex: "SVertex"
+    second_svertex: SVertex
     """ The second SVertex upon which the CurvePoint is built.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
     t2d: float
@@ -369,45 +367,43 @@ A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).
         """
         ...
 
-    def __init__(self, brother: "CurvePoint"):
+    def __init__(self, brother: CurvePoint):
         """Builds a CurvePoint using the default constructor, copy constructor,
         or one of the overloaded constructors. The over loaded constructors
         can either take two `SVertex` or two `CurvePoint`
         objects and an interpolation parameter
 
                 :param brother: A CurvePoint object.
-                :type brother: 'CurvePoint'
+                :type brother: CurvePoint
         """
         ...
 
-    def __init__(self, first_vertex: "SVertex", second_vertex: "SVertex", t2d: float):
+    def __init__(self, first_vertex: SVertex, second_vertex: SVertex, t2d: float):
         """Builds a CurvePoint using the default constructor, copy constructor,
         or one of the overloaded constructors. The over loaded constructors
         can either take two `SVertex` or two `CurvePoint`
         objects and an interpolation parameter
 
                 :param first_vertex: The first SVertex.
-                :type first_vertex: 'SVertex'
+                :type first_vertex: SVertex
                 :param second_vertex: The second SVertex.
-                :type second_vertex: 'SVertex'
+                :type second_vertex: SVertex
                 :param t2d: A 2D interpolation parameter used to linearly interpolate
         first_vertex and second_vertex or first_point and second_point.
                 :type t2d: float
         """
         ...
 
-    def __init__(
-        self, first_point: "CurvePoint", second_point: "CurvePoint", t2d: float
-    ):
+    def __init__(self, first_point: CurvePoint, second_point: CurvePoint, t2d: float):
         """Builds a CurvePoint using the default constructor, copy constructor,
         or one of the overloaded constructors. The over loaded constructors
         can either take two `SVertex` or two `CurvePoint`
         objects and an interpolation parameter
 
                 :param first_point: The first CurvePoint.
-                :type first_point: 'CurvePoint'
+                :type first_point: CurvePoint
                 :param second_point: The second CurvePoint.
-                :type second_point: 'CurvePoint'
+                :type second_point: CurvePoint
                 :param t2d: A 2D interpolation parameter used to linearly interpolate
         first_vertex and second_vertex or first_point and second_point.
                 :type t2d: float
@@ -420,10 +416,10 @@ class CurvePointIterator:
     through the .object attribute.
     """
 
-    object: "CurvePoint"
+    object: CurvePoint
     """ The CurvePoint object currently pointed by this iterator.
 
-    :type: 'CurvePoint'
+    :type: CurvePoint
     """
 
     t: float
@@ -445,12 +441,12 @@ class CurvePointIterator:
         """
         ...
 
-    def __init__(self, brother: "CurvePointIterator"):
+    def __init__(self, brother: CurvePointIterator):
         """Builds a CurvePointIterator object using either the default constructor,
         copy constructor, or the overloaded constructor.
 
                 :param brother: A CurvePointIterator object.
-                :type brother: 'CurvePointIterator'
+                :type brother: CurvePointIterator
         """
         ...
 
@@ -477,16 +473,16 @@ class FEdge:
     from one to the other.
     """
 
-    first_svertex: "SVertex"
+    first_svertex: SVertex
     """ The first SVertex constituting this FEdge.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
-    id: "Id"
+    id: Id
     """ The Id of this FEdge.
 
-    :type: 'Id'
+    :type: Id
     """
 
     is_smooth: bool
@@ -495,36 +491,36 @@ class FEdge:
     :type: bool
     """
 
-    nature: "Nature"
+    nature: Nature
     """ The nature of this FEdge.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
-    next_fedge: "FEdge"
+    next_fedge: FEdge
     """ The FEdge following this one in the ViewEdge. The value is None if
 this FEdge is the last of the ViewEdge.
 
-    :type: 'FEdge'
+    :type: FEdge
     """
 
-    previous_fedge: "FEdge"
+    previous_fedge: FEdge
     """ The FEdge preceding this one in the ViewEdge. The value is None if
 this FEdge is the first one of the ViewEdge.
 
-    :type: 'FEdge'
+    :type: FEdge
     """
 
-    second_svertex: "SVertex"
+    second_svertex: SVertex
     """ The second SVertex constituting this FEdge.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
-    viewedge: "ViewEdge"
+    viewedge: ViewEdge
     """ The ViewEdge to which this FEdge belongs to.
 
-    :type: 'ViewEdge'
+    :type: ViewEdge
     """
 
     def FEdge(self):
@@ -534,12 +530,12 @@ this FEdge is the first one of the ViewEdge.
         """
         ...
 
-    def FEdge(self, brother: "FEdge"):
+    def FEdge(self, brother: FEdge):
         """Builds an `FEdge` using the default constructor,
         copy constructor, or between two `SVertex` objects.
 
                 :param brother: An FEdge object.
-                :type brother: 'FEdge'
+                :type brother: FEdge
         """
         ...
 
@@ -580,30 +576,30 @@ no material.
     :type: int
     """
 
-    material_left: "Material"
+    material_left: Material
     """ The material of the face lying on the left of the FEdge.
 
-    :type: 'Material'
+    :type: Material
     """
 
-    material_right: "Material"
+    material_right: Material
     """ The material of the face lying on the right of the FEdge. If this FEdge
 is a border, it has no Face on its right and therefore no material.
 
-    :type: 'Material'
+    :type: Material
     """
 
-    normal_left: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    normal_left: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal to the face lying on the left of the FEdge.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    normal_right: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    normal_right: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal to the face lying on the right of the FEdge. If this FEdge
 is a border, it has no Face on its right and therefore no normal.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     def __init__(self):
@@ -613,23 +609,23 @@ is a border, it has no Face on its right and therefore no normal.
         """
         ...
 
-    def __init__(self, brother: "FEdgeSharp"):
+    def __init__(self, brother: FEdgeSharp):
         """Builds an `FEdgeSharp` using the default constructor,
         copy constructor, or between two `SVertex` objects.
 
                 :param brother: An FEdgeSharp object.
-                :type brother: 'FEdgeSharp'
+                :type brother: FEdgeSharp
         """
         ...
 
-    def __init__(self, first_vertex: "SVertex", second_vertex: "SVertex"):
+    def __init__(self, first_vertex: SVertex, second_vertex: SVertex):
         """Builds an `FEdgeSharp` using the default constructor,
         copy constructor, or between two `SVertex` objects.
 
                 :param first_vertex: The first SVertex object.
-                :type first_vertex: 'SVertex'
+                :type first_vertex: SVertex
                 :param second_vertex: The second SVertex object.
-                :type second_vertex: 'SVertex'
+                :type second_vertex: SVertex
         """
         ...
 
@@ -645,10 +641,10 @@ class FEdgeSmooth:
     :type: bool
     """
 
-    material: "Material"
+    material: Material
     """ The material of the face that this FEdge is running across.
 
-    :type: 'Material'
+    :type: Material
     """
 
     material_index: int
@@ -657,10 +653,10 @@ class FEdgeSmooth:
     :type: int
     """
 
-    normal: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    normal: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal of the face that this FEdge is running across.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     def __init__(self):
@@ -670,23 +666,23 @@ class FEdgeSmooth:
         """
         ...
 
-    def __init__(self, brother: "FEdgeSmooth"):
+    def __init__(self, brother: FEdgeSmooth):
         """Builds an `FEdgeSmooth` using the default constructor,
         copy constructor, or between two `SVertex`.
 
                 :param brother: An FEdgeSmooth object.
-                :type brother: 'FEdgeSmooth'
+                :type brother: FEdgeSmooth
         """
         ...
 
-    def __init__(self, first_vertex: "SVertex", second_vertex: "SVertex"):
+    def __init__(self, first_vertex: SVertex, second_vertex: SVertex):
         """Builds an `FEdgeSmooth` using the default constructor,
         copy constructor, or between two `SVertex`.
 
                 :param first_vertex: The first SVertex object.
-                :type first_vertex: 'SVertex'
+                :type first_vertex: SVertex
                 :param second_vertex: The second SVertex object.
-                :type second_vertex: 'SVertex'
+                :type second_vertex: SVertex
         """
         ...
 
@@ -705,11 +701,10 @@ class Id:
     :type: int
     """
 
-    def __init__(self, brother: "Id"):
+    def __init__(self, brother):
         """Build the Id from two numbers or another `Id` using the copy constructor.
 
         :param brother: An Id object.
-        :type brother: 'Id'
         """
         ...
 
@@ -734,10 +729,10 @@ class IntegrationType:
 class Interface0D:
     """Base class for any 0D element."""
 
-    id: "Id"
+    id: Id
     """ The Id of this 0D element.
 
-    :type: 'Id'
+    :type: Id
     """
 
     name: str
@@ -746,22 +741,22 @@ class Interface0D:
     :type: str
     """
 
-    nature: "Nature"
+    nature: Nature
     """ The nature of this 0D element.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
-    point_2d: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    point_2d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The 2D point of this 0D element.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    point_3d: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    point_3d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The 3D point of this 0D element.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     projected_x: float
@@ -786,14 +781,14 @@ class Interface0D:
         """Default constructor."""
         ...
 
-    def get_fedge(self, inter: "Interface0D") -> "FEdge":
+    def get_fedge(self, inter: Interface0D) -> Interface0D:
         """Returns the FEdge that lies between this 0D element and the 0D
         element given as the argument.
 
                 :param inter: A 0D element.
-                :type inter: 'Interface0D'
-                :rtype: 'FEdge'
+                :type inter: Interface0D
                 :return: The FEdge lying between the two 0D elements.
+                :rtype: FEdge
         """
         ...
 
@@ -809,13 +804,13 @@ For its counterpart (pointing to the first valid element), use it.is_begin.
     :type: bool
     """
 
-    object: "Interface0D"
+    object: Interface0D
     """ The 0D object currently pointed to by this iterator. Note that the object
 may be an instance of an Interface0D subclass. For example if the iterator
 has been created from the vertices_begin() method of the `Stroke`
 class, the .object property refers to a `StrokeVertex` object.
 
-    :type: 'Interface0D'
+    :type: Interface0D
     """
 
     t: float
@@ -830,31 +825,31 @@ class, the .object property refers to a `StrokeVertex` object.
     :type: float
     """
 
-    def __init__(self, brother: "Interface0DIterator"):
+    def __init__(self, brother: Interface0DIterator):
         """Construct a nested Interface0DIterator using either the copy constructor
         or the constructor that takes an he argument of a Function0D.
 
                 :param brother: An Interface0DIterator object.
-                :type brother: 'Interface0DIterator'
+                :type brother: Interface0DIterator
         """
         ...
 
-    def __init__(self, it: typing.Union["CurvePointIterator", "SVertexIterator"]):
+    def __init__(self, it: typing.Union[SVertexIterator, CurvePointIterator]):
         """Construct a nested Interface0DIterator using either the copy constructor
         or the constructor that takes an he argument of a Function0D.
 
                 :param it: An iterator object to be nested.
-                :type it: typing.Union['CurvePointIterator', 'SVertexIterator']
+                :type it: typing.Union[SVertexIterator, CurvePointIterator]
         """
         ...
 
 class Interface1D:
     """Base class for any 1D element."""
 
-    id: "Id"
+    id: Id
     """ The Id of this Interface1D.
 
-    :type: 'Id'
+    :type: Id
     """
 
     length_2d: float
@@ -869,10 +864,10 @@ class Interface1D:
     :type: str
     """
 
-    nature: "Nature"
+    nature: Nature
     """ The nature of this Interface1D.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
     time_stamp: int
@@ -885,7 +880,7 @@ class Interface1D:
         """Default constructor."""
         ...
 
-    def points_begin(self, t: float = 0.0) -> "Interface0DIterator":
+    def points_begin(self, t: float = 0.0) -> float:
         """Returns an iterator over the Interface1D points, pointing to the
         first point. The difference with vertices_begin() is that here we can
         iterate over points of the 1D element at a any given sampling.
@@ -894,12 +889,12 @@ class Interface1D:
                 :param t: A sampling with which we want to iterate over points of
         this 1D element.
                 :type t: float
-                :rtype: 'Interface0DIterator'
                 :return: An Interface0DIterator pointing to the first point.
+                :rtype: Interface0DIterator
         """
         ...
 
-    def points_end(self, t: float = 0.0) -> "Interface0DIterator":
+    def points_end(self, t: float = 0.0) -> float:
         """Returns an iterator over the Interface1D points, pointing after the
         last point. The difference with vertices_end() is that here we can
         iterate over points of the 1D element at a given sampling. Indeed,
@@ -908,26 +903,26 @@ class Interface1D:
                 :param t: A sampling with which we want to iterate over points of
         this 1D element.
                 :type t: float
-                :rtype: 'Interface0DIterator'
                 :return: An Interface0DIterator pointing after the last point.
+                :rtype: Interface0DIterator
         """
         ...
 
-    def vertices_begin(self) -> "Interface0DIterator":
+    def vertices_begin(self) -> Interface0DIterator:
         """Returns an iterator over the Interface1D vertices, pointing to the
         first vertex.
 
-                :rtype: 'Interface0DIterator'
                 :return: An Interface0DIterator pointing to the first vertex.
+                :rtype: Interface0DIterator
         """
         ...
 
-    def vertices_end(self) -> "Interface0DIterator":
+    def vertices_end(self) -> Interface0DIterator:
         """Returns an iterator over the Interface1D vertices, pointing after
         the last vertex.
 
-                :rtype: 'Interface0DIterator'
                 :return: An Interface0DIterator pointing after the last vertex.
+                :rtype: Interface0DIterator
         """
         ...
 
@@ -967,28 +962,28 @@ class Iterator:
 class Material:
     """Class defining a material."""
 
-    ambient: typing.Union["mathutils.Color", typing.Sequence[float]]
+    ambient: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGBA components of the ambient color of the material.
 
-    :type: typing.Union['mathutils.Color', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Color]
     """
 
-    diffuse: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    diffuse: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the diffuse color of the material.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    emission: typing.Union["mathutils.Color", typing.Sequence[float]]
+    emission: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGBA components of the emissive color of the material.
 
-    :type: typing.Union['mathutils.Color', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Color]
     """
 
-    line: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    line: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the line color of the material.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     priority: int
@@ -1003,10 +998,10 @@ class Material:
     :type: float
     """
 
-    specular: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    specular: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the specular color of the material.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     def __init__(self):
@@ -1016,22 +1011,22 @@ class Material:
         """
         ...
 
-    def __init__(self, brother: "Material"):
+    def __init__(self, brother: Material):
         """Creates a `FrsMaterial` using either default constructor,
         copy constructor, or an overloaded constructor
 
                 :param brother: A Material object to be used as a copy constructor.
-                :type brother: 'Material'
+                :type brother: Material
         """
         ...
 
     def __init__(
         self,
-        line: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
-        diffuse: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
-        ambient: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
-        specular: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
-        emission: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
+        line: typing.Union[typing.Sequence[float], mathutils.Vector, list],
+        diffuse: typing.Union[typing.Sequence[float], mathutils.Vector, list],
+        ambient: typing.Union[typing.Sequence[float], mathutils.Vector, list],
+        specular: typing.Union[typing.Sequence[float], mathutils.Vector, list],
+        emission: typing.Union[typing.Sequence[float], mathutils.Vector, list],
         shininess: float,
         priority: int,
     ):
@@ -1039,15 +1034,15 @@ class Material:
         copy constructor, or an overloaded constructor
 
                 :param line: The line color.
-                :type line: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type line: typing.Union[typing.Sequence[float], mathutils.Vector, list]
                 :param diffuse: The diffuse color.
-                :type diffuse: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type diffuse: typing.Union[typing.Sequence[float], mathutils.Vector, list]
                 :param ambient: The ambient color.
-                :type ambient: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type ambient: typing.Union[typing.Sequence[float], mathutils.Vector, list]
                 :param specular: The specular color.
-                :type specular: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type specular: typing.Union[typing.Sequence[float], mathutils.Vector, list]
                 :param emission: The emissive color.
-                :type emission: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type emission: typing.Union[typing.Sequence[float], mathutils.Vector, list]
                 :param shininess: The shininess coefficient.
                 :type shininess: float
                 :param priority: The line color priority.
@@ -1085,36 +1080,36 @@ class Noise:
 
         :param v: One-dimensional sample point.
         :type v: float
-        :rtype: float
         :return: A smooth noise value.
+        :rtype: float
         """
         ...
 
     def smoothNoise2(
-        self, v: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]]
-    ) -> float:
+        self, v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
+    ) -> typing.Union[typing.Sequence[float], mathutils.Vector, list]:
         """Returns a smooth noise value for a 2D element.
 
         :param v: Two-dimensional sample point.
-        :type v: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
-        :rtype: float
+        :type v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         :return: A smooth noise value.
+        :rtype: float
         """
         ...
 
     def smoothNoise3(
-        self, v: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]]
-    ) -> float:
+        self, v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
+    ) -> typing.Union[typing.Sequence[float], mathutils.Vector, list]:
         """Returns a smooth noise value for a 3D element.
 
         :param v: Three-dimensional sample point.
-        :type v: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
-        :rtype: float
+        :type v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         :return: A smooth noise value.
+        :rtype: float
         """
         ...
 
-    def turbulence1(self, v: float, freq: float, amp: float, oct: int = 4) -> float:
+    def turbulence1(self, v: float, freq: float, amp: float, oct: int = 4) -> int:
         """Returns a noise value for a 1D element.
 
         :param v: One-dimensional sample point.
@@ -1125,52 +1120,52 @@ class Noise:
         :type amp: float
         :param oct: Number of octaves.
         :type oct: int
-        :rtype: float
         :return: A noise value.
+        :rtype: float
         """
         ...
 
     def turbulence2(
         self,
-        v: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
+        v: typing.Union[typing.Sequence[float], mathutils.Vector, list],
         freq: float,
         amp: float,
         oct: int = 4,
-    ) -> float:
+    ) -> int:
         """Returns a noise value for a 2D element.
 
         :param v: Two-dimensional sample point.
-        :type v: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+        :type v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         :param freq: Noise frequency.
         :type freq: float
         :param amp: Amplitude.
         :type amp: float
         :param oct: Number of octaves.
         :type oct: int
-        :rtype: float
         :return: A noise value.
+        :rtype: float
         """
         ...
 
     def turbulence3(
         self,
-        v: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
+        v: typing.Union[typing.Sequence[float], mathutils.Vector, list],
         freq: float,
         amp: float,
         oct: int = 4,
-    ) -> float:
+    ) -> int:
         """Returns a noise value for a 3D element.
 
         :param v: Three-dimensional sample point.
-        :type v: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+        :type v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         :param freq: Noise frequency.
         :type freq: float
         :param amp: Amplitude.
         :type amp: float
         :param oct: Number of octaves.
         :type oct: int
-        :rtype: float
         :return: A noise value.
+        :rtype: float
         """
         ...
 
@@ -1179,21 +1174,21 @@ class NonTVertex:
     Can be associated to 2 or more view edges.
     """
 
-    svertex: "SVertex"
+    svertex: SVertex
     """ The SVertex on top of which this NonTVertex is built.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
     def __init__(self):
         """Builds a `NonTVertex` using the default constructor or a `SVertex`."""
         ...
 
-    def __init__(self, svertex: "SVertex"):
+    def __init__(self, svertex: SVertex):
         """Builds a `NonTVertex` using the default constructor or a `SVertex`.
 
         :param svertex: An SVertex object.
-        :type svertex: 'SVertex'
+        :type svertex: SVertex
         """
         ...
 
@@ -1204,7 +1199,8 @@ class Operators:
     predicates and shaders that are taken as arguments.
     """
 
-    def bidirectional_chain(self, it: "ChainingIterator", pred: "UnaryPredicate1D"):
+    @staticmethod
+    def bidirectional_chain(it: ChainingIterator, pred: UnaryPredicate1D):
         """Builds a set of chains from the current set of ViewEdges. Each
         ViewEdge of the current list potentially starts a new chain. The
         chaining operator then iterates over the ViewEdges of the ViewMap
@@ -1219,15 +1215,16 @@ class Operators:
 
                 :param it: The ChainingIterator on the ViewEdges of the ViewMap. It
         contains the chaining rule.
-                :type it: 'ChainingIterator'
+                :type it: ChainingIterator
                 :param pred: The predicate on the ViewEdge that expresses the stopping condition.
         This parameter is optional, you make not want to pass a stopping criterion
         when the stopping criterion is already contained in the iterator definition.
-                :type pred: 'UnaryPredicate1D'
+                :type pred: UnaryPredicate1D
         """
         ...
 
-    def bidirectional_chain(self, it: "ChainingIterator"):
+    @staticmethod
+    def bidirectional_chain(it: ChainingIterator):
         """Builds a set of chains from the current set of ViewEdges. Each
         ViewEdge of the current list potentially starts a new chain. The
         chaining operator then iterates over the ViewEdges of the ViewMap
@@ -1242,15 +1239,13 @@ class Operators:
 
                 :param it: The ChainingIterator on the ViewEdges of the ViewMap. It
         contains the chaining rule.
-                :type it: 'ChainingIterator'
+                :type it: ChainingIterator
         """
         ...
 
+    @staticmethod
     def chain(
-        self,
-        it: "ViewEdgeIterator",
-        pred: "UnaryPredicate1D",
-        modifier: "UnaryFunction1DVoid",
+        it: ViewEdgeIterator, pred: UnaryPredicate1D, modifier: UnaryFunction1DVoid
     ):
         """Builds a set of chains from the current set of ViewEdges. Each
         ViewEdge of the current list starts a new chain. The chaining
@@ -1260,19 +1255,20 @@ class Operators:
 
                 :param it: The iterator on the ViewEdges of the ViewMap. It contains
         the chaining rule.
-                :type it: 'ViewEdgeIterator'
+                :type it: ViewEdgeIterator
                 :param pred: The predicate on the ViewEdge that expresses the
         stopping condition.
-                :type pred: 'UnaryPredicate1D'
+                :type pred: UnaryPredicate1D
                 :param modifier: A function that takes a ViewEdge as argument and
         that is used to modify the processed ViewEdge state (the
         timestamp incrementation is a typical illustration of such a modifier).
         If this argument is not given, the time stamp is automatically managed.
-                :type modifier: 'UnaryFunction1DVoid'
+                :type modifier: UnaryFunction1DVoid
         """
         ...
 
-    def chain(self, it: "ViewEdgeIterator", pred: "UnaryPredicate1D"):
+    @staticmethod
+    def chain(it: ViewEdgeIterator, pred: UnaryPredicate1D):
         """Builds a set of chains from the current set of ViewEdges. Each
         ViewEdge of the current list starts a new chain. The chaining
         operator then iterates over the ViewEdges of the ViewMap using the
@@ -1281,84 +1277,88 @@ class Operators:
 
                 :param it: The iterator on the ViewEdges of the ViewMap. It contains
         the chaining rule.
-                :type it: 'ViewEdgeIterator'
+                :type it: ViewEdgeIterator
                 :param pred: The predicate on the ViewEdge that expresses the
         stopping condition.
-                :type pred: 'UnaryPredicate1D'
+                :type pred: UnaryPredicate1D
         """
         ...
 
-    def create(self, pred: "UnaryPredicate1D", shaders: typing.List["StrokeShader"]):
+    @staticmethod
+    def create(pred: UnaryPredicate1D, shaders):
         """Creates and shades the strokes from the current set of chains. A
         predicate can be specified to make a selection pass on the chains.
 
                 :param pred: The predicate that a chain must verify in order to be
         transform as a stroke.
-                :type pred: 'UnaryPredicate1D'
+                :type pred: UnaryPredicate1D
                 :param shaders: The list of shaders used to shade the strokes.
-                :type shaders: typing.List['StrokeShader']
         """
         ...
 
-    def get_chain_from_index(self, i: int) -> "Chain":
+    @staticmethod
+    def get_chain_from_index(i: int) -> int:
         """Returns the Chain at the index in the current set of Chains.
 
         :param i: index (0 <= i < Operators.get_chains_size()).
         :type i: int
-        :rtype: 'Chain'
         :return: The Chain object.
+        :rtype: Chain
         """
         ...
 
-    def get_chains_size(self) -> int:
+    @staticmethod
+    def get_chains_size() -> Chain:
         """Returns the number of Chains.
 
-        :rtype: int
         :return: The number of Chains.
+        :rtype: int
         """
         ...
 
-    def get_stroke_from_index(self, i: int) -> "Stroke":
+    @staticmethod
+    def get_stroke_from_index(i: int) -> int:
         """Returns the Stroke at the index in the current set of Strokes.
 
         :param i: index (0 <= i < Operators.get_strokes_size()).
         :type i: int
-        :rtype: 'Stroke'
         :return: The Stroke object.
+        :rtype: Stroke
         """
         ...
 
-    def get_strokes_size(self) -> int:
+    @staticmethod
+    def get_strokes_size() -> Stroke:
         """Returns the number of Strokes.
 
-        :rtype: int
         :return: The number of Strokes.
+        :rtype: int
         """
         ...
 
-    def get_view_edges_size(self) -> int:
+    @staticmethod
+    def get_view_edges_size() -> int:
         """Returns the number of ViewEdges.
 
-        :rtype: int
         :return: The number of ViewEdges.
+        :rtype: int
         """
         ...
 
-    def get_viewedge_from_index(self, i: int) -> "ViewEdge":
+    @staticmethod
+    def get_viewedge_from_index(i: int) -> int:
         """Returns the ViewEdge at the index in the current set of ViewEdges.
 
         :param i: index (0 <= i < Operators.get_view_edges_size()).
         :type i: int
-        :rtype: 'ViewEdge'
         :return: The ViewEdge object.
+        :rtype: ViewEdge
         """
         ...
 
+    @staticmethod
     def recursive_split(
-        self,
-        func: "UnaryFunction0DDouble",
-        pred_1d: "UnaryPredicate1D",
-        sampling: float = 0.0,
+        func: UnaryFunction0DDouble, pred_1d: UnaryPredicate1D, sampling: float = 0.0
     ):
         """Splits the current set of chains in a recursive way. We process the
         points of each chain (with a specified sampling) to find the point
@@ -1371,12 +1371,12 @@ class Operators:
 
                 :param func: The Unary Function evaluated at each point of the chain.
         The splitting point is the point minimizing this function.
-                :type func: 'UnaryFunction0DDouble'
+                :type func: UnaryFunction0DDouble
                 :param pred_1d: The Unary Predicate expressing the recursivity stopping
         condition. This predicate is evaluated for each curve before it
         actually gets split. If pred_1d(chain) is true, the curve won't be
         split anymore.
-                :type pred_1d: 'UnaryPredicate1D'
+                :type pred_1d: UnaryPredicate1D
                 :param sampling: The resolution used to sample the chain for the
         predicates evaluation. (The chain is not actually resampled; a
         virtual point only progresses along the curve using this
@@ -1385,11 +1385,11 @@ class Operators:
         """
         ...
 
+    @staticmethod
     def recursive_split(
-        self,
-        func: "UnaryFunction0DDouble",
-        pred_0d: "UnaryPredicate0D",
-        pred_1d: "UnaryPredicate1D",
+        func: UnaryFunction0DDouble,
+        pred_0d: UnaryPredicate0D,
+        pred_1d: UnaryPredicate1D,
         sampling: float = 0.0,
     ):
         """Splits the current set of chains in a recursive way. We process the
@@ -1403,18 +1403,18 @@ class Operators:
 
                 :param func: The Unary Function evaluated at each point of the chain.
         The splitting point is the point minimizing this function.
-                :type func: 'UnaryFunction0DDouble'
+                :type func: UnaryFunction0DDouble
                 :param pred_0d: The Unary Predicate 0D used to select the candidate
         points where the split can occur. For example, it is very likely
         that would rather have your chain splitting around its middle
         point than around one of its extremities. A 0D predicate working
         on the curvilinear abscissa allows to add this kind of constraints.
-                :type pred_0d: 'UnaryPredicate0D'
+                :type pred_0d: UnaryPredicate0D
                 :param pred_1d: The Unary Predicate expressing the recursivity stopping
         condition. This predicate is evaluated for each curve before it
         actually gets split. If pred_1d(chain) is true, the curve won't be
         split anymore.
-                :type pred_1d: 'UnaryPredicate1D'
+                :type pred_1d: UnaryPredicate1D
                 :param sampling: The resolution used to sample the chain for the
         predicates evaluation. (The chain is not actually resampled; a
         virtual point only progresses along the curve using this
@@ -1423,7 +1423,8 @@ class Operators:
         """
         ...
 
-    def reset(self, delete_strokes: bool = True):
+    @staticmethod
+    def reset(delete_strokes: bool = True):
         """Resets the line stylization process to the initial state. The results of
         stroke creation are accumulated if delete_strokes is set to False.
 
@@ -1432,19 +1433,20 @@ class Operators:
         """
         ...
 
-    def select(self, pred: "UnaryPredicate1D"):
+    @staticmethod
+    def select(pred: UnaryPredicate1D):
         """Selects the ViewEdges of the ViewMap verifying a specified
         condition.
 
                 :param pred: The predicate expressing this condition.
-                :type pred: 'UnaryPredicate1D'
+                :type pred: UnaryPredicate1D
         """
         ...
 
+    @staticmethod
     def sequential_split(
-        self,
-        starting_pred: "UnaryPredicate0D",
-        stopping_pred: "UnaryPredicate0D",
+        starting_pred: UnaryPredicate0D,
+        stopping_pred: UnaryPredicate0D,
         sampling: float = 0.0,
     ):
         """Splits each chain of the current set of chains in a sequential way.
@@ -1455,10 +1457,10 @@ class Operators:
 
                 :param starting_pred: The predicate on a point that expresses the
         starting condition. Each time this condition is verified, a new chain begins
-                :type starting_pred: 'UnaryPredicate0D'
+                :type starting_pred: UnaryPredicate0D
                 :param stopping_pred: The predicate on a point that expresses the
         stopping condition. The chain ends as soon as this predicate is verified.
-                :type stopping_pred: 'UnaryPredicate0D'
+                :type stopping_pred: UnaryPredicate0D
                 :param sampling: The resolution used to sample the chain for the
         predicates evaluation. (The chain is not actually resampled;
         a virtual point only progresses along the curve using this
@@ -1467,7 +1469,8 @@ class Operators:
         """
         ...
 
-    def sequential_split(self, pred: "UnaryPredicate0D", sampling: float = 0.0):
+    @staticmethod
+    def sequential_split(pred: UnaryPredicate0D, sampling: float = 0.0):
         """Splits each chain of the current set of chains in a sequential way.
         The points of each chain are processed (with a specified sampling)
         sequentially. The first point of the initial chain is the
@@ -1477,7 +1480,7 @@ class Operators:
                 :param pred: The predicate on a point that expresses the splitting condition.
         Each time the condition is verified, the chain is split into two chains.
         The resulting set of chains is a partition of the initial chain
-                :type pred: 'UnaryPredicate0D'
+                :type pred: UnaryPredicate0D
                 :param sampling: The resolution used to sample the chain for the
         predicates evaluation. (The chain is not actually resampled;
         a virtual point only progresses along the curve using this
@@ -1486,12 +1489,13 @@ class Operators:
         """
         ...
 
-    def sort(self, pred: "BinaryPredicate1D"):
+    @staticmethod
+    def sort(pred: BinaryPredicate1D):
         """Sorts the current set of chains (or viewedges) according to the
         comparison predicate given as argument.
 
                 :param pred: The binary predicate used for the comparison.
-                :type pred: 'BinaryPredicate1D'
+                :type pred: BinaryPredicate1D
         """
         ...
 
@@ -1500,22 +1504,22 @@ class SShape:
     elements from an identified input shape.
     """
 
-    bbox: "BBox"
+    bbox: BBox
     """ The bounding box of the SShape.
 
-    :type: 'BBox'
+    :type: BBox
     """
 
-    edges: typing.List["FEdge"]
+    edges: typing.List[FEdge]
     """ The list of edges constituting this SShape.
 
-    :type: typing.List['FEdge']
+    :type: typing.List[FEdge]
     """
 
-    id: "Id"
+    id: Id
     """ The Id of this SShape.
 
-    :type: 'Id'
+    :type: Id
     """
 
     name: str
@@ -1524,38 +1528,38 @@ class SShape:
     :type: str
     """
 
-    vertices: typing.List["SVertex"]
+    vertices: typing.List[SVertex]
     """ The list of vertices constituting this SShape.
 
-    :type: typing.List['SVertex']
+    :type: typing.List[SVertex]
     """
 
     def __init__(self):
         """Creates a `SShape` class using either a default constructor or copy constructor."""
         ...
 
-    def __init__(self, brother: "SShape"):
+    def __init__(self, brother: SShape):
         """Creates a `SShape` class using either a default constructor or copy constructor.
 
         :param brother: An SShape object.
-        :type brother: 'SShape'
+        :type brother: SShape
         """
         ...
 
-    def add_edge(self, edge: "FEdge"):
+    def add_edge(self, edge: FEdge):
         """Adds an FEdge to the list of FEdges.
 
         :param edge: An FEdge object.
-        :type edge: 'FEdge'
+        :type edge: FEdge
         """
         ...
 
-    def add_vertex(self, vertex: "SVertex"):
+    def add_vertex(self, vertex: SVertex):
         """Adds an SVertex to the list of SVertex of this Shape. The SShape
         attribute of the SVertex is also set to this SShape.
 
                 :param vertex: An SVertex object.
-                :type vertex: 'SVertex'
+                :type vertex: SVertex
         """
         ...
 
@@ -1580,19 +1584,16 @@ derivative of the radial curvature at this SVertex, respectively.
     :type: typing.Tuple
     """
 
-    id: "Id"
+    id: Id
     """ The Id of this SVertex.
 
-    :type: 'Id'
+    :type: Id
     """
 
-    normals: typing.List["mathutils.Vector"]
+    normals: typing.Any
     """ The normals for this Vertex as a list. In a sharp surface, an SVertex
 has exactly one normal. In a smooth surface, an SVertex can have any
-number of normals.
-
-    :type: typing.List['mathutils.Vector']
-    """
+number of normals."""
 
     normals_size: int
     """ The number of different normals for this SVertex.
@@ -1600,23 +1601,23 @@ number of normals.
     :type: int
     """
 
-    point_2d: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    point_2d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The projected 3D coordinates of the SVertex.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    point_3d: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    point_3d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The 3D coordinates of the SVertex.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    viewvertex: "ViewVertex"
+    viewvertex: ViewVertex
     """ If this SVertex is also a ViewVertex, this property refers to the
 ViewVertex, and None otherwise.
 
-    :type: 'ViewVertex'
+    :type: ViewVertex
     """
 
     def __init__(self):
@@ -1626,47 +1627,44 @@ ViewVertex, and None otherwise.
         """
         ...
 
-    def __init__(self, brother: "SVertex"):
+    def __init__(self, brother: SVertex):
         """Builds a `SVertex` using the default constructor,
         copy constructor or the overloaded constructor which builds   a `SVertex` from 3D coordinates and an Id.
 
                 :param brother: A SVertex object.
-                :type brother: 'SVertex'
+                :type brother: SVertex
         """
         ...
 
     def __init__(
-        self,
-        point_3d: typing.Union["mathutils.Vector", typing.Sequence[float]],
-        id: "Id",
+        self, point_3d: typing.Union[typing.Sequence[float], mathutils.Vector], id: Id
     ):
         """Builds a `SVertex` using the default constructor,
         copy constructor or the overloaded constructor which builds   a `SVertex` from 3D coordinates and an Id.
 
                 :param point_3d: A three-dimensional vector.
-                :type point_3d: typing.Union['mathutils.Vector', typing.Sequence[float]]
+                :type point_3d: typing.Union[typing.Sequence[float], mathutils.Vector]
                 :param id: An Id object.
-                :type id: 'Id'
+                :type id: Id
         """
         ...
 
-    def add_fedge(self, fedge: "FEdge"):
+    def add_fedge(self, fedge: FEdge):
         """Add an FEdge to the list of edges emanating from this SVertex.
 
         :param fedge: An FEdge.
-        :type fedge: 'FEdge'
+        :type fedge: FEdge
         """
         ...
 
     def add_normal(
-        self,
-        normal: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
+        self, normal: typing.Union[typing.Sequence[float], mathutils.Vector, list]
     ):
         """Adds a normal to the SVertex's set of normals. If the same normal
         is already in the set, nothing changes.
 
                 :param normal: A three-dimensional vector.
-                :type normal: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type normal: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         """
         ...
 
@@ -1676,10 +1674,10 @@ class SVertexIterator:
     from a ViewEdge by calling verticesBegin() or verticesEnd().
     """
 
-    object: "SVertex"
+    object: SVertex
     """ The SVertex object currently pointed by this iterator.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
     t: float
@@ -1698,32 +1696,32 @@ class SVertexIterator:
         """Build an SVertexIterator using either the default constructor, copy constructor,or the overloaded constructor that starts iteration from an SVertex object vertex."""
         ...
 
-    def __init__(self, brother: "SVertexIterator"):
+    def __init__(self, brother: SVertexIterator):
         """Build an SVertexIterator using either the default constructor, copy constructor,or the overloaded constructor that starts iteration from an SVertex object vertex.
 
         :param brother: An SVertexIterator object.
-        :type brother: 'SVertexIterator'
+        :type brother: SVertexIterator
         """
         ...
 
     def __init__(
         self,
-        vertex: "SVertex",
-        begin: "SVertex",
-        previous_edge: "FEdge",
-        next_edge: "FEdge",
+        vertex: SVertex,
+        begin: SVertex,
+        previous_edge: FEdge,
+        next_edge: FEdge,
         t: float,
     ):
         """Build an SVertexIterator using either the default constructor, copy constructor,or the overloaded constructor that starts iteration from an SVertex object vertex.
 
         :param vertex: The SVertex from which the iterator starts iteration.
-        :type vertex: 'SVertex'
+        :type vertex: SVertex
         :param begin: The first SVertex of a ViewEdge.
-        :type begin: 'SVertex'
+        :type begin: SVertex
         :param previous_edge: The previous FEdge coming to vertex.
-        :type previous_edge: 'FEdge'
+        :type previous_edge: FEdge
         :param next_edge: The next FEdge going out from vertex.
-        :type next_edge: 'FEdge'
+        :type next_edge: FEdge
         :param t: The curvilinear abscissa at vertex.
         :type t: float
         """
@@ -1736,10 +1734,10 @@ class Stroke:
     defines the stroke's shape and appearance at this vertex position.
     """
 
-    id: "Id"
+    id: Id
     """ The Id of this Stroke.
 
-    :type: 'Id'
+    :type: Id
     """
 
     length_2d: float
@@ -1748,10 +1746,10 @@ class Stroke:
     :type: float
     """
 
-    medium_type: "MediumType"
+    medium_type: MediumType
     """ The MediumType used for this Stroke.
 
-    :type: 'MediumType'
+    :type: MediumType
     """
 
     texture_id: int
@@ -1774,11 +1772,10 @@ class Stroke:
         """Creates a `Stroke` using the default constructor or copy constructor
 
         :param brother:
-        :type brother:
         """
         ...
 
-    def compute_sampling(self, n: int) -> float:
+    def compute_sampling(self, n: int) -> int:
         """Compute the sampling needed to get N vertices. If the
         specified number of vertices is less than the actual number of
         vertices, the actual sampling value is returned. (To remove Vertices,
@@ -1787,22 +1784,22 @@ class Stroke:
                 :param n: The number of stroke vertices we eventually want
         in our Stroke.
                 :type n: int
-                :rtype: float
                 :return: The sampling that must be used in the Resample(float)
         method.
+                :rtype: float
         """
         ...
 
-    def insert_vertex(self, vertex: "StrokeVertex", next: "StrokeVertexIterator"):
+    def insert_vertex(self, vertex: StrokeVertex, next: StrokeVertexIterator):
         """Inserts the StrokeVertex given as argument into the Stroke before the
         point specified by next. The length and curvilinear abscissa are
         updated consequently.
 
                 :param vertex: The StrokeVertex to insert in the Stroke.
-                :type vertex: 'StrokeVertex'
+                :type vertex: StrokeVertex
                 :param next: A StrokeVertexIterator pointing to the StrokeVertex
         before which vertex must be inserted.
-                :type next: 'StrokeVertexIterator'
+                :type next: StrokeVertexIterator
         """
         ...
 
@@ -1810,12 +1807,12 @@ class Stroke:
         """Removes all vertices from the Stroke."""
         ...
 
-    def remove_vertex(self, vertex: "StrokeVertex"):
+    def remove_vertex(self, vertex: StrokeVertex):
         """Removes the StrokeVertex given as argument from the Stroke. The length
         and curvilinear abscissa are updated consequently.
 
                 :param vertex: the StrokeVertex to remove from the Stroke.
-                :type vertex: 'StrokeVertex'
+                :type vertex: StrokeVertex
         """
         ...
 
@@ -1841,7 +1838,7 @@ class Stroke:
         """
         ...
 
-    def stroke_vertices_begin(self, t: float = 0.0) -> "StrokeVertexIterator":
+    def stroke_vertices_begin(self, t: float = 0.0) -> float:
         """Returns a StrokeVertexIterator pointing on the first StrokeVertex of
         the Stroke. One can specify a sampling value to re-sample the Stroke
         on the fly if needed.
@@ -1849,25 +1846,25 @@ class Stroke:
                 :param t: The resampling value with which we want our Stroke to be
         resampled. If 0 is specified, no resampling is done.
                 :type t: float
-                :rtype: 'StrokeVertexIterator'
                 :return: A StrokeVertexIterator pointing on the first StrokeVertex.
+                :rtype: StrokeVertexIterator
         """
         ...
 
-    def stroke_vertices_end(self) -> "StrokeVertexIterator":
+    def stroke_vertices_end(self) -> StrokeVertexIterator:
         """Returns a StrokeVertexIterator pointing after the last StrokeVertex
         of the Stroke.
 
-                :rtype: 'StrokeVertexIterator'
                 :return: A StrokeVertexIterator pointing after the last StrokeVertex.
+                :rtype: StrokeVertexIterator
         """
         ...
 
-    def stroke_vertices_size(self) -> int:
+    def stroke_vertices_size(self) -> StrokeVertexIterator:
         """Returns the number of StrokeVertex constituting the Stroke.
 
-        :rtype: int
         :return: The number of stroke vertices.
+        :rtype: int
         """
         ...
 
@@ -1887,18 +1884,18 @@ class StrokeAttribute:
     :type: float
     """
 
-    color: typing.Union["mathutils.Color", typing.Sequence[float]]
+    color: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGB components of the stroke color.
 
-    :type: typing.Union['mathutils.Color', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Color]
     """
 
-    thickness: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    thickness: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ Right and left components of the stroke thickness.
 The right (left) component is the thickness on the right (left) of the vertex
 when following the stroke.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     visible: bool
@@ -1915,13 +1912,13 @@ when following the stroke.
         """
         ...
 
-    def __init__(self, brother: "StrokeAttribute"):
+    def __init__(self, brother: StrokeAttribute):
         """Creates a `StrokeAttribute` object using either a default constructor,
         copy constructor, overloaded constructor, or and interpolation constructor
         to interpolate between two `StrokeAttribute` objects.
 
                 :param brother: A StrokeAttribute object to be used as a copy constructor.
-                :type brother: 'StrokeAttribute'
+                :type brother: StrokeAttribute
         """
         ...
 
@@ -1954,80 +1951,80 @@ when following the stroke.
         ...
 
     def __init__(
-        self, attribute1: "StrokeAttribute", attribute2: "StrokeAttribute", t: float
+        self, attribute1: StrokeAttribute, attribute2: StrokeAttribute, t: float
     ):
         """Creates a `StrokeAttribute` object using either a default constructor,
         copy constructor, overloaded constructor, or and interpolation constructor
         to interpolate between two `StrokeAttribute` objects.
 
                 :param attribute1: The first StrokeAttribute object.
-                :type attribute1: 'StrokeAttribute'
+                :type attribute1: StrokeAttribute
                 :param attribute2: The second StrokeAttribute object.
-                :type attribute2: 'StrokeAttribute'
+                :type attribute2: StrokeAttribute
                 :param t: The interpolation parameter (0 <= t <= 1).
                 :type t: float
         """
         ...
 
-    def get_attribute_real(self, name: str) -> float:
+    def get_attribute_real(self, name: str) -> str:
         """Returns an attribute of float type.
 
         :param name: The name of the attribute.
         :type name: str
-        :rtype: float
         :return: The attribute value.
+        :rtype: float
         """
         ...
 
-    def get_attribute_vec2(self, name: str) -> "mathutils.Vector":
+    def get_attribute_vec2(self, name: str) -> str:
         """Returns an attribute of two-dimensional vector type.
 
         :param name: The name of the attribute.
         :type name: str
-        :rtype: 'mathutils.Vector'
         :return: The attribute value.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def get_attribute_vec3(self, name: str) -> "mathutils.Vector":
+    def get_attribute_vec3(self, name: str) -> str:
         """Returns an attribute of three-dimensional vector type.
 
         :param name: The name of the attribute.
         :type name: str
-        :rtype: 'mathutils.Vector'
         :return: The attribute value.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def has_attribute_real(self, name: str) -> bool:
+    def has_attribute_real(self, name: str) -> str:
         """Checks whether the attribute name of float type is available.
 
         :param name: The name of the attribute.
         :type name: str
-        :rtype: bool
         :return: True if the attribute is available.
+        :rtype: bool
         """
         ...
 
-    def has_attribute_vec2(self, name: str) -> bool:
+    def has_attribute_vec2(self, name: str) -> str:
         """Checks whether the attribute name of two-dimensional vector type
         is available.
 
                 :param name: The name of the attribute.
                 :type name: str
-                :rtype: bool
                 :return: True if the attribute is available.
+                :rtype: bool
         """
         ...
 
-    def has_attribute_vec3(self, name: str) -> bool:
+    def has_attribute_vec3(self, name: str) -> str:
         """Checks whether the attribute name of three-dimensional vector
         type is available.
 
                 :param name: The name of the attribute.
                 :type name: str
-                :rtype: bool
                 :return: True if the attribute is available.
+                :rtype: bool
         """
         ...
 
@@ -2046,7 +2043,7 @@ when following the stroke.
     def set_attribute_vec2(
         self,
         name: str,
-        value: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
+        value: typing.Union[typing.Sequence[float], mathutils.Vector, list],
     ):
         """Adds a user-defined attribute of two-dimensional vector type. If
         there is no attribute of the given name, it is added. Otherwise,
@@ -2055,14 +2052,14 @@ when following the stroke.
                 :param name: The name of the attribute.
                 :type name: str
                 :param value: The attribute value.
-                :type value: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type value: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         """
         ...
 
     def set_attribute_vec3(
         self,
         name: str,
-        value: typing.Union["mathutils.Vector", typing.List, typing.Sequence[float]],
+        value: typing.Union[typing.Sequence[float], mathutils.Vector, list],
     ):
         """Adds a user-defined attribute of three-dimensional vector type.
         If there is no attribute of the given name, it is added.
@@ -2071,7 +2068,7 @@ when following the stroke.
                 :param name: The name of the attribute.
                 :type name: str
                 :param value: The attribute value.
-                :type value: typing.Union['mathutils.Vector', typing.List, typing.Sequence[float]]
+                :type value: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         """
         ...
 
@@ -2095,21 +2092,21 @@ class StrokeShader:
         """Default constructor."""
         ...
 
-    def shade(self, stroke: "Stroke"):
+    def shade(self, stroke: Stroke):
         """The shading method. Must be overloaded by inherited classes.
 
         :param stroke: A Stroke object.
-        :type stroke: 'Stroke'
+        :type stroke: Stroke
         """
         ...
 
 class StrokeVertex:
     """Class hierarchy: `Interface0D` > `CurvePoint` > `StrokeVertex`Class to define a stroke vertex."""
 
-    attribute: "StrokeAttribute"
+    attribute: StrokeAttribute
     """ StrokeAttribute for this StrokeVertex.
 
-    :type: 'StrokeAttribute'
+    :type: StrokeAttribute
     """
 
     curvilinear_abscissa: float
@@ -2118,10 +2115,10 @@ class StrokeVertex:
     :type: float
     """
 
-    point: typing.Union["mathutils.Vector", typing.Sequence[float]]
+    point: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ 2D point coordinates.
 
-    :type: typing.Union['mathutils.Vector', typing.Sequence[float]]
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     stroke_length: float
@@ -2145,61 +2142,63 @@ and it won't change the real stroke length).
         """
         ...
 
-    def __init__(self, brother: "StrokeVertex"):
+    def __init__(self, brother: StrokeVertex):
         """Builds a `StrokeVertex` using the default constructor,
         copy constructor, from 2 `StrokeVertex` and an interpolation parameter,
         from a CurvePoint, from a SVertex, or a `SVertex`   and a `StrokeAttribute` object.
 
                 :param brother: A StrokeVertex object.
-                :type brother: 'StrokeVertex'
+                :type brother: StrokeVertex
         """
         ...
 
     def __init__(
-        self, first_vertex: "StrokeVertex", second_vertex: "StrokeVertex", t3d: float
+        self, first_vertex: StrokeVertex, second_vertex: StrokeVertex, t3d: float
     ):
         """Builds a `StrokeVertex` using the default constructor,
         copy constructor, from 2 `StrokeVertex` and an interpolation parameter,
         from a CurvePoint, from a SVertex, or a `SVertex`   and a `StrokeAttribute` object.
 
                 :param first_vertex: The first StrokeVertex.
-                :type first_vertex: 'StrokeVertex'
+                :type first_vertex: StrokeVertex
                 :param second_vertex: The second StrokeVertex.
-                :type second_vertex: 'StrokeVertex'
+                :type second_vertex: StrokeVertex
                 :param t3d: An interpolation parameter.
                 :type t3d: float
         """
         ...
 
-    def __init__(self, point: "CurvePoint"):
+    def __init__(self, point: CurvePoint):
         """Builds a `StrokeVertex` using the default constructor,
         copy constructor, from 2 `StrokeVertex` and an interpolation parameter,
         from a CurvePoint, from a SVertex, or a `SVertex`   and a `StrokeAttribute` object.
 
                 :param point: A CurvePoint object.
-                :type point: 'CurvePoint'
+                :type point: CurvePoint
         """
         ...
 
-    def __init__(self, svertex: "SVertex"):
+    def __init__(self, svertex: typing.Union[SVertex, SVertex]):
         """Builds a `StrokeVertex` using the default constructor,
         copy constructor, from 2 `StrokeVertex` and an interpolation parameter,
         from a CurvePoint, from a SVertex, or a `SVertex`   and a `StrokeAttribute` object.
 
                 :param svertex: An SVertex object.An SVertex object.
-                :type svertex: 'SVertex'
+                :type svertex: typing.Union[SVertex, SVertex]
         """
         ...
 
-    def __init__(self, svertex: "SVertex", attribute: "StrokeAttribute"):
+    def __init__(
+        self, svertex: typing.Union[SVertex, SVertex], attribute: StrokeAttribute
+    ):
         """Builds a `StrokeVertex` using the default constructor,
         copy constructor, from 2 `StrokeVertex` and an interpolation parameter,
         from a CurvePoint, from a SVertex, or a `SVertex`   and a `StrokeAttribute` object.
 
                 :param svertex: An SVertex object.An SVertex object.
-                :type svertex: 'SVertex'
+                :type svertex: typing.Union[SVertex, SVertex]
                 :param attribute: A StrokeAttribute object.
-                :type attribute: 'StrokeAttribute'
+                :type attribute: StrokeAttribute
         """
         ...
 
@@ -2224,10 +2223,10 @@ For its counterpart (pointing to the first valid element), use it.is_begin.
     :type: bool
     """
 
-    object: "StrokeVertex"
+    object: StrokeVertex
     """ The StrokeVertex object currently pointed to by this iterator.
 
-    :type: 'StrokeVertex'
+    :type: StrokeVertex
     """
 
     t: float
@@ -2249,37 +2248,37 @@ For its counterpart (pointing to the first valid element), use it.is_begin.
         """
         ...
 
-    def __init__(self, brother: "StrokeVertexIterator"):
+    def __init__(self, brother: StrokeVertexIterator):
         """Creates a `StrokeVertexIterator` using either the
         default constructor or the copy constructor.
 
                 :param brother: A StrokeVertexIterator object.
-                :type brother: 'StrokeVertexIterator'
+                :type brother: StrokeVertexIterator
         """
         ...
 
-    def decremented(self) -> "StrokeVertexIterator":
+    def decremented(self) -> StrokeVertexIterator:
         """Returns a copy of a decremented StrokeVertexIterator.
 
-        :rtype: 'StrokeVertexIterator'
         :return: A StrokeVertexIterator pointing the previous StrokeVertex.
+        :rtype: StrokeVertexIterator
         """
         ...
 
-    def incremented(self) -> "StrokeVertexIterator":
+    def incremented(self) -> StrokeVertexIterator:
         """Returns a copy of an incremented StrokeVertexIterator.
 
-        :rtype: 'StrokeVertexIterator'
         :return: A StrokeVertexIterator pointing the next StrokeVertex.
+        :rtype: StrokeVertexIterator
         """
         ...
 
-    def reversed(self) -> "StrokeVertexIterator":
+    def reversed(self) -> StrokeVertexIterator:
         """Returns a StrokeVertexIterator that traverses stroke vertices in the
         reversed order.
 
-                :rtype: 'StrokeVertexIterator'
                 :return: A StrokeVertexIterator traversing stroke vertices backward.
+                :rtype: StrokeVertexIterator
         """
         ...
 
@@ -2291,47 +2290,47 @@ class TVertex:
     is of invisibility N and the other of invisibility N+1.
     """
 
-    back_svertex: "SVertex"
+    back_svertex: SVertex
     """ The SVertex that is further away from the viewpoint.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
-    front_svertex: "SVertex"
+    front_svertex: SVertex
     """ The SVertex that is closer to the viewpoint.
 
-    :type: 'SVertex'
+    :type: SVertex
     """
 
-    id: "Id"
+    id: Id
     """ The Id of this TVertex.
 
-    :type: 'Id'
+    :type: Id
     """
 
     def __init__(self):
         """Default constructor."""
         ...
 
-    def get_mate(self, viewedge: "ViewEdge") -> "ViewEdge":
+    def get_mate(self, viewedge: ViewEdge) -> ViewEdge:
         """Returns the mate edge of the ViewEdge given as argument. If the
         ViewEdge is frontEdgeA, frontEdgeB is returned. If the ViewEdge is
         frontEdgeB, frontEdgeA is returned. Same for back edges.
 
                 :param viewedge: A ViewEdge object.
-                :type viewedge: 'ViewEdge'
-                :rtype: 'ViewEdge'
+                :type viewedge: ViewEdge
                 :return: The mate edge of the given ViewEdge.
+                :rtype: ViewEdge
         """
         ...
 
-    def get_svertex(self, fedge: "FEdge") -> "SVertex":
+    def get_svertex(self, fedge: FEdge) -> FEdge:
         """Returns the SVertex (among the 2) belonging to the given FEdge.
 
         :param fedge: An FEdge object.
-        :type fedge: 'FEdge'
-        :rtype: 'SVertex'
+        :type fedge: FEdge
         :return: The SVertex belonging to the given FEdge.
+        :rtype: SVertex
         """
         ...
 
@@ -2463,10 +2462,10 @@ class UnaryFunction1DDouble:
     `Interface1D` and return a float value.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2476,12 +2475,12 @@ class UnaryFunction1DDouble:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using the default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2490,10 +2489,10 @@ class UnaryFunction1DEdgeNature:
     `Interface1D` and return a `Nature` object.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2503,12 +2502,12 @@ class UnaryFunction1DEdgeNature:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using the default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2517,10 +2516,10 @@ class UnaryFunction1DFloat:
     `Interface1D` and return a float value.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2530,12 +2529,12 @@ class UnaryFunction1DFloat:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using the default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2544,10 +2543,10 @@ class UnaryFunction1DUnsigned:
     `Interface1D` and return an int value.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2557,12 +2556,12 @@ class UnaryFunction1DUnsigned:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using the default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2571,10 +2570,10 @@ class UnaryFunction1DVec2f:
     `Interface1D` and return a 2D vector.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2584,12 +2583,12 @@ class UnaryFunction1DVec2f:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using the default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2598,10 +2597,10 @@ class UnaryFunction1DVec3f:
     `Interface1D` and return a 3D vector.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2611,12 +2610,12 @@ class UnaryFunction1DVec3f:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using the default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2626,10 +2625,10 @@ class UnaryFunction1DVectorViewShape:
     objects.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2639,12 +2638,12 @@ class UnaryFunction1DVectorViewShape:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using the default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2653,10 +2652,10 @@ class UnaryFunction1DVoid:
     `Interface1D`.
     """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
@@ -2666,12 +2665,12 @@ class UnaryFunction1DVoid:
         """
         ...
 
-    def __init__(self, integration_type: "IntegrationType"):
+    def __init__(self, integration_type: IntegrationType):
         """Builds a unary 1D function using either a default constructor
         or the integration method given as an argument.
 
                 :param integration_type: An integration method.
-                :type integration_type: 'IntegrationType'
+                :type integration_type: IntegrationType
         """
         ...
 
@@ -2694,14 +2693,14 @@ class UnaryPredicate0D:
         """Default constructor."""
         ...
 
-    def __call__(self, it: "Interface0DIterator") -> bool:
+    def __call__(self, it: Interface0DIterator) -> Interface0DIterator:
         """Must be overload by inherited classes.
 
                 :param it: The Interface0DIterator pointing onto the Interface0D at
         which we wish to evaluate the predicate.
-                :type it: 'Interface0DIterator'
-                :rtype: bool
+                :type it: Interface0DIterator
                 :return: True if the condition is satisfied, false otherwise.
+                :rtype: bool
         """
         ...
 
@@ -2724,13 +2723,13 @@ class UnaryPredicate1D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter: "Interface1D") -> bool:
+    def __call__(self, inter: Interface1D) -> Interface1D:
         """Must be overload by inherited classes.
 
         :param inter: The Interface1D on which we wish to evaluate the predicate.
-        :type inter: 'Interface1D'
-        :rtype: bool
+        :type inter: Interface1D
         :return: True if the condition is satisfied, false otherwise.
+        :rtype: bool
         """
         ...
 
@@ -2746,22 +2745,22 @@ class ViewEdge:
     :type: int
     """
 
-    first_fedge: "FEdge"
+    first_fedge: FEdge
     """ The first FEdge that constitutes this ViewEdge.
 
-    :type: 'FEdge'
+    :type: FEdge
     """
 
-    first_viewvertex: "ViewVertex"
+    first_viewvertex: ViewVertex
     """ The first ViewVertex.
 
-    :type: 'ViewVertex'
+    :type: ViewVertex
     """
 
-    id: "Id"
+    id: Id
     """ The Id of this ViewEdge.
 
-    :type: 'Id'
+    :type: Id
     """
 
     is_closed: bool
@@ -2770,29 +2769,29 @@ class ViewEdge:
     :type: bool
     """
 
-    last_fedge: "FEdge"
+    last_fedge: FEdge
     """ The last FEdge that constitutes this ViewEdge.
 
-    :type: 'FEdge'
+    :type: FEdge
     """
 
-    last_viewvertex: "ViewVertex"
+    last_viewvertex: ViewVertex
     """ The second ViewVertex.
 
-    :type: 'ViewVertex'
+    :type: ViewVertex
     """
 
-    nature: "Nature"
+    nature: Nature
     """ The nature of this ViewEdge.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
-    occludee: "ViewShape"
+    occludee: ViewShape
     """ The shape that is occluded by the ViewShape to which this ViewEdge
 belongs to. If no object is occluded, this property is set to None.
 
-    :type: 'ViewShape'
+    :type: ViewShape
     """
 
     qi: int
@@ -2801,21 +2800,21 @@ belongs to. If no object is occluded, this property is set to None.
     :type: int
     """
 
-    viewshape: "ViewShape"
+    viewshape: ViewShape
     """ The ViewShape to which this ViewEdge belongs to.
 
-    :type: 'ViewShape'
+    :type: ViewShape
     """
 
     def __init__(self):
         """Builds a `ViewEdge` using the default constructor or the copy constructor."""
         ...
 
-    def __init__(self, brother: "ViewEdge"):
+    def __init__(self, brother: ViewEdge):
         """Builds a `ViewEdge` using the default constructor or the copy constructor.
 
         :param brother: A ViewEdge object.
-        :type brother: 'ViewEdge'
+        :type brother: ViewEdge
         """
         ...
 
@@ -2830,22 +2829,22 @@ class ViewEdgeIterator:
     on a given ViewEdge.
     """
 
-    begin: "ViewEdge"
+    begin: ViewEdge
     """ The first ViewEdge used for the iteration.
 
-    :type: 'ViewEdge'
+    :type: ViewEdge
     """
 
-    current_edge: "ViewEdge"
+    current_edge: ViewEdge
     """ The ViewEdge object currently pointed by this iterator.
 
-    :type: 'ViewEdge'
+    :type: ViewEdge
     """
 
-    object: "ViewEdge"
+    object: ViewEdge
     """ The ViewEdge object currently pointed by this iterator.
 
-    :type: 'ViewEdge'
+    :type: ViewEdge
     """
 
     orientation: bool
@@ -2858,14 +2857,11 @@ of the "begin" ViewEdge.
     :type: bool
     """
 
-    def __init__(
-        self, begin: typing.Optional["ViewEdge"] = None, orientation: bool = True
-    ):
+    def __init__(self, begin=None, orientation: bool = True):
         """Builds a ViewEdgeIterator from a starting ViewEdge and its
         orientation or the copy constructor.
 
                 :param begin: The ViewEdge from where to start the iteration.
-                :type begin: typing.Optional['ViewEdge']
                 :param orientation: If true, we'll look for the next ViewEdge among
         the ViewEdges that surround the ending ViewVertex of begin. If
         false, we'll search over the ViewEdges surrounding the ending
@@ -2874,12 +2870,12 @@ of the "begin" ViewEdge.
         """
         ...
 
-    def __init__(self, brother: "ViewEdgeIterator"):
+    def __init__(self, brother: ViewEdgeIterator):
         """Builds a ViewEdgeIterator from a starting ViewEdge and its
         orientation or the copy constructor.
 
                 :param brother: A ViewEdgeIterator object.
-                :type brother: 'ViewEdgeIterator'
+                :type brother: ViewEdgeIterator
         """
         ...
 
@@ -2890,37 +2886,37 @@ of the "begin" ViewEdge.
 class ViewMap:
     """Class defining the ViewMap."""
 
-    scene_bbox: "BBox"
+    scene_bbox: BBox
     """ The 3D bounding box of the scene.
 
-    :type: 'BBox'
+    :type: BBox
     """
 
     def __init__(self):
         """Default constructor."""
         ...
 
-    def get_closest_fedge(self, x: float, y: float) -> "FEdge":
+    def get_closest_fedge(self, x: float, y: float) -> float:
         """Gets the FEdge nearest to the 2D point specified as arguments.
 
         :param x: X coordinate of a 2D point.
         :type x: float
         :param y: Y coordinate of a 2D point.
         :type y: float
-        :rtype: 'FEdge'
         :return: The FEdge nearest to the specified 2D point.
+        :rtype: FEdge
         """
         ...
 
-    def get_closest_viewedge(self, x: float, y: float) -> "ViewEdge":
+    def get_closest_viewedge(self, x: float, y: float) -> float:
         """Gets the ViewEdge nearest to the 2D point specified as arguments.
 
         :param x: X coordinate of a 2D point.
         :type x: float
         :param y: Y coordinate of a 2D point.
         :type y: float
-        :rtype: 'ViewEdge'
         :return: The ViewEdge nearest to the specified 2D point.
+        :rtype: ViewEdge
         """
         ...
 
@@ -2929,16 +2925,16 @@ class ViewShape:
     and `ViewEdge`) that are issued from the same input shape.
     """
 
-    edges: typing.List["ViewEdge"]
+    edges: typing.List[ViewEdge]
     """ The list of ViewEdge objects contained in this ViewShape.
 
-    :type: typing.List['ViewEdge']
+    :type: typing.List[ViewEdge]
     """
 
-    id: "Id"
+    id: Id
     """ The Id of this ViewShape.
 
-    :type: 'Id'
+    :type: Id
     """
 
     library_path: typing.Union[str, typing.Any]
@@ -2953,16 +2949,16 @@ class ViewShape:
     :type: str
     """
 
-    sshape: "SShape"
+    sshape: SShape
     """ The SShape on top of which this ViewShape is built.
 
-    :type: 'SShape'
+    :type: SShape
     """
 
-    vertices: typing.List["ViewVertex"]
+    vertices: typing.List[ViewVertex]
     """ The list of ViewVertex objects contained in this ViewShape.
 
-    :type: typing.List['ViewVertex']
+    :type: typing.List[ViewVertex]
     """
 
     def __init__(self):
@@ -2972,37 +2968,37 @@ class ViewShape:
         """
         ...
 
-    def __init__(self, brother: "ViewShape"):
+    def __init__(self, brother: ViewShape):
         """Builds a `ViewShape` using the default constructor,
         copy constructor, or from a `SShape`.
 
                 :param brother: A ViewShape object.
-                :type brother: 'ViewShape'
+                :type brother: ViewShape
         """
         ...
 
-    def __init__(self, sshape: "SShape"):
+    def __init__(self, sshape: SShape):
         """Builds a `ViewShape` using the default constructor,
         copy constructor, or from a `SShape`.
 
                 :param sshape: An SShape object.
-                :type sshape: 'SShape'
+                :type sshape: SShape
         """
         ...
 
-    def add_edge(self, edge: "ViewEdge"):
+    def add_edge(self, edge: ViewEdge):
         """Adds a ViewEdge to the list of ViewEdge objects.
 
         :param edge: A ViewEdge object.
-        :type edge: 'ViewEdge'
+        :type edge: ViewEdge
         """
         ...
 
-    def add_vertex(self, vertex: "ViewVertex"):
+    def add_vertex(self, vertex: ViewVertex):
         """Adds a ViewVertex to the list of the ViewVertex objects.
 
         :param vertex: A ViewVertex object.
-        :type vertex: 'ViewVertex'
+        :type vertex: ViewVertex
         """
         ...
 
@@ -3018,41 +3014,41 @@ class ViewVertex:
     `TVertex` class and the `NonTVertex` class.
     """
 
-    nature: "Nature"
+    nature: Nature
     """ The nature of this ViewVertex.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
-    def edges_begin(self) -> "orientedViewEdgeIterator":
+    def edges_begin(self) -> Nature:
         """Returns an iterator over the ViewEdges that goes to or comes from
         this ViewVertex pointing to the first ViewEdge of the list. The
         orientedViewEdgeIterator allows to iterate in CCW order over these
         ViewEdges and to get the orientation for each ViewEdge
         (incoming/outgoing).
 
-                :rtype: 'orientedViewEdgeIterator'
                 :return: An orientedViewEdgeIterator pointing to the first ViewEdge.
+                :rtype: orientedViewEdgeIterator
         """
         ...
 
-    def edges_end(self) -> "orientedViewEdgeIterator":
+    def edges_end(self) -> orientedViewEdgeIterator:
         """Returns an orientedViewEdgeIterator over the ViewEdges around this
         ViewVertex, pointing after the last ViewEdge.
 
-                :rtype: 'orientedViewEdgeIterator'
                 :return: An orientedViewEdgeIterator pointing after the last ViewEdge.
+                :rtype: orientedViewEdgeIterator
         """
         ...
 
-    def edges_iterator(self, edge: "ViewEdge") -> "orientedViewEdgeIterator":
+    def edges_iterator(self, edge: ViewEdge) -> ViewEdge:
         """Returns an orientedViewEdgeIterator pointing to the ViewEdge given
         as argument.
 
                 :param edge: A ViewEdge object.
-                :type edge: 'ViewEdge'
-                :rtype: 'orientedViewEdgeIterator'
+                :type edge: ViewEdge
                 :return: An orientedViewEdgeIterator pointing to the given ViewEdge.
+                :rtype: orientedViewEdgeIterator
         """
         ...
 
@@ -3063,13 +3059,10 @@ class orientedViewEdgeIterator:
     obtained from a ViewVertex by calling edges_begin() or edges_end().
     """
 
-    object: typing.Union["ViewEdge", bool]
+    object: typing.Any
     """ The oriented ViewEdge (i.e., a tuple of the pointed ViewEdge and a boolean
 value) currently pointed to by this iterator. If the boolean value is true,
-the ViewEdge is incoming.
-
-    :type: typing.Union['ViewEdge', bool]
-    """
+the ViewEdge is incoming."""
 
     def __init__(self):
         """Creates an `orientedViewEdgeIterator` using either the
@@ -3078,11 +3071,11 @@ the ViewEdge is incoming.
         """
         ...
 
-    def __init__(self, iBrother: "orientedViewEdgeIterator"):
+    def __init__(self, iBrother: orientedViewEdgeIterator):
         """Creates an `orientedViewEdgeIterator` using either the
         default constructor or the copy constructor.
 
                 :param iBrother: An orientedViewEdgeIterator object.
-                :type iBrother: 'orientedViewEdgeIterator'
+                :type iBrother: orientedViewEdgeIterator
         """
         ...