fake-bpy-module 20240210__py3-none-any.whl → 20240326__py3-none-any.whl

freestyle/types/__init__.pyi

@@ -1,35 +1,61 @@
-import sys
 import typing
 import mathutils
 
 GenericType = typing.TypeVar("GenericType")
 
 class AdjacencyIterator:
-    """Class hierarchy: `Iterator` > `AdjacencyIterator` Class for representing adjacency iterators used in the chaining process. An AdjacencyIterator is created in the increment() and decrement() methods of a `ChainingIterator` and passed to the traverse() method of the ChainingIterator."""
+    """Class hierarchy: `Iterator` > `AdjacencyIterator`Class for representing adjacency iterators used in the chaining
+    process. An AdjacencyIterator is created in the increment() and
+    decrement() methods of a `ChainingIterator` and passed to the
+    traverse() method of the ChainingIterator.
+    """
 
     is_incoming: bool
-    """ True if the current ViewEdge is coming towards the iteration vertex, and False otherwise.
+    """ True if the current ViewEdge is coming towards the iteration vertex, and
+False otherwise.
 
     :type: bool
     """
 
-    object: "ViewEdge"
+    object: ViewEdge
     """ The ViewEdge object currently pointed to by this iterator.
 
-    :type: 'ViewEdge'
+    :type: ViewEdge
     """
 
     def __init__(self):
-        """__init__(brother) __init__(vertex, restrict_to_selection=True, restrict_to_unvisited=True) Builds an `AdjacencyIterator` using the default constructor, copy constructor or the overloaded constructor.
+        """Builds an `AdjacencyIterator` using the default constructor,
+        copy constructor or the overloaded constructor.
+
+        """
+        ...
+
+    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
+        """
+        ...
+
+    def __init__(
+        self,
+        vertex: ViewVertex,
+        restrict_to_selection: bool = True,
+        restrict_to_unvisited: bool = True,
+    ):
+        """Builds an `AdjacencyIterator` using the default constructor,
+        copy constructor or the overloaded constructor.
 
-        :param brother: An AdjacencyIterator object.
-        :type brother: 'AdjacencyIterator'
-        :param vertex: The vertex which is the next crossing.
-        :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
-        :param restrict_to_unvisited: Indicates whether a ViewEdge that has already been chained must be ignored ot not.
-        :type restrict_to_unvisited: bool
+                :param vertex: The vertex which is the next crossing.
+                :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
+                :param restrict_to_unvisited: Indicates whether a ViewEdge that has
+        already been chained must be ignored ot not.
+                :type restrict_to_unvisited: bool
         """
         ...
 
@@ -41,7 +67,12 @@ class BBox:
         ...
 
 class BinaryPredicate0D:
-    """Base class for binary predicates working on `Interface0D` objects. A BinaryPredicate0D is typically an ordering relation between two Interface0D objects. The predicate evaluates a relation between the two Interface0D instances and returns a boolean value (true or false). It is used by invoking the __call__() method."""
+    """Base class for binary predicates working on `Interface0D`
+    objects. A BinaryPredicate0D is typically an ordering relation
+    between two Interface0D objects. The predicate evaluates a relation
+    between the two Interface0D instances and returns a boolean value (true
+    or false). It is used by invoking the __call__() method.
+    """
 
     name: str
     """ The name of the binary 0D predicate.
@@ -53,20 +84,26 @@ class BinaryPredicate0D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter1: "Interface0D", inter2: "Interface0D") -> bool:
-        """Must be overload by inherited classes. It evaluates a relation between two Interface0D objects.
+    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'
-        :param inter2: The second Interface0D object.
-        :type inter2: 'Interface0D'
-        :rtype: bool
-        :return: True or false.
+                :param inter1: The first Interface0D object.
+                :type inter1: Interface0D
+                :param inter2: The second Interface0D object.
+                :type inter2: Interface0D
+                :return: True or false.
+                :rtype: bool
         """
         ...
 
 class BinaryPredicate1D:
-    """Base class for binary predicates working on `Interface1D` objects. A BinaryPredicate1D is typically an ordering relation between two Interface1D objects. The predicate evaluates a relation between the two Interface1D instances and returns a boolean value (true or false). It is used by invoking the __call__() method."""
+    """Base class for binary predicates working on `Interface1D`
+    objects. A BinaryPredicate1D is typically an ordering relation
+    between two Interface1D objects. The predicate evaluates a relation
+    between the two Interface1D instances and returns a boolean value (true
+    or false). It is used by invoking the __call__() method.
+    """
 
     name: str
     """ The name of the binary 1D predicate.
@@ -78,53 +115,82 @@ class BinaryPredicate1D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter1: "Interface1D", inter2: "Interface1D") -> bool:
-        """Must be overload by inherited classes. It evaluates a relation between two Interface1D objects.
+    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'
-        :param inter2: The second Interface1D object.
-        :type inter2: 'Interface1D'
-        :rtype: bool
-        :return: True or false.
+                :param inter1: The first Interface1D object.
+                :type inter1: Interface1D
+                :param inter2: The second Interface1D object.
+                :type inter2: Interface1D
+                :return: True or false.
+                :rtype: bool
         """
         ...
 
 class Chain:
-    """Class hierarchy: `Interface1D` > `Curve` > `Chain` Class to represent a 1D elements issued from the chaining process. A Chain is the last step before the `Stroke` and is used in the Splitting and Creation processes."""
+    """Class hierarchy: `Interface1D` > `Curve` > `Chain`Class to represent a 1D elements issued from the chaining process. A
+    Chain is the last step before the `Stroke` and is used in the
+    Splitting and Creation processes.
+    """
 
     def __init__(self):
-        """__init__(brother) __init__(id) Builds a `Chain` using the default constructor, copy constructor or from an `Id`.
+        """Builds a `Chain` using the default constructor,
+        copy constructor or from an `Id`.
+
+        """
+        ...
 
-        :param brother: A Chain object.
-        :type brother: 'Chain'
-        :param id: An Id object.
-        :type id: 'Id'
+    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
+        """
+        ...
+
+    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
         """
         ...
 
-    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'
-        :param orientation: The orientation with which the ViewEdge must be processed.
-        :type orientation: bool
+                :param viewedge: The ViewEdge that must be added.
+                :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'
-        :param orientation: The orientation with which the ViewEdge must be processed.
-        :type orientation: bool
+                :param viewedge: The ViewEdge that must be added.
+                :type viewedge: ViewEdge
+                :param orientation: The orientation with which the ViewEdge must be
+        processed.
+                :type orientation: bool
         """
         ...
 
 class ChainingIterator:
-    """Class hierarchy: `Iterator` > `ViewEdgeIterator` > `ChainingIterator` Base class for chaining iterators. This class is designed to be overloaded in order to describe chaining rules. It makes the description of chaining rules easier. The two main methods that need to overloaded are traverse() and init(). traverse() tells which `ViewEdge` to follow, among the adjacent ones. If you specify restriction rules (such as "Chain only ViewEdges of the selection"), they will be included in the adjacency iterator (i.e, the adjacent iterator will only stop on "valid" edges)."""
+    """Class hierarchy: `Iterator` > `ViewEdgeIterator` > `ChainingIterator`Base class for chaining iterators. This class is designed to be
+    overloaded in order to describe chaining rules. It makes the
+    description of chaining rules easier. The two main methods that need
+    to overloaded are traverse() and init(). traverse() tells which
+    `ViewEdge` to follow, among the adjacent ones. If you specify
+    restriction rules (such as "Chain only ViewEdges of the selection"),
+    they will be included in the adjacency iterator (i.e, the adjacent
+    iterator will only stop on "valid" edges).
+    """
 
     is_incrementing: bool
     """ True if the current iteration is an incrementation.
@@ -132,56 +198,76 @@ 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,
     ):
-        """__init__(brother) Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation or by using the copy constructor.
-
-        :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
-        :param restrict_to_unvisited: Indicates whether a ViewEdge that has 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
-        :param brother:
-        :type brother: 'ChainingIterator'
+        """Builds a Chaining Iterator from the first ViewEdge used for
+        iteration and its orientation or by using the copy constructor.
+
+                :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
+                :param restrict_to_unvisited: Indicates whether a ViewEdge that has
+        already been chained must be ignored ot not.
+                :type restrict_to_unvisited: bool
+                :param begin: The ViewEdge from which to start the chain.
+                :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):
+        """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
         """
         ...
 
     def init(self):
-        """Initializes the iterator context. This method is called each time a new chain is started. It can be used to reset some history information that you might want to keep."""
+        """Initializes the iterator context. This method is called each
+        time a new chain is started. It can be used to reset some
+        history information that you might want to keep.
+
+        """
         ...
 
-    def traverse(self, it: "AdjacencyIterator") -> "ViewEdge":
-        """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.
+    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.
 
-        :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'
-        :return: Returns the next ViewEdge to follow, or None if chaining ends.
+                :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
+                :return: Returns the next ViewEdge to follow, or None if chaining ends.
         """
         ...
 
 class Curve:
-    """Class hierarchy: `Interface1D` > `Curve` Base class for curves made of CurvePoints. `SVertex` is the type of the initial curve vertices. A `Chain` is a specialization of a Curve."""
+    """Class hierarchy: `Interface1D` > `Curve`Base class for curves made of CurvePoints. `SVertex` is the
+    type of the initial curve vertices. A `Chain` is a
+    specialization of a Curve.
+    """
 
     is_empty: bool
     """ True if the Curve doesn't have any Vertex yet.
@@ -196,50 +282,74 @@ class Curve:
     """
 
     def __init__(self):
-        """__init__(brother) __init__(id) Builds a `FrsCurve` using a default constructor, copy constructor or from an `Id`.
+        """Builds a `FrsCurve` using a default constructor,
+        copy constructor or from an `Id`.
+
+        """
+        ...
+
+    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
+        """
+        ...
 
