fake-bpy-module 20240411__py3-none-any.whl → 20240418__py3-none-any.whl

freestyle/types/__init__.pyi

@@ -1,3 +1,75 @@
+"""
+This module contains core classes of the Freestyle Python API,
+including data types of view map components (0D and 1D elements), base
+classes for user-defined line stylization rules (predicates,
+functions, chaining iterators, and stroke shaders), and operators.
+
+Class hierarchy:
+
+* BBox
+* BinaryPredicate0D
+* BinaryPredicate1D
+* Id
+* Interface0D
+    * CurvePoint
+        * StrokeVertex
+    * SVertex
+    * ViewVertex
+        * NonTVertex
+        * TVertex
+* Interface1D
+    * Curve
+        * Chain
+    * FEdge
+        * FEdgeSharp
+        * FEdgeSmooth
+    * Stroke
+    * ViewEdge
+* Iterator
+    * AdjacencyIterator
+    * CurvePointIterator
+    * Interface0DIterator
+    * SVertexIterator
+    * StrokeVertexIterator
+    * ViewEdgeIterator
+        * ChainingIterator
+    * orientedViewEdgeIterator
+* Material
+* Noise
+* Operators
+* SShape
+* StrokeAttribute
+* StrokeShader
+* UnaryFunction0D
+    * UnaryFunction0DDouble
+    * UnaryFunction0DEdgeNature
+    * UnaryFunction0DFloat
+    * UnaryFunction0DId
+    * UnaryFunction0DMaterial
+    * UnaryFunction0DUnsigned
+    * UnaryFunction0DVec2f
+    * UnaryFunction0DVec3f
+    * UnaryFunction0DVectorViewShape
+    * UnaryFunction0DViewShape
+* UnaryFunction1D
+    * UnaryFunction1DDouble
+    * UnaryFunction1DEdgeNature
+    * UnaryFunction1DFloat
+    * UnaryFunction1DUnsigned
+    * UnaryFunction1DVec2f
+    * UnaryFunction1DVec3f
+    * UnaryFunction1DVectorViewShape
+    * UnaryFunction1DVoid
+* UnaryPredicate0D
+* UnaryPredicate1D
+* ViewMap
+* ViewShape
+* IntegrationType
+* MediumType
+* Nature
+
+"""
+
 import typing
 import mathutils
 
@@ -84,7 +156,7 @@ class BinaryPredicate0D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter1: Interface0D, inter2: Interface0D) -> Interface0D:
+    def __call__(self, inter1: Interface0D, inter2: Interface0D) -> bool:
         """Must be overload by inherited classes. It evaluates a relation
         between two Interface0D objects.
 
@@ -115,7 +187,7 @@ class BinaryPredicate1D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter1: Interface1D, inter2: Interface1D) -> Interface1D:
+    def __call__(self, inter1: Interface1D, inter2: Interface1D) -> bool:
         """Must be overload by inherited classes. It evaluates a relation
         between two Interface1D objects.
 
@@ -250,7 +322,7 @@ class ChainingIterator:
         """
         ...
 
-    def traverse(self, it: AdjacencyIterator) -> AdjacencyIterator:
+    def traverse(self, it: 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.
@@ -275,8 +347,11 @@ class Curve:
     :type: bool
     """
 
-    segments_size: typing.Any
-    """ The number of segments in the polyline constituting the Curve."""
+    segments_size: int
+    """ The number of segments in the polyline constituting the Curve.
+
+    :type: int
+    """
 
     def __init__(self):
         """Builds a `FrsCurve` using a default constructor,
@@ -349,8 +424,11 @@ A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).
     :type: SVertex
     """
 
-    t2d: typing.Any
-    """ The 2D interpolation parameter."""
+    t2d: float
+    """ The 2D interpolation parameter.
+
+    :type: float
+    """
 
     def __init__(self):
         """Builds a CurvePoint using the default constructor, copy constructor,
@@ -372,7 +450,7 @@ A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).
         """
         ...
 
-    def __init__(self, first_vertex: SVertex, second_vertex: SVertex, t2d):
+    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`
@@ -384,10 +462,11 @@ A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.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):
+    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`
@@ -399,6 +478,7 @@ A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).
                 :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
         """
         ...
 
@@ -414,11 +494,17 @@ class CurvePointIterator:
     :type: CurvePoint
     """
 