-        :param brother: A Curve object.
-        :type brother: 'Curve'
-        :param id: An Id object.
-        :type 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
         """
         ...
 
-    def push_vertex_back(self, vertex: typing.Union["SVertex", "CurvePoint"]):
+    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['SVertex', 'CurvePoint']
+        :type vertex: typing.Union[SVertex, CurvePoint]
         """
         ...
 
-    def push_vertex_front(self, vertex: typing.Union["SVertex", "CurvePoint"]):
+    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['SVertex', 'CurvePoint']
+        :type vertex: typing.Union[SVertex, CurvePoint]
         """
         ...
 
 class CurvePoint:
-    """Class hierarchy: `Interface0D` > `CurvePoint` Class to represent a point of a curve. A CurvePoint can be any point of a 1D curve (it doesn't have to be a vertex of the curve). Any `Interface1D` is built upon ViewEdges, themselves built upon FEdges. Therefore, a curve is basically a polyline made of a list of `SVertex` objects. Thus, a CurvePoint is built by linearly interpolating two `SVertex` instances. CurvePoint can be used as virtual points while querying 0D information along a curve at a given resolution."""
+    """Class hierarchy: `Interface0D` > `CurvePoint`Class to represent a point of a curve. A CurvePoint can be any point
+    of a 1D curve (it doesn't have to be a vertex of the curve). Any
+    `Interface1D` is built upon ViewEdges, themselves built upon
+    FEdges. Therefore, a curve is basically a polyline made of a list of
+    `SVertex` objects. Thus, a CurvePoint is built by linearly
+    interpolating two `SVertex` instances. CurvePoint can be used
+    as virtual points while querying 0D information along a curve at a
+    given resolution.
+    """
 
-    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).
+    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
@@ -249,30 +359,67 @@ class CurvePoint:
     """
 
     def __init__(self):
-        """__init__(brother) __init__(first_vertex, second_vertex, t2d) __init__(first_point, second_point, t2d) 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
+        """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
+
+        """
+        ...
+
+    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
+        """
+        ...
+
+    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
+                :param second_vertex: The second 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):
+        """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'
-        :param first_vertex: The first SVertex.
-        :type first_vertex: 'SVertex'
-        :param second_vertex: The second SVertex.
-        :type second_vertex: 'SVertex'
-        :param first_point: The first CurvePoint.
-        :type first_point: 'CurvePoint'
-        :param second_point: The second 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
+                :param first_point: The first CurvePoint.
+                :type first_point: CurvePoint
+                :param second_point: The second 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
         """
         ...
 
 class CurvePointIterator:
-    """Class hierarchy: `Iterator` > `CurvePointIterator` Class representing an iterator on a curve. Allows an iterating outside initial vertices. A CurvePoint is instantiated and returned through the .object attribute."""
+    """Class hierarchy: `Iterator` > `CurvePointIterator`Class representing an iterator on a curve. Allows an iterating
+    outside initial vertices. A CurvePoint is instantiated and returned
+    through the .object attribute.
+    """
 
-    object: "CurvePoint"
+    object: CurvePoint
     """ The CurvePoint object currently pointed by this iterator.
 
-    :type: 'CurvePoint'
+    :type: CurvePoint
     """
 
     t: float
@@ -288,28 +435,54 @@ class CurvePointIterator:
     """
 
     def __init__(self):
-        """__init__(brother) __init__(step=0.0) Builds a CurvePointIterator object using either the default constructor, copy constructor, or the overloaded constructor.
+        """Builds a CurvePointIterator object using either the default constructor,
+        copy constructor, or the overloaded constructor.
 
-        :param brother: A CurvePointIterator object.
-        :type brother: 'CurvePointIterator'
-        :param step: A resampling resolution with which the curve is resampled. If zero, no resampling is done (i.e., the iterator iterates over initial vertices).
-        :type step: float
         """
         ...
 
-class FEdge:
-    """Class hierarchy: `Interface1D` > `FEdge` Base Class for feature edges. This FEdge can represent a silhouette, a crease, a ridge/valley, a border or a suggestive contour. For silhouettes, the FEdge is oriented so that the visible face lies on the left of the edge. For borders, the FEdge is oriented so that the face lies on the left of the edge. An FEdge can represent an initial edge of the mesh or runs across a face of the initial mesh depending on the smoothness or sharpness of the mesh. This class is specialized into a smooth and a sharp version since their properties slightly vary from one to the other."""
+    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
+        """
+        ...
+
+    def __init__(self, step: float = 0.0):
+        """Builds a CurvePointIterator object using either the default constructor,
+        copy constructor, or the overloaded constructor.
+
+                :param step: A resampling resolution with which the curve is resampled.
+        If zero, no resampling is done (i.e., the iterator iterates over
+        initial vertices).
+                :type step: float
+        """
+        ...
 
-    first_svertex: "SVertex"
+class FEdge:
+    """Class hierarchy: `Interface1D` > `FEdge`Base Class for feature edges. This FEdge can represent a silhouette,
+    a crease, a ridge/valley, a border or a suggestive contour. For
+    silhouettes, the FEdge is oriented so that the visible face lies on
+    the left of the edge. For borders, the FEdge is oriented so that the
+    face lies on the left of the edge. An FEdge can represent an initial
+    edge of the mesh or runs across a face of the initial mesh depending
+    on the smoothness or sharpness of the mesh. This class is specialized
+    into a smooth and a sharp version since their properties slightly vary
+    from one to the other.
+    """
+
+    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
@@ -318,50 +491,62 @@ class FEdge:
     :type: bool
     """
 
-    nature: "Nature"
+    nature: Nature
     """ The nature of this FEdge.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
-    next_fedge: "FEdge"
-    """ The FEdge following this one in the ViewEdge. The value is None if this FEdge is the last of the ViewEdge.
+    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"
-    """ The FEdge preceding this one in the ViewEdge. The value is None if this FEdge is the first one of the ViewEdge.
+    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):
-        """FEdge(brother) Builds an `FEdge` using the default constructor, copy constructor, or between two `SVertex` objects.
+        """Builds an `FEdge` using the default constructor,
+        copy constructor, or between two `SVertex` objects.
+
+        """
+        ...
+
+    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'
-        :param first_vertex: The first SVertex.
-        :type first_vertex: 'SVertex'
-        :param second_vertex: The second SVertex.
-        :type second_vertex: 'SVertex'
+                :param brother: An FEdge object.
+                :type brother: FEdge
         """
         ...
 
 class FEdgeSharp:
-    """Class hierarchy: `Interface1D` > `FEdge` > `FEdgeSharp` Class defining a sharp FEdge. A Sharp FEdge corresponds to an initial edge of the input mesh. It can be a silhouette, a crease or a border. If it is a crease edge, then it is bordered by two faces of the mesh. Face a lies on its right whereas Face b lies on its left. If it is a border edge, then it doesn't have any face on its right, and thus Face a is None."""
+    """Class hierarchy: `Interface1D` > `FEdge` > `FEdgeSharp`Class defining a sharp FEdge. A Sharp FEdge corresponds to an initial
+    edge of the input mesh. It can be a silhouette, a crease or a border.
+    If it is a crease edge, then it is bordered by two faces of the mesh.
+    Face a lies on its right whereas Face b lies on its left. If it is a
+    border edge, then it doesn't have any face on its right, and thus Face
+    a is None.
+    """
 
     face_mark_left: bool
     """ The face mark of the face lying on the left of the FEdge.
@@ -370,7 +555,9 @@ class FEdgeSharp:
     """
 
     face_mark_right: bool
-    """ The face mark of the face lying on the right of the FEdge. If this FEdge is a border, it has no face on the right and thus this property is set to false.
+    """ The face mark of the face lying on the right of the FEdge. If this FEdge
+is a border, it has no face on the right and thus this property is set to
+false.
 
     :type: bool
     """
@@ -382,49 +569,71 @@ class FEdgeSharp:
     """
 
     material_index_right: int
-    """ The index of 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.
+    """ The index of 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: 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"
-    """ 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.
+    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[typing.Sequence[float], "mathutils.Vector"]
+    normal_left: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal to the face lying on the left of the FEdge.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    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.
+    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[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     def __init__(self):
-        """__init__(brother) __init__(first_vertex, second_vertex) Builds an `FEdgeSharp` using the default constructor, copy constructor, or between two `SVertex` objects.
+        """Builds an `FEdgeSharp` using the default constructor,
+        copy constructor, or between two `SVertex` objects.
+
+        """
+        ...
+
+    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'
-        :param first_vertex: The first SVertex object.
-        :type first_vertex: 'SVertex'
-        :param second_vertex: The second SVertex object.
-        :type second_vertex: 'SVertex'
+                :param brother: An FEdgeSharp object.
+                :type brother: FEdgeSharp
+        """
+        ...
+
+    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
+                :param second_vertex: The second SVertex object.
+                :type second_vertex: SVertex
         """
         ...
 
 class FEdgeSmooth:
-    """Class hierarchy: `Interface1D` > `FEdge` > `FEdgeSmooth` Class defining a smooth edge. This kind of edge typically runs across a face of the input mesh. It can be a silhouette, a ridge or valley, a suggestive contour."""
+    """Class hierarchy: `Interface1D` > `FEdge` > `FEdgeSmooth`Class defining a smooth edge. This kind of edge typically runs across
+    a face of the input mesh. It can be a silhouette, a ridge or valley,
+    a suggestive contour.
+    """
 
     face_mark: bool
     """ The face mark of the face that this FEdge is running across.
@@ -432,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
@@ -444,21 +653,36 @@ class FEdgeSmooth:
     :type: int
     """
 