-    t: typing.Any
-    """ The curvilinear abscissa of the current point."""
+    t: float
+    """ The curvilinear abscissa of the current point.
 
-    u: typing.Any
-    """ The point parameter at the current point in the stroke (0 <= u <= 1)."""
+    :type: float
+    """
+
+    u: float
+    """ The point parameter at the current point in the stroke (0 <= u <= 1).
+
+    :type: float
+    """
 
     def __init__(self):
         """Builds a CurvePointIterator object using either the default constructor,
@@ -436,13 +522,14 @@ class CurvePointIterator:
         """
         ...
 
-    def __init__(self, step=0.0):
+    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
         """
         ...
 
@@ -547,13 +634,19 @@ false.
     :type: bool
     """
 
-    material_index_left: typing.Any
-    """ The index of the material of the face lying on the left of the FEdge."""
+    material_index_left: int
+    """ The index of the material of the face lying on the left of the FEdge.
 
-    material_index_right: typing.Any
+    :type: int
+    """
+
+    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."""
+no material.
+
+    :type: int
+    """
 
     material_left: Material
     """ The material of the face lying on the left of the FEdge.
@@ -626,8 +719,11 @@ class FEdgeSmooth:
     :type: Material
     """
 
-    material_index: typing.Any
-    """ The index of the material of the face that this FEdge is running across."""
+    material_index: int
+    """ The index of the material of the face that this FEdge is running across.
+
+    :type: int
+    """
 
     normal: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal of the face that this FEdge is running across.
@@ -665,11 +761,17 @@ class FEdgeSmooth:
 class Id:
     """Class for representing an object Id."""
 
-    first: typing.Any
-    """ The first number constituting the Id."""
+    first: int
+    """ The first number constituting the Id.
 
-    second: typing.Any
-    """ The second number constituting the Id."""
+    :type: int
+    """
+
+    second: int
+    """ The second number constituting the Id.
+
+    :type: int
+    """
 
     def __init__(self, brother):
         """Build the Id from two numbers or another `Id` using the copy constructor.
@@ -678,11 +780,13 @@ class Id:
         """
         ...
 
-    def __init__(self, first=0, second=0):
+    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.
+        :type second: int
         """
         ...
 
@@ -727,20 +831,29 @@ class Interface0D:
     :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    projected_x: typing.Any
-    """ The X coordinate of the projected 3D point of this 0D element."""
+    projected_x: float
+    """ The X coordinate of the projected 3D point of this 0D element.
 
-    projected_y: typing.Any
-    """ The Y coordinate of the projected 3D point of this 0D element."""
+    :type: float
+    """
+
+    projected_y: float
+    """ The Y coordinate of the projected 3D point of this 0D element.
 
-    projected_z: typing.Any
-    """ The Z coordinate of the projected 3D point of this 0D element."""
+    :type: float
+    """
+
+    projected_z: float
+    """ The Z coordinate of the projected 3D point of this 0D element.
+
+    :type: float
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
-    def get_fedge(self, inter: Interface0D) -> Interface0D:
+    def get_fedge(self, inter: Interface0D) -> FEdge:
         """Returns the FEdge that lies between this 0D element and the 0D
         element given as the argument.
 
@@ -772,11 +885,17 @@ class, the .object property refers to a `StrokeVertex` object.
     :type: Interface0D
     """
 
-    t: typing.Any
-    """ The curvilinear abscissa of the current point."""
+    t: float
+    """ The curvilinear abscissa of the current point.
+
+    :type: float
+    """
+
+    u: float
+    """ The point parameter at the current point in the 1D element (0 <= u <= 1).
 
-    u: typing.Any
-    """ The point parameter at the current point in the 1D element (0 <= u <= 1)."""
+    :type: float
+    """
 
     def __init__(self, brother: Interface0DIterator):
         """Construct a nested Interface0DIterator using either the copy constructor
@@ -805,8 +924,11 @@ class Interface1D:
     :type: Id
     """
 
-    length_2d: typing.Any
-    """ The 2D length of this Interface1D."""
+    length_2d: float
+    """ The 2D length of this Interface1D.
+
+    :type: float
+    """
 
     name: str
     """ The string of the name of the 1D element.
@@ -820,14 +942,17 @@ class Interface1D:
     :type: Nature
     """
 
-    time_stamp: typing.Any
-    """ The time stamp of the 1D element, mainly used for selection."""
+    time_stamp: int
+    """ The time stamp of the 1D element, mainly used for selection.
+
+    :type: int
+    """
 
     def __init__(self):
         """Default constructor."""
         ...
 
-    def points_begin(self, t=0.0):
+    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.
@@ -835,12 +960,13 @@ class Interface1D:
 
                 :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=0.0):
+    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,
@@ -848,6 +974,7 @@ class Interface1D:
 
                 :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
         """
@@ -931,11 +1058,17 @@ class Material:
     :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    priority: typing.Any
-    """ Line color priority of the material."""
+    priority: int
+    """ Line color priority of the material.
 
-    shininess: typing.Any
-    """ Shininess coefficient of the material."""
+    :type: int
+    """
+
+    shininess: float
+    """ Shininess coefficient of the material.
+
+    :type: float
+    """
 
     specular: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the specular color of the material.
@@ -966,8 +1099,8 @@ class Material:
         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,
-        priority,
+        shininess: float,
+        priority: int,
     ):
         """Creates a `FrsMaterial` using either default constructor,
         copy constructor, or an overloaded constructor
@@ -983,7 +1116,9 @@ class Material:
                 :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
         """
         ...
 
@@ -1002,89 +1137,107 @@ class Nature:
 class Noise:
     """Class to provide Perlin noise functionalities.Undocumented, consider contributing.Undocumented, consider contributing."""
 
-    def __init__(self, seed=-1):
+    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
         """
         ...
 
-    def smoothNoise1(self, v):
+    def smoothNoise1(self, v: float) -> float:
         """Returns a smooth noise value for a 1D element.
 
         :param v: One-dimensional sample point.
+        :type v: float
         :return: A smooth noise value.
+        :rtype: float
         """
         ...
 
     def smoothNoise2(
         self, v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
-    ) -> typing.Union[typing.Sequence[float], mathutils.Vector, list]:
+    ) -> float:
         """Returns a smooth noise value for a 2D element.
 
         :param v: Two-dimensional sample point.
         :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, list]
-    ) -> typing.Union[typing.Sequence[float], mathutils.Vector, list]:
+    ) -> float:
         """Returns a smooth noise value for a 3D element.
 
         :param v: Three-dimensional sample point.
         :type v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         :return: A smooth noise value.
+        :rtype: float
         """
         ...
 
-    def turbulence1(self, v, freq, amp, oct=4):
+    def turbulence1(self, v: float, freq: float, amp: float, oct: int = 4) -> float:
         """Returns a noise value for a 1D element.
 
         :param v: One-dimensional sample point.
+        :type v: float
         :param freq: Noise frequency.
+        :type freq: float
         :param amp: Amplitude.
+        :type amp: float
         :param oct: Number of octaves.
+        :type oct: int
         :return: A noise value.
+        :rtype: float
         """
         ...
 
     def turbulence2(
         self,
         v: typing.Union[typing.Sequence[float], mathutils.Vector, list],
-        freq,
-        amp,
-        oct=4,
-    ):
+        freq: float,
+        amp: float,
+        oct: int = 4,
+    ) -> float:
         """Returns a noise value for a 2D element.
 
         :param v: Two-dimensional sample point.
         :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
         :return: A noise value.
+        :rtype: float
         """
         ...
 
     def turbulence3(
         self,
         v: typing.Union[typing.Sequence[float], mathutils.Vector, list],
-        freq,
-        amp,
-        oct=4,
-    ):
+        freq: float,
+        amp: float,
+        oct: int = 4,
+    ) -> float:
         """Returns a noise value for a 3D element.
 
         :param v: Three-dimensional sample point.
         :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
         :return: A noise value.
+        :rtype: float
         """
         ...
 
@@ -1216,54 +1369,60 @@ class Operators:
         ...
 
     @staticmethod
-    def get_chain_from_index(i):
+    def get_chain_from_index(i: int) -> Chain:
         """Returns the Chain at the index in the current set of Chains.
 
         :param i: index (0 <= i < Operators.get_chains_size()).
+        :type i: int
         :return: The Chain object.
         :rtype: Chain
         """
         ...
 
     @staticmethod
-    def get_chains_size() -> Chain:
+    def get_chains_size() -> int:
         """Returns the number of Chains.
 
         :return: The number of Chains.
+        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_stroke_from_index(i):
+    def get_stroke_from_index(i: int) -> Stroke:
         """Returns the Stroke at the index in the current set of Strokes.
 
         :param i: index (0 <= i < Operators.get_strokes_size()).
+        :type i: int
         :return: The Stroke object.
         :rtype: Stroke
         """
         ...
 
     @staticmethod