-    normal: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    normal: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal of the face that this FEdge is running across.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     def __init__(self):
-        """__init__(brother) __init__(first_vertex, second_vertex) Builds an `FEdgeSmooth` using the default constructor, copy constructor, or between two `SVertex`.
+        """Builds an `FEdgeSmooth` using the default constructor,
+        copy constructor, or between two `SVertex`.
+
+        """
+        ...
+
+    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
+        """
+        ...
+
+    def __init__(self, first_vertex: SVertex, second_vertex: SVertex):
+        """Builds an `FEdgeSmooth` using the default constructor,
+        copy constructor, or between two `SVertex`.
 
-        :param brother: An FEdgeSmooth object.
-        :type brother: 'FEdgeSmooth'
-        :param first_vertex: The first SVertex object.
-        :type first_vertex: 'SVertex'
-        :param second_vertex: The second SVertex object.
-        :type second_vertex: 'SVertex'
+                :param first_vertex: The first SVertex object.
+                :type first_vertex: SVertex
+                :param second_vertex: The second SVertex object.
+                :type second_vertex: SVertex
         """
         ...
 
@@ -477,11 +701,16 @@ class Id:
     :type: int
     """
 
-    def __init__(self, brother: "Id"):
-        """__init__(first=0, second=0) Build the Id from two numbers or another `Id` using the copy constructor.
+    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'
+        """
+        ...
+
+    def __init__(self, first: int = 0, second: int = 0):
+        """Build the Id from two numbers or another `Id` using the copy constructor.
+
         :param first:
         :type first: int
         :param second: The second number.
@@ -490,17 +719,20 @@ class Id:
         ...
 
 class IntegrationType:
-    """Class hierarchy: int > `IntegrationType` Different integration methods that can be invoked to integrate into a single value the set of values obtained from each 0D element of an 1D element: * IntegrationType.MEAN: The value computed for the 1D element is the mean of the values obtained for the 0D elements. * IntegrationType.MIN: The value computed for the 1D element is the minimum of the values obtained for the 0D elements. * IntegrationType.MAX: The value computed for the 1D element is the maximum of the values obtained for the 0D elements. * IntegrationType.FIRST: The value computed for the 1D element is the first of the values obtained for the 0D elements. * IntegrationType.LAST: The value computed for the 1D element is the last of the values obtained for the 0D elements."""
+    """Class hierarchy: int > `IntegrationType`Different integration methods that can be invoked to integrate into a
+    single value the set of values obtained from each 0D element of an 1D
+    element:
+    """
 
     ...
 
 class Interface0D:
     """Base class for any 0D element."""
 
-    id: "Id"
+    id: Id
     """ The Id of this 0D element.
 
-    :type: 'Id'
+    :type: Id
     """
 
     name: str
@@ -509,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[typing.Sequence[float], "mathutils.Vector"]
+    point_2d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The 2D point of this 0D element.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    point_3d: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    point_3d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The 3D point of this 0D element.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     projected_x: float
@@ -549,29 +781,36 @@ class Interface0D:
         """Default constructor."""
         ...
 
-    def get_fedge(self, inter: "Interface0D") -> "FEdge":
-        """Returns the FEdge that lies between this 0D element and the 0D element given as the argument.
+    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'
-        :return: The FEdge lying between the two 0D elements.
+                :param inter: A 0D element.
+                :type inter: Interface0D
+                :return: The FEdge lying between the two 0D elements.
+                :rtype: FEdge
         """
         ...
 
 class Interface0DIterator:
-    """Class hierarchy: `Iterator` > `Interface0DIterator` Class defining an iterator over Interface0D elements. An instance of this iterator is always obtained from a 1D element."""
+    """Class hierarchy: `Iterator` > `Interface0DIterator`Class defining an iterator over Interface0D elements. An instance of
+    this iterator is always obtained from a 1D element.
+    """
 
     at_last: bool
-    """ True if the iterator points to the last valid element. For its counterpart (pointing to the first valid element), use it.is_begin.
+    """ True if the iterator points to the last valid element.
+For its counterpart (pointing to the first valid element), use it.is_begin.
 
     :type: bool
     """
 
-    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.
+    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
@@ -586,23 +825,31 @@ class Interface0DIterator:
     :type: float
     """
 
-    def __init__(self, brother: "Interface0DIterator"):
-        """__init__(it) Construct a nested Interface0DIterator using either the copy constructor or the constructor that takes an he argument of a Function0D.
+    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
+        """
+        ...
+
+    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 brother: An Interface0DIterator object.
-        :type brother: 'Interface0DIterator'
-        :param it: An iterator object to be nested.
-        :type it: typing.Union['SVertexIterator', 'CurvePointIterator', typing.Any, 'StrokeVertexIterator']
+                :param it: An iterator object to be nested.
+                :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
@@ -617,10 +864,10 @@ class Interface1D:
     :type: str
     """
 
-    nature: "Nature"
+    nature: Nature
     """ The nature of this Interface1D.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
     time_stamp: int
@@ -633,39 +880,49 @@ class Interface1D:
         """Default constructor."""
         ...
 
-    def points_begin(self, t: float = 0.0) -> "Interface0DIterator":
-        """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. Indeed, for each iteration, a virtual point is created.
+    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.
+        Indeed, for each iteration, a virtual point is created.
 
-        :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.
+                :param t: A sampling with which we want to iterate over points of
+        this 1D element.
+                :type t: float
+                :return: An Interface0DIterator pointing to the first point.
+                :rtype: Interface0DIterator
         """
         ...
 
-    def points_end(self, t: float = 0.0) -> "Interface0DIterator":
-        """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, for each iteration, a virtual point is created.
+    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,
+        for each iteration, a virtual point is created.
 
-        :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.
+                :param t: A sampling with which we want to iterate over points of
+        this 1D element.
+                :type t: float
+                :return: An Interface0DIterator pointing after the last point.
+                :rtype: Interface0DIterator
         """
         ...
 
-    def vertices_begin(self) -> "Interface0DIterator":
-        """Returns an iterator over the Interface1D vertices, pointing to the first vertex.
+    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.
+                :return: An Interface0DIterator pointing to the first vertex.
+                :rtype: Interface0DIterator
         """
         ...
 
-    def vertices_end(self) -> "Interface0DIterator":
-        """Returns an iterator over the Interface1D vertices, pointing after the last vertex.
+    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.
+                :return: An Interface0DIterator pointing after the last vertex.
+                :rtype: Interface0DIterator
         """
         ...
 
@@ -705,28 +962,28 @@ class Iterator:
 class Material:
     """Class defining a material."""
 
-    ambient: typing.Union[typing.Sequence[float], "mathutils.Color"]
+    ambient: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGBA components of the ambient color of the material.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Color']
+    :type: typing.Union[typing.Sequence[float], mathutils.Color]
     """
 
-    diffuse: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    diffuse: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the diffuse color of the material.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    emission: typing.Union[typing.Sequence[float], "mathutils.Color"]
+    emission: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGBA components of the emissive color of the material.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Color']
+    :type: typing.Union[typing.Sequence[float], mathutils.Color]
     """
 
-    line: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    line: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the line color of the material.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     priority: int
@@ -741,52 +998,80 @@ class Material:
     :type: float
     """
 
-    specular: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    specular: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the specular color of the material.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     def __init__(self):
-        """__init__(brother) __init__(line, diffuse, ambient, specular, emission, shininess, priority) 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'
-        :param line: The line color.
-        :type line: typing.Union[typing.Sequence[float], 'mathutils.Vector', typing.List]
-        :param diffuse: The diffuse color.
-        :type diffuse: typing.Union[typing.Sequence[float], 'mathutils.Vector', typing.List]
-        :param ambient: The ambient color.
-        :type ambient: typing.Union[typing.Sequence[float], 'mathutils.Vector', typing.List]
-        :param specular: The specular color.
-        :type specular: typing.Union[typing.Sequence[float], 'mathutils.Vector', typing.List]
-        :param emission: The emissive color.
-        :type emission: typing.Union[typing.Sequence[float], 'mathutils.Vector', typing.List]
-        :param shininess: The shininess coefficient.
-        :type shininess: float
-        :param priority: The line color priority.
-        :type priority: int
+        """Creates a `FrsMaterial` using either default constructor,
+        copy constructor, or an overloaded constructor
+
+        """
+        ...
+
+    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
+        """
+        ...
+
+    def __init__(
+        self,
+        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,
+    ):
+        """Creates a `FrsMaterial` using either default constructor,
+        copy constructor, or an overloaded constructor
+
+                :param line: The line color.
+                :type line: typing.Union[typing.Sequence[float], mathutils.Vector, list]
+                :param diffuse: The diffuse color.
+                :type diffuse: typing.Union[typing.Sequence[float], mathutils.Vector, list]
+                :param ambient: The ambient color.
+                :type ambient: typing.Union[typing.Sequence[float], mathutils.Vector, list]
+                :param specular: The specular color.
+                :type specular: typing.Union[typing.Sequence[float], mathutils.Vector, list]
+                :param emission: The emissive color.
+                :type emission: typing.Union[typing.Sequence[float], mathutils.Vector, list]
+                :param shininess: The shininess coefficient.
+                :type shininess: float
+                :param priority: The line color priority.
+                :type priority: int
         """
         ...
 
 class MediumType:
-    """Class hierarchy: int > `MediumType` The different blending modes available to simulate the interaction media-medium: * Stroke.DRY_MEDIUM: To simulate a dry medium such as Pencil or Charcoal. * Stroke.HUMID_MEDIUM: To simulate ink painting (color subtraction blending). * Stroke.OPAQUE_MEDIUM: To simulate an opaque medium (oil, spray...)."""
+    """Class hierarchy: int > `MediumType`The different blending modes available to simulate the interaction
+    media-medium:
+    """
 
     ...
 
 class Nature:
-    """Class hierarchy: int > `Nature` Different possible natures of 0D and 1D elements of the ViewMap. Vertex natures: * Nature.POINT: True for any 0D element. * Nature.S_VERTEX: True for SVertex. * Nature.VIEW_VERTEX: True for ViewVertex. * Nature.NON_T_VERTEX: True for NonTVertex. * Nature.T_VERTEX: True for TVertex. * Nature.CUSP: True for CUSP. Edge natures: * Nature.NO_FEATURE: True for non feature edges (always false for 1D elements of the ViewMap). * Nature.SILHOUETTE: True for silhouettes. * Nature.BORDER: True for borders. * Nature.CREASE: True for creases. * Nature.RIDGE: True for ridges. * Nature.VALLEY: True for valleys. * Nature.SUGGESTIVE_CONTOUR: True for suggestive contours. * Nature.MATERIAL_BOUNDARY: True for edges at material boundaries. * Nature.EDGE_MARK: True for edges having user-defined edge marks."""
+    """Class hierarchy: int > `Nature`Different possible natures of 0D and 1D elements of the ViewMap.Vertex natures:Edge natures:"""
 
     ...
 
 class Noise:
-    """Class to provide Perlin noise functionalities. Undocumented, consider `contributing <https://developer.blender.org/>`__. Undocumented, consider `contributing <https://developer.blender.org/>`__."""
+    """Class to provide Perlin noise functionalities.Undocumented, consider contributing.Undocumented, consider contributing."""
 
-    def __init__(self, seed=" -1"):
-        """Builds a Noise object. Seed is an optional argument. The seed value is used as a seed for random number generation if it is equal to or greater than zero; otherwise, time is used as a seed.
+    def __init__(self, seed: int = -1):
+        """Builds a Noise object. Seed is an optional argument. The seed value is used
+        as a seed for random number generation if it is equal to or greater than zero;
+        otherwise, time is used as a seed.
 
-        :param seed: Seed for random number generation.
-        :type seed: int
+                :param seed: Seed for random number generation.
+                :type seed: int
         """
         ...
 