-    def get_strokes_size() -> Stroke:
+    def get_strokes_size() -> int:
         """Returns the number of Strokes.
 
         :return: The number of Strokes.
+        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_view_edges_size():
+    def get_view_edges_size() -> int:
         """Returns the number of ViewEdges.
 
         :return: The number of ViewEdges.
+        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_viewedge_from_index(i):
+    def get_viewedge_from_index(i: int) -> ViewEdge:
         """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
         :return: The ViewEdge object.
         :rtype: ViewEdge
         """
@@ -1271,7 +1430,7 @@ class Operators:
 
     @staticmethod
     def recursive_split(
-        func: UnaryFunction0DDouble, pred_1d: UnaryPredicate1D, sampling=0.0
+        func: UnaryFunction0DDouble, pred_1d: UnaryPredicate1D, sampling: float = 0.0
     ):
         """Splits the current set of chains in a recursive way. We process the
         points of each chain (with a specified sampling) to find the point
@@ -1294,6 +1453,7 @@ class Operators:
         predicates evaluation. (The chain is not actually resampled; a
         virtual point only progresses along the curve using this
         resolution.)
+                :type sampling: float
         """
         ...
 
@@ -1302,7 +1462,7 @@ class Operators:
         func: UnaryFunction0DDouble,
         pred_0d: UnaryPredicate0D,
         pred_1d: UnaryPredicate1D,
-        sampling=0.0,
+        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
@@ -1331,6 +1491,7 @@ class Operators:
         predicates evaluation. (The chain is not actually resampled; a
         virtual point only progresses along the curve using this
         resolution.)
+                :type sampling: float
         """
         ...
 
@@ -1356,7 +1517,9 @@ class Operators:
 
     @staticmethod
     def sequential_split(
-        starting_pred: UnaryPredicate0D, stopping_pred: UnaryPredicate0D, sampling=0.0
+        starting_pred: UnaryPredicate0D,
+        stopping_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)
@@ -1374,11 +1537,12 @@ class Operators:
         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=0.0):
+    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
@@ -1393,6 +1557,7 @@ class Operators:
         predicates evaluation. (The chain is not actually resampled;
         a virtual point only progresses along the curve using this
         resolution.)
+                :type sampling: float
         """
         ...
 
@@ -1502,8 +1667,11 @@ derivative of the radial curvature at this SVertex, respectively.
 has exactly one normal. In a smooth surface, an SVertex can have any
 number of normals."""
 
-    normals_size: typing.Any
-    """ The number of different normals for this SVertex."""
+    normals_size: int
+    """ The number of different normals for this SVertex.
+
+    :type: int
+    """
 
     point_2d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The projected 3D coordinates of the SVertex.
@@ -1584,11 +1752,17 @@ class SVertexIterator:
     :type: SVertex
     """
 
-    t: typing.Any
-    """ The curvilinear abscissa of the current point."""
+    t: float
+    """ The curvilinear abscissa of the current point.
 
-    u: typing.Any
-    """ The point parameter at the current point in the 1D element (0 <= u <= 1)."""
+    :type: float
+    """
+
+    u: float
+    """ The point parameter at the current point in the 1D element (0 <= u <= 1).
+
+    :type: float
+    """
 
     def __init__(self):
         """Build an SVertexIterator using either the default constructor, copy constructor,or the overloaded constructor that starts iteration from an SVertex object vertex."""