@@ -795,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[typing.Sequence[float], "mathutils.Vector", typing.List]
-    ) -> 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[typing.Sequence[float], 'mathutils.Vector', typing.List]
-        :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[typing.Sequence[float], "mathutils.Vector", typing.List]
-    ) -> 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[typing.Sequence[float], 'mathutils.Vector', typing.List]
-        :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.
@@ -835,151 +1120,219 @@ 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[typing.Sequence[float], "mathutils.Vector", typing.List],
+        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[typing.Sequence[float], 'mathutils.Vector', typing.List]
+        :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[typing.Sequence[float], "mathutils.Vector", typing.List],
+        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[typing.Sequence[float], 'mathutils.Vector', typing.List]
+        :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
         """
         ...
 
 class NonTVertex:
-    """Class hierarchy: `Interface0D` > `ViewVertex` > `NonTVertex` View vertex for corners, cusps, etc. associated to a single SVertex. Can be associated to 2 or more view edges."""
+    """Class hierarchy: `Interface0D` > `ViewVertex` > `NonTVertex`View vertex for corners, cusps, etc. associated to a single SVertex.
+    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):
-        """__init__(svertex) Builds a `NonTVertex` using the default constructor or a `SVertex`.
+        """Builds a `NonTVertex` using the default constructor or a `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
         """
         ...
 
 class Operators:
-    """Class defining the operators used in a style module. There are five types of operators: Selection, chaining, splitting, sorting and creation. All these operators are user controlled through functors, predicates and shaders that are taken as arguments."""
+    """Class defining the operators used in a style module. There are five
+    types of operators: Selection, chaining, splitting, sorting and
+    creation. All these operators are user controlled through functors,
+    predicates and shaders that are taken as arguments.
+    """
+
+    @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
+        using the user specified iterator. This operator iterates both using
+        the increment and decrement operators and is therefore bidirectional.
+        This operator works with a ChainingIterator which contains the
+        chaining rules. It is this last one which can be told to chain only
+        edges that belong to the selection or not to process twice a ViewEdge
+        during the chaining. Each time a ViewEdge is added to a chain, its
+        chaining time stamp is incremented. This allows you to keep track of
+        the number of chains to which a ViewEdge belongs to.
+
+                :param it: The ChainingIterator on the ViewEdges of the ViewMap. It
+        contains the chaining rule.
+                :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
+        """
+        ...
 
     @staticmethod
-    def bidirectional_chain(it: "ChainingIterator", pred: "UnaryPredicate1D"):
-        """bidirectional_chain(it) 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 using the user specified iterator. This operator iterates both using the increment and decrement operators and is therefore bidirectional. This operator works with a ChainingIterator which contains the chaining rules. It is this last one which can be told to chain only edges that belong to the selection or not to process twice a ViewEdge during the chaining. Each time a ViewEdge is added to a chain, its chaining time stamp is incremented. This allows you to keep track of the number of chains to which a ViewEdge belongs to.
+    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
+        using the user specified iterator. This operator iterates both using
+        the increment and decrement operators and is therefore bidirectional.
+        This operator works with a ChainingIterator which contains the
+        chaining rules. It is this last one which can be told to chain only
+        edges that belong to the selection or not to process twice a ViewEdge
+        during the chaining. Each time a ViewEdge is added to a chain, its
+        chaining time stamp is incremented. This allows you to keep track of
+        the number of chains to which a ViewEdge belongs to.
 
-        :param it: The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-        :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'
+                :param it: The ChainingIterator on the ViewEdges of the ViewMap. It
+        contains the chaining rule.
+                :type it: ChainingIterator
         """
         ...
 
     @staticmethod
     def chain(
-        it: "ViewEdgeIterator",
-        pred: "UnaryPredicate1D",
-        modifier: "UnaryFunction1DVoid",
+        it: ViewEdgeIterator, pred: UnaryPredicate1D, modifier: UnaryFunction1DVoid
     ):
-        """chain(it, pred) 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 user specified iterator. This operator only iterates using the increment operator and is therefore unidirectional.
+        """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
+        user specified iterator. This operator only iterates using the
+        increment operator and is therefore unidirectional.
+
+                :param it: The iterator on the ViewEdges of the ViewMap. It contains
+        the chaining rule.
+                :type it: ViewEdgeIterator
+                :param pred: The predicate on the ViewEdge that expresses the
+        stopping condition.
+                :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
+        """
+        ...
+
+    @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
+        user specified iterator. This operator only iterates using the
+        increment operator and is therefore unidirectional.
 
-        :param it: The iterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-        :type it: 'ViewEdgeIterator'
-        :param pred: The predicate on the ViewEdge that expresses the stopping condition.
-        :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'
+                :param it: The iterator on the ViewEdges of the ViewMap. It contains
+        the chaining rule.
+                :type it: ViewEdgeIterator
+                :param pred: The predicate on the ViewEdge that expresses the
+        stopping condition.
+                :type pred: UnaryPredicate1D
         """
         ...
 
     @staticmethod
-    def create(pred: "UnaryPredicate1D", shaders: typing.List["StrokeShader"]):
-        """Creates and shades the strokes from the current set of chains. A predicate can be specified to make a selection pass on the chains.
+    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'
-        :param shaders: The list of shaders used to shade the strokes.
-        :type shaders: typing.List['StrokeShader']
+                :param pred: The predicate that a chain must verify in order to be
+        transform as a stroke.
+                :type pred: UnaryPredicate1D
+                :param shaders: The list of shaders used to shade the strokes.
         """
         ...
 
     @staticmethod
-    def get_chain_from_index(i: int) -> "Chain":
+    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
         """
         ...
 
     @staticmethod
-    def get_chains_size() -> int:
+    def get_chains_size() -> Chain:
         """Returns the number of Chains.
 
-        :rtype: int
         :return: The number of Chains.
+        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_stroke_from_index(i: int) -> "Stroke":
+    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
         """
         ...
 
     @staticmethod
-    def get_strokes_size() -> int:
+    def get_strokes_size() -> Stroke:
         """Returns the number of Strokes.
 
-        :rtype: int
         :return: The number of Strokes.
+        :rtype: int
         """
         ...
 
@@ -987,106 +1340,186 @@ class Operators:
     def get_view_edges_size() -> int:
         """Returns the number of ViewEdges.
 
-        :rtype: int
         :return: The number of ViewEdges.
+        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_viewedge_from_index(i: int) -> "ViewEdge":
+    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(
-        func: "UnaryFunction0DDouble",
-        pred_1d: "UnaryPredicate1D",
-        sampling: float = 0.0,
+        func: UnaryFunction0DDouble, pred_1d: UnaryPredicate1D, sampling: float = 0.0
     ):
-        """recursive_split(func, pred_0d, pred_1d, sampling=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 minimizing a specified function. The chain is split in two at this point and the two new chains are processed in the same way. The recursivity level is controlled through a predicate 1D that expresses a stopping condition on the chain that is about to be processed. The user can also specify a 0D predicate to make a first selection on the points that can potentially be split. A point that doesn't verify the 0D predicate won't be candidate in realizing the min.
+        """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
+        minimizing a specified function. The chain is split in two at this
+        point and the two new chains are processed in the same way. The
+        recursivity level is controlled through a predicate 1D that expresses
+        a stopping condition on the chain that is about to be processed.The user can also specify a 0D predicate to make a first selection on the points
+        that can potentially be split. A point that doesn't verify the 0D
+        predicate won't be candidate in realizing the min.
+
+                :param func: The Unary Function evaluated at each point of the chain.
+        The splitting point is the point minimizing this function.
+                :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
+                :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
+        resolution.)
+                :type sampling: float
+        """
+        ...
 
-        :param func: The Unary Function evaluated at each point of the chain. The splitting point is the point minimizing this function.
-        :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'
-        :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'
-        :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 resolution.)
-        :type sampling: float
+    @staticmethod
+    def recursive_split(
+        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
+        points of each chain (with a specified sampling) to find the point
+        minimizing a specified function. The chain is split in two at this
+        point and the two new chains are processed in the same way. The
+        recursivity level is controlled through a predicate 1D that expresses
+        a stopping condition on the chain that is about to be processed.The user can also specify a 0D predicate to make a first selection on the points
+        that can potentially be split. A point that doesn't verify the 0D
+        predicate won't be candidate in realizing the min.
+
+                :param func: The Unary Function evaluated at each point of the chain.
+        The splitting point is the point minimizing this function.
+                :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
+                :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
+                :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
+        resolution.)
+                :type sampling: float
         """
         ...
 
     @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.
+        """Resets the line stylization process to the initial state. The results of
+        stroke creation are accumulated if delete_strokes is set to False.
 
-        :param delete_strokes: Delete the strokes that are currently stored.
-        :type delete_strokes: bool
+                :param delete_strokes: Delete the strokes that are currently stored.
+                :type delete_strokes: bool
         """
         ...
 
     @staticmethod
-    def select(pred: "UnaryPredicate1D"):
-        """Selects the ViewEdges of the ViewMap verifying a specified condition.
+    def select(pred: UnaryPredicate1D):
+        """Selects the ViewEdges of the ViewMap verifying a specified
+        condition.
 
-        :param pred: The predicate expressing this condition.
-        :type pred: 'UnaryPredicate1D'
+                :param pred: The predicate expressing this condition.
+                :type pred: UnaryPredicate1D
         """
         ...
 
     @staticmethod
     def sequential_split(
-        starting_pred: "UnaryPredicate0D",
-        stopping_pred: "UnaryPredicate0D",
+        starting_pred: UnaryPredicate0D,
+        stopping_pred: UnaryPredicate0D,
         sampling: float = 0.0,
     ):
-        """sequential_split(pred, sampling=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 first point of one of the resulting chains. The splitting ends when no more chain can start.
+        """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
+        first point of one of the resulting chains. The splitting ends when
+        no more chain can start.
+
+                :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
+                :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
+                :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
+        resolution.)
+                :type sampling: float
+        """
+        ...
+
+    @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
+        first point of one of the resulting chains. The splitting ends when
+        no more chain can start.
 
-        :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'
-        :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'
-        :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'
-        :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 resolution.)
-        :type sampling: float
+                :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
+                :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
+        resolution.)
+                :type sampling: float
         """
         ...
 
     @staticmethod
-    def sort(pred: "BinaryPredicate1D"):
-        """Sorts the current set of chains (or viewedges) according to the comparison predicate given as argument.
+    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'
+                :param pred: The binary predicate used for the comparison.
+                :type pred: BinaryPredicate1D
         """
         ...
 
 class SShape:
-    """Class to define a feature shape. It is the gathering of feature elements from an identified input shape."""
+    """Class to define a feature shape. It is the gathering of feature
+    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
@@ -1095,33 +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):
-        """__init__(brother) Creates a `SShape` class using either a default constructor or copy constructor.
+        """Creates a `SShape` class using either a default constructor or copy constructor."""
+        ...
+
+    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"):
-        """Adds an SVertex to the list of SVertex of this Shape. The SShape attribute of the SVertex is also set to this SShape.
+    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'
+                :param vertex: An SVertex object.
+                :type vertex: SVertex
         """
         ...
 
@@ -1130,25 +1568,32 @@ class SShape:
         ...
 
 class SVertex:
-    """Class hierarchy: `Interface0D` > `SVertex` Class to define a vertex of the embedding."""
+    """Class hierarchy: `Interface0D` > `SVertex`Class to define a vertex of the embedding."""
 
     curvatures: typing.Tuple
-    """ Curvature information expressed in the form of a seven-element tuple (K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values representing the first (maximum) and second (minimum) principal curvatures at this SVertex, respectively; e1 and e2 are three-dimensional vectors representing the first and second principal directions, i.e. the directions of the normal plane where the curvature takes its maximum and minimum values, respectively; and Kr, er and dKr are the radial curvature, radial direction, and the derivative of the radial curvature at this SVertex, respectively.
+    """ Curvature information expressed in the form of a seven-element tuple
+(K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values
+representing the first (maximum) and second (minimum) principal
+curvatures at this SVertex, respectively; e1 and e2 are
+three-dimensional vectors representing the first and second principal
+directions, i.e. the directions of the normal plane where the
+curvature takes its maximum and minimum values, respectively; and Kr,
+er and dKr are the radial curvature, radial direction, and the
+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"]
-    """ 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']
-    """
+    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."""
 
     normals_size: int
     """ The number of different normals for this SVertex.
@@ -1156,62 +1601,83 @@ class SVertex:
     :type: int
     """
 
-    point_2d: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    point_2d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The projected 3D coordinates of the SVertex.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    point_3d: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    point_3d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The 3D coordinates of the SVertex.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    viewvertex: "ViewVertex"
-    """ If this SVertex is also a ViewVertex, this property refers to the ViewVertex, and None otherwise.
+    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):
-        """__init__(brother) __init__(point_3d, id) Builds a `SVertex` using the default constructor, copy constructor or the overloaded constructor which builds a `SVertex` from 3D coordinates and an Id.
+        """Builds a `SVertex` using the default constructor,
+        copy constructor or the overloaded constructor which builds   a `SVertex` from 3D coordinates and an Id.
+
+        """
+        ...
+
+    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
+        """
+        ...
+
+    def __init__(
+        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 brother: A SVertex object.
-        :type brother: 'SVertex'
-        :param point_3d: A three-dimensional vector.
-        :type point_3d: typing.Union[typing.Sequence[float], 'mathutils.Vector']
-        :param id: An Id object.
-        :type id: 'Id'
+                :param point_3d: A three-dimensional vector.
+                :type point_3d: typing.Union[typing.Sequence[float], mathutils.Vector]
+                :param id: An Id object.
+                :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[typing.Sequence[float], "mathutils.Vector", typing.List],
+        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.
+        """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[typing.Sequence[float], 'mathutils.Vector', typing.List]
+                :param normal: A three-dimensional vector.
+                :type normal: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         """
         ...
 
 class SVertexIterator:
-    """Class hierarchy: `Iterator` > `SVertexIterator` Class representing an iterator over `SVertex` of a `ViewEdge`. An instance of an SVertexIterator can be obtained from a ViewEdge by calling verticesBegin() or verticesEnd()."""
+    """Class hierarchy: `Iterator` > `SVertexIterator`Class representing an iterator over `SVertex` of a
+    `ViewEdge`. An instance of an SVertexIterator can be obtained
+    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
@@ -1227,30 +1693,51 @@ class SVertexIterator:
     """
 
     def __init__(self):
-        """__init__(brother) __init__(vertex, begin, previous_edge, next_edge, t) Build an SVertexIterator using either the default constructor, copy constructor, or the overloaded constructor that starts iteration from an SVertex object vertex.
+        """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):
+        """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,
+        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
         """
         ...
 
 class Stroke:
-    """Class hierarchy: `Interface1D` > `Stroke` Class to define a stroke. A stroke is made of a set of 2D vertices (`StrokeVertex`), regularly spaced out. This set of vertices defines the stroke's backbone geometry. Each of these stroke vertices defines the stroke's shape and appearance at this vertex position."""
+    """Class hierarchy: `Interface1D` > `Stroke`Class to define a stroke. A stroke is made of a set of 2D vertices
+    (`StrokeVertex`), regularly spaced out. This set of vertices
+    defines the stroke's backbone geometry. Each of these stroke vertices
+    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
@@ -1259,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
@@ -1278,26 +1765,41 @@ class Stroke:
     """
 
     def Stroke(self):
-        """Stroke(brother) Creates a `Stroke` using the default constructor or copy constructor"""
+        """Creates a `Stroke` using the default constructor or copy constructor"""
         ...
 
-    def compute_sampling(self, n: int) -> float:
-        """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, use the RemoveVertex() method of this class.)
+    def Stroke(self, brother):
+        """Creates a `Stroke` using the default constructor or copy constructor
 
-        :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.
+        :param brother:
+        """
+        ...
+
+    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,
+        use the RemoveVertex() method of this class.)
+
+                :param n: The number of stroke vertices we eventually want
+        in our Stroke.
+                :type n: int
+                :return: The sampling that must be used in the Resample(float)
+        method.
+                :rtype: float
         """
         ...
 
-    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.
+    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'
-        :param next: A StrokeVertexIterator pointing to the StrokeVertex before which vertex must be inserted.
-        :type next: 'StrokeVertexIterator'
+                :param vertex: The StrokeVertex to insert in the Stroke.
+                :type vertex: StrokeVertex
+                :param next: A StrokeVertexIterator pointing to the StrokeVertex
+        before which vertex must be inserted.
+                :type next: StrokeVertexIterator
         """
         ...
 
@@ -1305,47 +1807,64 @@ class Stroke:
         """Removes all vertices from the Stroke."""
         ...
 
-    def remove_vertex(self, vertex: "StrokeVertex"):
-        """Removes the StrokeVertex given as argument from the Stroke. The length and curvilinear abscissa are updated consequently.
+    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'
+                :param vertex: the StrokeVertex to remove from the Stroke.
+                :type vertex: StrokeVertex
         """
         ...
 
     def resample(self, n: int):
-        """resample(sampling) Resamples the stroke so using one of two methods with the goal of creating a stroke with fewer points and the same shape.
+        """Resamples the stroke so using one of two methods with the goal
+        of creating a stroke with fewer points and the same shape.
 
-        :param n: Resamples the stroke so that it eventually has N points. That means it is going to add N-vertices_size, where vertices_size is the number of points we already have. If vertices_size >= N, no resampling is done.
-        :type n: int
-        :param sampling: Resamples the stroke with a given sampling value. If the sampling is smaller than the actual sampling value, no resampling is done.
-        :type sampling: float
+                :param n: Resamples the stroke so that it eventually has N points. That means
+        it is going to add N-vertices_size, where vertices_size is the
+        number of points we already have. If vertices_size >= N, no
+        resampling is done.
+                :type n: int
         """
         ...
 
-    def stroke_vertices_begin(self, t: float = 0.0) -> "StrokeVertexIterator":
-        """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.
+    def resample(self, sampling: float):
+        """Resamples the stroke so using one of two methods with the goal
+        of creating a stroke with fewer points and the same shape.
 
-        :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.
+                :param sampling: Resamples the stroke with a given sampling value. If the
+        sampling is smaller than the actual sampling value, no resampling is done.
+                :type sampling: float
+        """
+        ...
+
+    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.
+
+                :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
+                :return: A StrokeVertexIterator pointing on the first StrokeVertex.
+                :rtype: StrokeVertexIterator
         """
         ...
 
-    def stroke_vertices_end(self) -> "StrokeVertexIterator":
-        """Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke.
+    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.
+                :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
         """
         ...
 
@@ -1354,7 +1873,10 @@ class Stroke:
         ...
 
 class StrokeAttribute:
-    """Class to define a set of attributes associated with a `StrokeVertex`. The attribute set stores the color, alpha and thickness values for a Stroke Vertex."""
+    """Class to define a set of attributes associated with a `StrokeVertex`.
+    The attribute set stores the color, alpha and thickness values for a Stroke
+    Vertex.
+    """
 
     alpha: float
     """ Alpha component of the stroke color.
@@ -1362,16 +1884,18 @@ class StrokeAttribute:
     :type: float
     """
 
-    color: typing.Union[typing.Sequence[float], "mathutils.Color"]
+    color: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGB components of the stroke color.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Color']
+    :type: typing.Union[typing.Sequence[float], mathutils.Color]
     """
 
-    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.
+    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[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     visible: bool
@@ -1381,131 +1905,182 @@ class StrokeAttribute:
     """
 
     def __init__(self):
-        """__init__(brother) __init__(red, green, blue, alpha, thickness_right, thickness_left) __init__(attribute1, attribute2, t) 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'
-        :param red: Red component of a stroke color.
-        :type red: float
-        :param green: Green component of a stroke color.
-        :type green: float
-        :param blue: Blue component of a stroke color.
-        :type blue: float
-        :param alpha: Alpha component of a stroke color.
-        :type alpha: float
-        :param thickness_right: Stroke thickness on the right.
-        :type thickness_right: float
-        :param thickness_left: Stroke thickness on the left.
-        :type thickness_left: float
-        :param attribute1: The first StrokeAttribute object.
-        :type attribute1: 'StrokeAttribute'
-        :param attribute2: The second StrokeAttribute object.
-        :type attribute2: 'StrokeAttribute'
-        :param t: The interpolation parameter (0 <= t <= 1).
-        :type 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.
+
         """
         ...
 
-    def get_attribute_real(self, name: str) -> float:
+    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
+        """
+        ...
+
+    def __init__(
+        self,
+        red: float,
+        green: float,
+        blue: float,
+        alpha: float,
+        thickness_right: float,
+        thickness_left: 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 red: Red component of a stroke color.
+                :type red: float
+                :param green: Green component of a stroke color.
+                :type green: float
+                :param blue: Blue component of a stroke color.
+                :type blue: float
+                :param alpha: Alpha component of a stroke color.
+                :type alpha: float
+                :param thickness_right: Stroke thickness on the right.
+                :type thickness_right: float
+                :param thickness_left: Stroke thickness on the left.
+                :type thickness_left: float
+        """
+        ...
+
+    def __init__(
+        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
+                :param attribute2: The second StrokeAttribute object.
+                :type attribute2: StrokeAttribute
+                :param t: The interpolation parameter (0 <= t <= 1).
+                :type t: 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:
-        """Checks whether the attribute name of two-dimensional vector type is available.
+    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.
+                :param name: The name of the attribute.
+                :type name: str
+                :return: True if the attribute is available.
+                :rtype: bool
         """
         ...
 
-    def has_attribute_vec3(self, name: str) -> bool:
-        """Checks whether the attribute name of three-dimensional vector type is available.
+    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.
+                :param name: The name of the attribute.
+                :type name: str
+                :return: True if the attribute is available.
+                :rtype: bool
         """
         ...
 
     def set_attribute_real(self, name: str, value: float):
-        """Adds a user-defined attribute of float type. If there is no attribute of the given name, it is added. Otherwise, the new value replaces the old one.
+        """Adds a user-defined attribute of float type. If there is no
+        attribute of the given name, it is added. Otherwise, the new value
+        replaces the old one.
 
-        :param name: The name of the attribute.
-        :type name: str
-        :param value: The attribute value.
-        :type value: float
+                :param name: The name of the attribute.
+                :type name: str
+                :param value: The attribute value.
+                :type value: float
         """
         ...
 
     def set_attribute_vec2(
         self,
         name: str,
-        value: typing.Union[typing.Sequence[float], "mathutils.Vector", typing.List],
+        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, the new value replaces the old one.
+        """Adds a user-defined attribute of two-dimensional vector type. If
+        there is no attribute of the given name, it is added. Otherwise,
+        the new value replaces the old one.
 
-        :param name: The name of the attribute.
-        :type name: str
-        :param value: The attribute value.
-        :type value: typing.Union[typing.Sequence[float], 'mathutils.Vector', typing.List]
+                :param name: The name of the attribute.
+                :type name: str
+                :param value: The attribute value.
+                :type value: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         """
         ...
 
     def set_attribute_vec3(
         self,
         name: str,
-        value: typing.Union[typing.Sequence[float], "mathutils.Vector", typing.List],
+        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. Otherwise, the new value replaces the old one.
+        """Adds a user-defined attribute of three-dimensional vector type.
+        If there is no attribute of the given name, it is added.
+        Otherwise, the new value replaces the old one.
 
-        :param name: The name of the attribute.
-        :type name: str
-        :param value: The attribute value.
-        :type value: typing.Union[typing.Sequence[float], 'mathutils.Vector', typing.List]
+                :param name: The name of the attribute.
+                :type name: str
+                :param value: The attribute value.
+                :type value: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         """
         ...
 
 class StrokeShader:
-    """Base class for stroke shaders. Any stroke shader must inherit from this class and overload the shade() method. A StrokeShader is designed to modify stroke attributes such as thickness, color, geometry, texture, blending mode, and so on. The basic way for this operation is to iterate over the stroke vertices of the `Stroke` and to modify the `StrokeAttribute` of each vertex. Here is a code example of such an iteration:: it = ioStroke.strokeVerticesBegin() while not it.is_end: att = it.object.attribute ## perform here any attribute modification it.increment()"""
+    """Base class for stroke shaders. Any stroke shader must inherit from
+    this class and overload the shade() method. A StrokeShader is
+    designed to modify stroke attributes such as thickness, color,
+    geometry, texture, blending mode, and so on. The basic way for this
+    operation is to iterate over the stroke vertices of the `Stroke`
+    and to modify the `StrokeAttribute` of each vertex. Here is a
+    code example of such an iteration:
+    """
 
     name: str
     """ The name of the stroke shader.
@@ -1517,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."""
+    """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
@@ -1540,14 +2115,15 @@ class StrokeVertex:
     :type: float
     """
 
-    point: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    point: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ 2D point coordinates.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     stroke_length: float
-    """ Stroke length (it is only a value retained by the StrokeVertex, and it won't change the real stroke length).
+    """ Stroke length (it is only a value retained by the StrokeVertex,
+and it won't change the real stroke length).
 
     :type: float
     """
@@ -1559,40 +2135,98 @@ class StrokeVertex:
     """
 
     def __init__(self):
-        """__init__(brother) __init__(first_vertex, second_vertex, t3d) __init__(point) __init__(svertex) __init__(svertex, attribute) 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'
-        :param first_vertex: The first StrokeVertex.
-        :type first_vertex: 'StrokeVertex'
-        :param second_vertex: The second StrokeVertex.
-        :type second_vertex: 'StrokeVertex'
-        :param t3d: An interpolation parameter.
-        :type t3d: float
-        :param point: A CurvePoint object.
-        :type point: 'CurvePoint'
-        :param svertex: An SVertex object. An SVertex object.
-        :type svertex: 'SVertex'
-        :param svertex: An SVertex object. An SVertex object.
-        :type svertex: 'SVertex'
-        :param attribute: A StrokeAttribute object.
-        :type 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.
+
+        """
+        ...
+
+    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
+        """
+        ...
+
+    def __init__(
+        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
+                :param second_vertex: The second StrokeVertex.
+                :type second_vertex: StrokeVertex
+                :param t3d: An interpolation parameter.
+                :type t3d: float
+        """
+        ...
+
+    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
+        """
+        ...
+
+    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: typing.Union[SVertex, SVertex]
+        """
+        ...
+
+    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: typing.Union[SVertex, SVertex]
+                :param attribute: A StrokeAttribute object.
+                :type attribute: StrokeAttribute
         """
         ...
 
 class StrokeVertexIterator:
-    """Class hierarchy: `Iterator` > `StrokeVertexIterator` Class defining an iterator designed to iterate over the `StrokeVertex` of a `Stroke`. An instance of a StrokeVertexIterator can be obtained from a Stroke by calling iter(), stroke_vertices_begin() or stroke_vertices_begin(). It is iterating over the same vertices as an `Interface0DIterator`. The difference resides in the object access: an Interface0DIterator only allows access to an Interface0D while one might need to access the specialized StrokeVertex type. In this case, one should use a StrokeVertexIterator. To call functions of the UnaryFuntion0D type, a StrokeVertexIterator can be converted to an Interface0DIterator by by calling Interface0DIterator(it)."""
+    """Class hierarchy: `Iterator` > `StrokeVertexIterator`Class defining an iterator designed to iterate over the
+    `StrokeVertex` of a `Stroke`. An instance of a
+    StrokeVertexIterator can be obtained from a Stroke by calling
+    iter(), stroke_vertices_begin() or stroke_vertices_begin(). It is iterating
+    over the same vertices as an `Interface0DIterator`. The difference
+    resides in the object access: an Interface0DIterator only allows
+    access to an Interface0D while one might need to access the
+    specialized StrokeVertex type. In this case, one should use a
+    StrokeVertexIterator. To call functions of the UnaryFuntion0D type,
+    a StrokeVertexIterator can be converted to an Interface0DIterator by
+    by calling Interface0DIterator(it).
+    """
 
     at_last: bool
-    """ True if the iterator points to the last valid element. For its counterpart (pointing to the first valid element), use it.is_begin.
+    """ True if the iterator points to the last valid element.
+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
@@ -1608,84 +2242,107 @@ class StrokeVertexIterator:
     """
 
     def __init__(self):
-        """__init__(brother) Creates a `StrokeVertexIterator` using either the default constructor or the copy constructor.
+        """Creates a `StrokeVertexIterator` using either the
+        default constructor or the copy constructor.
+
+        """
+        ...
+
+    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'
+                :param brother: A StrokeVertexIterator object.
+                :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":
-        """Returns a StrokeVertexIterator that traverses stroke vertices in the reversed order.
+    def reversed(self) -> StrokeVertexIterator:
+        """Returns a StrokeVertexIterator that traverses stroke vertices in the
+        reversed order.
 
-        :rtype: 'StrokeVertexIterator'
-        :return: A StrokeVertexIterator traversing stroke vertices backward.
+                :return: A StrokeVertexIterator traversing stroke vertices backward.
+                :rtype: StrokeVertexIterator
         """
         ...
 
 class TVertex:
-    """Class hierarchy: `Interface0D` > `ViewVertex` > `TVertex` Class to define a T vertex, i.e. an intersection between two edges. It points towards two SVertex and four ViewEdges. Among the ViewEdges, two are front and the other two are back. Basically a front edge hides part of a back edge. So, among the back edges, one is of invisibility N and the other of invisibility N+1."""
+    """Class hierarchy: `Interface0D` > `ViewVertex` > `TVertex`Class to define a T vertex, i.e. an intersection between two edges.
+    It points towards two SVertex and four ViewEdges. Among the
+    ViewEdges, two are front and the other two are back. Basically a
+    front edge hides part of a back edge. So, among the back edges, one
+    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":
-        """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.
+    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'
-        :return: The mate edge of the given ViewEdge.
+                :param viewedge: A ViewEdge object.
+                :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
         """
         ...
 
 class UnaryFunction0D:
-    """Base class for Unary Functions (functors) working on `Interface0DIterator`. A unary function will be used by invoking __call__() on an Interface0DIterator. In Python, several different subclasses of UnaryFunction0D are used depending on the types of functors' return values. For example, you would inherit from a `UnaryFunction0DDouble` if you wish to define a function that returns a double value. Available UnaryFunction0D subclasses are: * `UnaryFunction0DDouble` * `UnaryFunction0DEdgeNature` * `UnaryFunction0DFloat` * `UnaryFunction0DId` * `UnaryFunction0DMaterial` * `UnaryFunction0DUnsigned` * `UnaryFunction0DVec2f` * `UnaryFunction0DVec3f` * `UnaryFunction0DVectorViewShape` * `UnaryFunction0DViewShape`"""
+    """Base class for Unary Functions (functors) working on
+    `Interface0DIterator`. A unary function will be used by
+    invoking __call__() on an Interface0DIterator. In Python, several
+    different subclasses of UnaryFunction0D are used depending on the
+    types of functors' return values. For example, you would inherit from
+    a `UnaryFunction0DDouble` if you wish to define a function that
+    returns a double value. Available UnaryFunction0D subclasses are:
+    """
 
     name: str
     """ The name of the unary 0D function.
@@ -1694,77 +2351,105 @@ class UnaryFunction0D:
     """
 
 class UnaryFunction0DDouble:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DDouble` Base class for unary functions (functors) that work on `Interface0DIterator` and return a float value."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DDouble`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a float value.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DEdgeNature:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DEdgeNature` Base class for unary functions (functors) that work on `Interface0DIterator` and return a `Nature` object."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DEdgeNature`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a `Nature` object.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DFloat:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DFloat` Base class for unary functions (functors) that work on `Interface0DIterator` and return a float value."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DFloat`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a float value.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DId:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DId` Base class for unary functions (functors) that work on `Interface0DIterator` and return an `Id` object."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DId`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return an `Id` object.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DMaterial:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DMaterial` Base class for unary functions (functors) that work on `Interface0DIterator` and return a `Material` object."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DMaterial`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a `Material` object.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DUnsigned:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DUnsigned` Base class for unary functions (functors) that work on `Interface0DIterator` and return an int value."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DUnsigned`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return an int value.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DVec2f:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DVec2f` Base class for unary functions (functors) that work on `Interface0DIterator` and return a 2D vector."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DVec2f`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a 2D vector.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DVec3f:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DVec3f` Base class for unary functions (functors) that work on `Interface0DIterator` and return a 3D vector."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DVec3f`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a 3D vector.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DVectorViewShape:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DVectorViewShape` Base class for unary functions (functors) that work on `Interface0DIterator` and return a list of `ViewShape` objects."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DVectorViewShape`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a list of `ViewShape`
+    objects.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction0DViewShape:
-    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DViewShape` Base class for unary functions (functors) that work on `Interface0DIterator` and return a `ViewShape` object."""
+    """Class hierarchy: `UnaryFunction0D` > `UnaryFunction0DViewShape`Base class for unary functions (functors) that work on
+    `Interface0DIterator` and return a `ViewShape` object.
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
 class UnaryFunction1D:
-    """Base class for Unary Functions (functors) working on `Interface1D`. A unary function will be used by invoking __call__() on an Interface1D. In Python, several different subclasses of UnaryFunction1D are used depending on the types of functors' return values. For example, you would inherit from a `UnaryFunction1DDouble` if you wish to define a function that returns a double value. Available UnaryFunction1D subclasses are: * `UnaryFunction1DDouble` * `UnaryFunction1DEdgeNature` * `UnaryFunction1DFloat` * `UnaryFunction1DUnsigned` * `UnaryFunction1DVec2f` * `UnaryFunction1DVec3f` * `UnaryFunction1DVectorViewShape` * `UnaryFunction1DVoid`"""
+    """Base class for Unary Functions (functors) working on
+    `Interface1D`. A unary function will be used by invoking
+    __call__() on an Interface1D. In Python, several different subclasses
+    of UnaryFunction1D are used depending on the types of functors' return
+    values. For example, you would inherit from a
+    `UnaryFunction1DDouble` if you wish to define a function that
+    returns a double value. Available UnaryFunction1D subclasses are:
+    """
 
     name: str
     """ The name of the unary 1D function.
@@ -1773,143 +2458,230 @@ class UnaryFunction1D:
     """
 
 class UnaryFunction1DDouble:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DDouble` Base class for unary functions (functors) that work on `Interface1D` and return a float value."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DDouble`Base class for unary functions (functors) that work on