@@ -1603,7 +1777,12 @@ class SVertexIterator:
         ...
 
     def __init__(
-        self, vertex: SVertex, begin: SVertex, previous_edge: FEdge, next_edge: FEdge, t
+        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.
 
@@ -1616,6 +1795,7 @@ class SVertexIterator:
         :param next_edge: The next FEdge going out from vertex.
         :type next_edge: FEdge
         :param t: The curvilinear abscissa at vertex.
+        :type t: float
         """
         ...
 
@@ -1632,8 +1812,11 @@ class Stroke:
     :type: Id
     """
 
-    length_2d: typing.Any
-    """ The 2D length of the Stroke."""
+    length_2d: float
+    """ The 2D length of the Stroke.
+
+    :type: float
+    """
 
     medium_type: MediumType
     """ The MediumType used for this Stroke.
@@ -1641,8 +1824,11 @@ class Stroke:
     :type: MediumType
     """
 
-    texture_id: typing.Any
-    """ The ID of the texture used to simulate th marks system for this Stroke."""
+    texture_id: int
+    """ The ID of the texture used to simulate th marks system for this Stroke.
+
+    :type: int
+    """
 
     tips: bool
     """ True if this Stroke uses a texture with tips, and false otherwise.
@@ -1661,7 +1847,7 @@ class Stroke:
         """
         ...
 
-    def compute_sampling(self, n):
+    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,
@@ -1669,8 +1855,10 @@ class Stroke:
 
                 :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
         """
         ...
 
@@ -1700,7 +1888,7 @@ class Stroke:
         """
         ...
 
-    def resample(self, n):
+    def resample(self, n: int):
         """Resamples the stroke so using one of two methods with the goal
         of creating a stroke with fewer points and the same shape.
 
@@ -1708,25 +1896,28 @@ class Stroke:
         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 resample(self, sampling):
+    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 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=0.0):
+    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.
 
                 :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
         """
@@ -1741,10 +1932,11 @@ class Stroke:
         """
         ...
 
-    def stroke_vertices_size(self) -> StrokeVertexIterator:
+    def stroke_vertices_size(self) -> int:
         """Returns the number of StrokeVertex constituting the Stroke.
 
         :return: The number of stroke vertices.
+        :rtype: int
         """
         ...
 
@@ -1758,8 +1950,11 @@ class StrokeAttribute:
     Vertex.
     """
 
-    alpha: typing.Any
-    """ Alpha component of the stroke color."""
+    alpha: float
+    """ Alpha component of the stroke color.
+
+    :type: float
+    """
 
     color: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGB components of the stroke color.
@@ -1799,21 +1994,37 @@ when following the stroke.
         """
         ...
 
-    def __init__(self, red, green, blue, alpha, thickness_right, thickness_left):
+    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):
+    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.
@@ -1823,19 +2034,21 @@ when following the stroke.
                 :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:
+    def get_attribute_real(self, name: str) -> float:
         """Returns an attribute of float type.
 
         :param name: The name of the attribute.
         :type name: str
         :return: The attribute value.
+        :rtype: float
         """
         ...
 
-    def get_attribute_vec2(self, name: str) -> str:
+    def get_attribute_vec2(self, name: str) -> mathutils.Vector:
         """Returns an attribute of two-dimensional vector type.
 
         :param name: The name of the attribute.
@@ -1845,7 +2058,7 @@ when following the stroke.
         """
         ...
 
-    def get_attribute_vec3(self, name: str) -> str:
+    def get_attribute_vec3(self, name: str) -> mathutils.Vector:
         """Returns an attribute of three-dimensional vector type.
 
         :param name: The name of the attribute.
@@ -1855,7 +2068,7 @@ when following the stroke.
         """
         ...
 
-    def has_attribute_real(self, name: str) -> str:
+    def has_attribute_real(self, name: str) -> bool:
         """Checks whether the attribute name of float type is available.
 
         :param name: The name of the attribute.
@@ -1865,7 +2078,7 @@ when following the stroke.
         """
         ...
 
-    def has_attribute_vec2(self, name: str) -> str:
+    def has_attribute_vec2(self, name: str) -> bool:
         """Checks whether the attribute name of two-dimensional vector type
         is available.
 
@@ -1876,7 +2089,7 @@ when following the stroke.
         """
         ...
 
-    def has_attribute_vec3(self, name: str) -> str:
+    def has_attribute_vec3(self, name: str) -> bool:
         """Checks whether the attribute name of three-dimensional vector
         type is available.
 
@@ -1887,7 +2100,7 @@ when following the stroke.
         """
         ...
 
-    def set_attribute_real(self, name: str, value):
+    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.
@@ -1895,6 +2108,7 @@ when following the stroke.
                 :param name: The name of the attribute.
                 :type name: str
                 :param value: The attribute value.
+                :type value: float
         """
         ...
 
@@ -1967,8 +2181,11 @@ class StrokeVertex:
     :type: StrokeAttribute
     """
 
-    curvilinear_abscissa: typing.Any
-    """ Curvilinear abscissa of this StrokeVertex in the Stroke."""
+    curvilinear_abscissa: float
+    """ Curvilinear abscissa of this StrokeVertex in the Stroke.
+
+    :type: float
+    """
 
     point: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ 2D point coordinates.
@@ -1976,12 +2193,18 @@ class StrokeVertex:
     :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    stroke_length: typing.Any
+    stroke_length: float
     """ Stroke length (it is only a value retained by the StrokeVertex,
-and it won't change the real stroke length)."""
+and it won't change the real stroke length).
 
-    u: typing.Any
-    """ Curvilinear abscissa of this StrokeVertex in the Stroke."""
+    :type: float
+    """
+
+    u: float
+    """ Curvilinear abscissa of this StrokeVertex in the Stroke.
+
+    :type: float
+    """
 
     def __init__(self):
         """Builds a `StrokeVertex` using the default constructor,
@@ -2001,7 +2224,9 @@ and it won't change the real stroke length)."""
         """
         ...
 
-    def __init__(self, first_vertex: StrokeVertex, second_vertex: StrokeVertex, t3d):
+    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.
@@ -2011,6 +2236,7 @@ and it won't change the real stroke length)."""
                 :param second_vertex: The second StrokeVertex.
                 :type second_vertex: StrokeVertex
                 :param t3d: An interpolation parameter.
+                :type t3d: float
         """
         ...
 
@@ -2075,11 +2301,17 @@ For its counterpart (pointing to the first valid element), use it.is_begin.
     :type: StrokeVertex
     """
 
-    t: typing.Any
-    """ The curvilinear abscissa of the current point."""
+    t: float
+    """ The curvilinear abscissa of the current point.
+
+    :type: float
+    """
 
-    u: typing.Any
-    """ The point parameter at the current point in the stroke (0 <= u <= 1)."""
+    u: float
+    """ The point parameter at the current point in the stroke (0 <= u <= 1).
+
+    :type: float
+    """
 
     def __init__(self):
         """Creates a `StrokeVertexIterator` using either the
@@ -2164,7 +2396,7 @@ class TVertex:
         """
         ...
 
-    def get_svertex(self, fedge: FEdge) -> FEdge:
+    def get_svertex(self, fedge: FEdge) -> SVertex:
         """Returns the SVertex (among the 2) belonging to the given FEdge.
 
         :param fedge: An FEdge object.
@@ -2533,7 +2765,7 @@ class UnaryPredicate0D:
         """Default constructor."""
         ...
 
-    def __call__(self, it: Interface0DIterator) -> Interface0DIterator:
+    def __call__(self, it: Interface0DIterator) -> bool:
         """Must be overload by inherited classes.
 
                 :param it: The Interface0DIterator pointing onto the Interface0D at
@@ -2563,7 +2795,7 @@ class UnaryPredicate1D:
         """Default constructor."""
         ...
 
-    def __call__(self, inter: Interface1D) -> Interface1D:
+    def __call__(self, inter: Interface1D) -> bool:
         """Must be overload by inherited classes.
 
         :param inter: The Interface1D on which we wish to evaluate the predicate.
@@ -2579,8 +2811,11 @@ class ViewEdge:
     a set of FEdges.
     """
 
-    chaining_time_stamp: typing.Any
-    """ The time stamp of this ViewEdge."""
+    chaining_time_stamp: int
+    """ The time stamp of this ViewEdge.
+
+    :type: int
+    """
 
     first_fedge: FEdge
     """ The first FEdge that constitutes this ViewEdge.
@@ -2631,8 +2866,11 @@ belongs to. If no object is occluded, this property is set to None.
     :type: ViewShape
     """
 
-    qi: typing.Any
-    """ The quantitative invisibility."""
+    qi: int
+    """ The quantitative invisibility.
+
+    :type: int
+    """
 
     viewshape: ViewShape
     """ The ViewShape to which this ViewEdge belongs to.
@@ -2730,21 +2968,25 @@ class ViewMap:
         """Default constructor."""
         ...
 
-    def get_closest_fedge(self, x, y):
+    def get_closest_fedge(self, x: float, y: float) -> FEdge:
         """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
         :return: The FEdge nearest to the specified 2D point.
         :rtype: FEdge
         """
         ...
 
-    def get_closest_viewedge(self, x, y):
+    def get_closest_viewedge(self, x: float, y: float) -> ViewEdge:
         """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
         :return: The ViewEdge nearest to the specified 2D point.
         :rtype: ViewEdge
         """
@@ -2850,7 +3092,7 @@ class ViewVertex:
     :type: Nature
     """
 
-    def edges_begin(self) -> 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
@@ -2871,7 +3113,7 @@ class ViewVertex:
         """
         ...
 
-    def edges_iterator(self, edge: ViewEdge) -> ViewEdge:
+    def edges_iterator(self, edge: ViewEdge) -> orientedViewEdgeIterator:
         """Returns an orientedViewEdgeIterator pointing to the ViewEdge given
         as argument.