+    `Interface1D` and return a float value.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using the default constructor or the integration method given as an argument.
+        """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'
+        """
+        ...
+
+    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
         """
         ...
 
 class UnaryFunction1DEdgeNature:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DEdgeNature` Base class for unary functions (functors) that work on `Interface1D` and return a `Nature` object."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DEdgeNature`Base class for unary functions (functors) that work on
+    `Interface1D` and return a `Nature` object.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using the default constructor or the integration method given as an argument.
+        """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'
+    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
         """
         ...
 
 class UnaryFunction1DFloat:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DFloat` Base class for unary functions (functors) that work on `Interface1D` and return a float value."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DFloat`Base class for unary functions (functors) that work on
+    `Interface1D` and return a float value.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using the default constructor or the integration method given as an argument.
+        """Builds a unary 1D function using the default constructor
+        or the integration method given as an argument.
+
+        """
+        ...
+
+    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'
+                :param integration_type: An integration method.
+                :type integration_type: IntegrationType
         """
         ...
 
 class UnaryFunction1DUnsigned:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DUnsigned` Base class for unary functions (functors) that work on `Interface1D` and return an int value."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DUnsigned`Base class for unary functions (functors) that work on
+    `Interface1D` and return an int value.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using the default constructor or the integration method given as an argument.
+        """Builds a unary 1D function using the default constructor
+        or the integration method given as an argument.
+
+        """
+        ...
+
+    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'
+                :param integration_type: An integration method.
+                :type integration_type: IntegrationType
         """
         ...
 
 class UnaryFunction1DVec2f:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVec2f` Base class for unary functions (functors) that work on `Interface1D` and return a 2D vector."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVec2f`Base class for unary functions (functors) that work on
+    `Interface1D` and return a 2D vector.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using the default constructor or the integration method given as an argument.
+        """Builds a unary 1D function using the default constructor
+        or the integration method given as an argument.
+
+        """
+        ...
+
+    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'
+                :param integration_type: An integration method.
+                :type integration_type: IntegrationType
         """
         ...
 
 class UnaryFunction1DVec3f:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVec3f` Base class for unary functions (functors) that work on `Interface1D` and return a 3D vector."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVec3f`Base class for unary functions (functors) that work on
+    `Interface1D` and return a 3D vector.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using the default constructor or the integration method given as an argument.
+        """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'
+        """
+        ...
+
+    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
         """
         ...
 
 class UnaryFunction1DVectorViewShape:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVectorViewShape` Base class for unary functions (functors) that work on `Interface1D` and return a list of `ViewShape` objects."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVectorViewShape`Base class for unary functions (functors) that work on
+    `Interface1D` and return a list of `ViewShape`
+    objects.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using the default constructor or the integration method given as an argument.
+        """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'
+        """
+        ...
+
+    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
         """
         ...
 
 class UnaryFunction1DVoid:
-    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVoid` Base class for unary functions (functors) working on `Interface1D`."""
+    """Class hierarchy: `UnaryFunction1D` > `UnaryFunction1DVoid`Base class for unary functions (functors) working on
+    `Interface1D`.
+    """
 
-    integration_type: "IntegrationType"
+    integration_type: IntegrationType
     """ The integration method.
 
-    :type: 'IntegrationType'
+    :type: IntegrationType
     """
 
     def __init__(self):
-        """__init__(integration_type) Builds a unary 1D function using either a default constructor or the integration method given as an argument.
+        """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'
+        """
+        ...
+
+    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
         """
         ...
 
 class UnaryPredicate0D:
-    """Base class for unary predicates that work on `Interface0DIterator`. A UnaryPredicate0D is a functor that evaluates a condition on an Interface0DIterator and returns true or false depending on whether this condition is satisfied or not. The UnaryPredicate0D is used by invoking its __call__() method. Any inherited class must overload the __call__() method."""
+    """Base class for unary predicates that work on
+    `Interface0DIterator`. A UnaryPredicate0D is a functor that
+    evaluates a condition on an Interface0DIterator and returns true or
+    false depending on whether this condition is satisfied or not. The
+    UnaryPredicate0D is used by invoking its __call__() method. Any
+    inherited class must overload the __call__() method.
+    """
 
     name: str
     """ The name of the unary 0D predicate.
@@ -1921,18 +2693,25 @@ 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
-        :return: True if the condition is satisfied, false otherwise.
+                :param it: The Interface0DIterator pointing onto the Interface0D at
+        which we wish to evaluate the predicate.
+                :type it: Interface0DIterator
+                :return: True if the condition is satisfied, false otherwise.
+                :rtype: bool
         """
         ...
 
 class UnaryPredicate1D:
-    """Base class for unary predicates that work on `Interface1D`. A UnaryPredicate1D is a functor that evaluates a condition on a Interface1D and returns true or false depending on whether this condition is satisfied or not. The UnaryPredicate1D is used by invoking its __call__() method. Any inherited class must overload the __call__() method."""
+    """Base class for unary predicates that work on `Interface1D`. A
+    UnaryPredicate1D is a functor that evaluates a condition on a
+    Interface1D and returns true or false depending on whether this
+    condition is satisfied or not. The UnaryPredicate1D is used by
+    invoking its __call__() method. Any inherited class must overload the
+    __call__() method.
+    """
 
     name: str
     """ The name of the unary 1D predicate.
@@ -1944,18 +2723,21 @@ 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
         """
         ...
 
 class ViewEdge:
-    """Class hierarchy: `Interface1D` > `ViewEdge` Class defining a ViewEdge. A ViewEdge in an edge of the image graph. it connects two `ViewVertex` objects. It is made by connecting a set of FEdges."""
+    """Class hierarchy: `Interface1D` > `ViewEdge`Class defining a ViewEdge. A ViewEdge in an edge of the image graph.
+    it connects two `ViewVertex` objects. It is made by connecting
+    a set of FEdges.
+    """
 
     chaining_time_stamp: int
     """ The time stamp of this ViewEdge.
@@ -1963,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
@@ -1987,28 +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"
-    """ 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.
+    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
@@ -2017,17 +2800,21 @@ class ViewEdge:
     :type: int
     """
 
-    viewshape: "ViewShape"
+    viewshape: ViewShape
     """ The ViewShape to which this ViewEdge belongs to.
 
-    :type: 'ViewShape'
+    :type: ViewShape
     """
 
     def __init__(self):
-        """__init__(brother) Builds a `ViewEdge` using the default constructor or the copy constructor.
+        """Builds a `ViewEdge` using the default constructor or the copy constructor."""
+        ...
+
+    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
         """
         ...
 
@@ -2036,43 +2823,59 @@ class ViewEdge:
         ...
 
 class ViewEdgeIterator:
-    """Class hierarchy: `Iterator` > `ViewEdgeIterator` Base class for iterators over ViewEdges of the `ViewMap` Graph. Basically the increment() operator of this class should be able to take the decision of "where" (on which ViewEdge) to go when pointing on a given ViewEdge."""
+    """Class hierarchy: `Iterator` > `ViewEdgeIterator`Base class for iterators over ViewEdges of the `ViewMap` Graph.
+    Basically the increment() operator of this class should be able to
+    take the decision of "where" (on which ViewEdge) to go when pointing
+    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
-    """ The orientation of the pointed ViewEdge in the iteration. If true, the iterator looks for the next ViewEdge among those ViewEdges that surround the ending ViewVertex of the "begin" ViewEdge. If false, the iterator searches over the ViewEdges surrounding the ending ViewVertex of the "begin" ViewEdge.
+    """ The orientation of the pointed ViewEdge in the iteration.
+If true, the iterator looks for the next ViewEdge among those ViewEdges
+that surround the ending ViewVertex of the "begin" ViewEdge. If false,
+the iterator searches over the ViewEdges surrounding the ending ViewVertex
+of the "begin" ViewEdge.
 
     :type: bool
     """
 
-    def __init__(
-        self, begin: typing.Optional["ViewEdge"] = None, orientation: bool = True
-    ):
-        """__init__(brother) Builds a ViewEdgeIterator from a starting ViewEdge and its orientation or the copy constructor.
+    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 ViewVertex of begin.
-        :type orientation: bool
-        :param brother: A ViewEdgeIterator object.
-        :type brother: 'ViewEdgeIterator'
+                :param begin: The ViewEdge from where to start the iteration.
+                :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
+        ViewVertex of begin.
+                :type orientation: bool
+        """
+        ...
+
+    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
         """
         ...
 
@@ -2083,53 +2886,55 @@ class ViewEdgeIterator:
 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
         """
         ...
 
 class ViewShape:
-    """Class gathering the elements of the ViewMap (i.e., `ViewVertex` and `ViewEdge`) that are issued from the same input shape."""
+    """Class gathering the elements of the ViewMap (i.e., `ViewVertex`
+    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]
@@ -2144,92 +2949,133 @@ 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):
-        """__init__(brother) __init__(sshape) Builds a `ViewShape` using the default constructor, copy constructor, or from a `SShape`.
+        """Builds a `ViewShape` using the default constructor,
+        copy constructor, or from a `SShape`.
 
-        :param brother: A ViewShape object.
-        :type brother: 'ViewShape'
-        :param sshape: An SShape object.
-        :type sshape: 'SShape'
         """
         ...
 
-    def add_edge(self, edge: "ViewEdge"):
+    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
+        """
+        ...
+
+    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
+        """
+        ...
+
+    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
         """
         ...
 
 class ViewVertex:
-    """Class hierarchy: `Interface0D` > `ViewVertex` Class to define a view vertex. A view vertex is a feature vertex corresponding to a point of the image graph, where the characteristics of an edge (e.g., nature and visibility) might change. A `ViewVertex` can be of two kinds: A `TVertex` when it corresponds to the intersection between two ViewEdges or a `NonTVertex` when it corresponds to a vertex of the initial input mesh (it is the case for vertices such as corners for example). Thus, this class can be specialized into two classes, the `TVertex` class and the `NonTVertex` class."""
-
-    nature: "Nature"
+    """Class hierarchy: `Interface0D` > `ViewVertex`Class to define a view vertex. A view vertex is a feature vertex
+    corresponding to a point of the image graph, where the characteristics
+    of an edge (e.g., nature and visibility) might change. A
+    `ViewVertex` can be of two kinds: A `TVertex` when it
+    corresponds to the intersection between two ViewEdges or a
+    `NonTVertex` when it corresponds to a vertex of the initial
+    input mesh (it is the case for vertices such as corners for example).
+    Thus, this class can be specialized into two classes, the
+    `TVertex` class and the `NonTVertex` class.
+    """
+
+    nature: Nature
     """ The nature of this ViewVertex.
 
-    :type: 'Nature'
+    :type: Nature
     """
 
-    def edges_begin(self) -> "orientedViewEdgeIterator":
-        """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).
+    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.
+                :return: An orientedViewEdgeIterator pointing to the first ViewEdge.
+                :rtype: orientedViewEdgeIterator
         """
         ...
 
-    def edges_end(self) -> "orientedViewEdgeIterator":
-        """Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex, pointing after the last ViewEdge.
+    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.
+                :return: An orientedViewEdgeIterator pointing after the last ViewEdge.
+                :rtype: orientedViewEdgeIterator
         """
         ...
 
-    def edges_iterator(self, edge: "ViewEdge") -> "orientedViewEdgeIterator":
-        """Returns an orientedViewEdgeIterator pointing to the ViewEdge given as argument.
+    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'
-        :return: An orientedViewEdgeIterator pointing to the given ViewEdge.
+                :param edge: A ViewEdge object.
+                :type edge: ViewEdge
+                :return: An orientedViewEdgeIterator pointing to the given ViewEdge.
+                :rtype: orientedViewEdgeIterator
         """
         ...
 
 class orientedViewEdgeIterator:
-    """Class hierarchy: `Iterator` > `orientedViewEdgeIterator` Class representing an iterator over oriented ViewEdges around a `ViewVertex`. This iterator allows a CCW iteration (in the image plane). An instance of an orientedViewEdgeIterator can only be obtained from a ViewVertex by calling edges_begin() or edges_end()."""
-
-    object: typing.Union[bool, "ViewEdge"]
-    """ 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[bool, 'ViewEdge']
+    """Class hierarchy: `Iterator` > `orientedViewEdgeIterator`Class representing an iterator over oriented ViewEdges around a
+    `ViewVertex`. This iterator allows a CCW iteration (in the image
+    plane). An instance of an orientedViewEdgeIterator can only be
+    obtained from a ViewVertex by calling edges_begin() or edges_end().
     """
 
+    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."""
+
     def __init__(self):
-        """__init__(iBrother) Creates an `orientedViewEdgeIterator` using either the default constructor or the copy constructor.
+        """Creates an `orientedViewEdgeIterator` using either the
+        default constructor or the copy constructor.
+
+        """
+        ...
+
+    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'
+                :param iBrother: An orientedViewEdgeIterator object.
+                :type iBrother: orientedViewEdgeIterator
         """
         ...