fake-bpy-module 20240327__py3-none-any.whl → 20240329__py3-none-any.whl

freestyle/types/__init__.pyi

@@ -275,11 +275,8 @@ class Curve:
     :type: bool
     """
 
-    segments_size: int
-    """ The number of segments in the polyline constituting the Curve.
-
-    :type: int
-    """
+    segments_size: typing.Any
+    """ The number of segments in the polyline constituting the Curve."""
 
     def __init__(self):
         """Builds a `FrsCurve` using a default constructor,
@@ -352,11 +349,8 @@ A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).
     :type: SVertex
     """
 
-    t2d: float
-    """ The 2D interpolation parameter.
-
-    :type: float
-    """
+    t2d: typing.Any
+    """ The 2D interpolation parameter."""
 
     def __init__(self):
         """Builds a CurvePoint using the default constructor, copy constructor,
@@ -378,7 +372,7 @@ A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).
         """
         ...
 
-    def __init__(self, first_vertex: SVertex, second_vertex: SVertex, t2d: float):
+    def __init__(self, first_vertex: SVertex, second_vertex: SVertex, 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`
@@ -390,11 +384,10 @@ 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: float):
+    def __init__(self, first_point: CurvePoint, second_point: CurvePoint, 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`
@@ -406,7 +399,6 @@ 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
         """
         ...
 
@@ -422,17 +414,11 @@ class CurvePointIterator:
     :type: CurvePoint
     """
 
-    t: float
-    """ The curvilinear abscissa of the current point.
+    t: typing.Any
+    """ The curvilinear abscissa of the current point."""
 
-    :type: float
-    """
-
-    u: float
-    """ The point parameter at the current point in the stroke (0 <= u <= 1).
-
-    :type: float
-    """
+    u: typing.Any
+    """ The point parameter at the current point in the stroke (0 <= u <= 1)."""
 
     def __init__(self):
         """Builds a CurvePointIterator object using either the default constructor,
@@ -450,14 +436,13 @@ class CurvePointIterator:
         """
         ...
 
-    def __init__(self, step: float = 0.0):
+    def __init__(self, step=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
         """
         ...
 
@@ -562,19 +547,13 @@ false.
     :type: bool
     """
 
-    material_index_left: int
-    """ The index of the material of the face lying on the left of the FEdge.
-
-    :type: int
-    """
+    material_index_left: typing.Any
+    """ The index of the material of the face lying on the left of the FEdge."""
 
-    material_index_right: int
+    material_index_right: typing.Any
     """ 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
-    """
+no material."""
 
     material_left: Material
     """ The material of the face lying on the left of the FEdge.
@@ -647,11 +626,8 @@ class FEdgeSmooth:
     :type: Material
     """
 
-    material_index: int
-    """ The index of the material of the face that this FEdge is running across.
-
-    :type: int
-    """
+    material_index: typing.Any
+    """ The index of the material of the face that this FEdge is running across."""
 
     normal: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal of the face that this FEdge is running across.
@@ -689,17 +665,11 @@ class FEdgeSmooth:
 class Id:
     """Class for representing an object Id."""
 
-    first: int
-    """ The first number constituting the Id.
+    first: typing.Any
+    """ The first number constituting the Id."""
 
-    :type: int
-    """
-
-    second: int
-    """ The second number constituting the Id.
-
-    :type: int
-    """
+    second: typing.Any
+    """ The second number constituting the Id."""
 
     def __init__(self, brother):
         """Build the Id from two numbers or another `Id` using the copy constructor.
@@ -708,13 +678,11 @@ class Id:
         """
         ...
 
-    def __init__(self, first: int = 0, second: int = 0):
+    def __init__(self, first=0, second=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
         """
         ...
 
@@ -759,23 +727,14 @@ class Interface0D:
     :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    projected_x: float
-    """ The X coordinate of the projected 3D point of this 0D element.
+    projected_x: typing.Any
+    """ The X 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_y: typing.Any
+    """ The Y 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
-    """
+    projected_z: typing.Any
+    """ The Z coordinate of the projected 3D point of this 0D element."""
 
     def __init__(self):
         """Default constructor."""
@@ -813,17 +772,11 @@ class, the .object property refers to a `StrokeVertex` object.
     :type: Interface0D
     """
 
-    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).
+    t: typing.Any
+    """ The curvilinear abscissa of the current point."""
 
-    :type: float
-    """
+    u: typing.Any
+    """ The point parameter at the current point in the 1D element (0 <= u <= 1)."""
 
     def __init__(self, brother: Interface0DIterator):
         """Construct a nested Interface0DIterator using either the copy constructor
@@ -852,11 +805,8 @@ class Interface1D:
     :type: Id
     """
 
-    length_2d: float
-    """ The 2D length of this Interface1D.
-
-    :type: float
-    """
+    length_2d: typing.Any
+    """ The 2D length of this Interface1D."""
 
     name: str
     """ The string of the name of the 1D element.
@@ -870,17 +820,14 @@ class Interface1D:
     :type: Nature
     """
 
-    time_stamp: int
-    """ The time stamp of the 1D element, mainly used for selection.
-
-    :type: int
-    """
+    time_stamp: typing.Any
+    """ The time stamp of the 1D element, mainly used for selection."""
 
     def __init__(self):
         """Default constructor."""
         ...
 
-    def points_begin(self, t: float = 0.0) -> float:
+    def points_begin(self, t=0.0):
         """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.
@@ -888,13 +835,12 @@ 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: float = 0.0) -> float:
+    def points_end(self, t=0.0):
         """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,
@@ -902,7 +848,6 @@ 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
         """
@@ -986,17 +931,11 @@ class Material:
     :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    priority: int
-    """ Line color priority of the material.
+    priority: typing.Any
+    """ Line color priority of the material."""
 
-    :type: int
-    """
-
-    shininess: float
-    """ Shininess coefficient of the material.
-
-    :type: float
-    """
+    shininess: typing.Any
+    """ Shininess coefficient of the material."""
 
     specular: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ RGBA components of the specular color of the material.
@@ -1027,8 +966,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: float,
-        priority: int,
+        shininess,
+        priority,
     ):
         """Creates a `FrsMaterial` using either default constructor,
         copy constructor, or an overloaded constructor
@@ -1044,9 +983,7 @@ 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
         """
         ...
 
@@ -1065,23 +1002,20 @@ class Nature:
 class Noise:
     """Class to provide Perlin noise functionalities.Undocumented, consider contributing.Undocumented, consider contributing."""
 
-    def __init__(self, seed: int = -1):
+    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.
 
                 :param seed: Seed for random number generation.
-                :type seed: int
         """
         ...
 
-    def smoothNoise1(self, v: float) -> float:
+    def smoothNoise1(self, v):
         """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
         """
         ...
 
@@ -1093,7 +1027,6 @@ class Noise:
         :param v: Two-dimensional sample point.
         :type v: typing.Union[typing.Sequence[float], mathutils.Vector, list]
         :return: A smooth noise value.
-        :rtype: float
         """
         ...
 
@@ -1105,67 +1038,53 @@ class Noise:
         :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: float, freq: float, amp: float, oct: int = 4) -> int:
+    def turbulence1(self, v, freq, amp, oct=4):
         """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: float,
-        amp: float,
-        oct: int = 4,
-    ) -> int:
+        freq,
+        amp,
+        oct=4,
+    ):
         """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: float,
-        amp: float,
-        oct: int = 4,
-    ) -> int:
+        freq,
+        amp,
+        oct=4,
+    ):
         """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
         """
         ...
 
@@ -1297,11 +1216,10 @@ class Operators:
         ...
 
     @staticmethod
-    def get_chain_from_index(i: int) -> int:
+    def get_chain_from_index(i):
         """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
         """
@@ -1312,16 +1230,14 @@ class Operators:
         """Returns the number of Chains.
 
         :return: The number of Chains.
-        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_stroke_from_index(i: int) -> int:
+    def get_stroke_from_index(i):
         """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
         """
@@ -1332,25 +1248,22 @@ class Operators:
         """Returns the number of Strokes.
 
         :return: The number of Strokes.
-        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_view_edges_size() -> int:
+    def get_view_edges_size():
         """Returns the number of ViewEdges.
 
         :return: The number of ViewEdges.
-        :rtype: int
         """
         ...
 
     @staticmethod
-    def get_viewedge_from_index(i: int) -> int:
+    def get_viewedge_from_index(i):
         """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
         """
@@ -1358,7 +1271,7 @@ class Operators:
 
     @staticmethod
     def recursive_split(
-        func: UnaryFunction0DDouble, pred_1d: UnaryPredicate1D, sampling: float = 0.0
+        func: UnaryFunction0DDouble, pred_1d: UnaryPredicate1D, 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
@@ -1381,7 +1294,6 @@ class Operators:
         predicates evaluation. (The chain is not actually resampled; a
         virtual point only progresses along the curve using this
         resolution.)
-                :type sampling: float
         """
         ...
 
@@ -1390,7 +1302,7 @@ class Operators:
         func: UnaryFunction0DDouble,
         pred_0d: UnaryPredicate0D,
         pred_1d: UnaryPredicate1D,
-        sampling: float = 0.0,
+        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
@@ -1419,7 +1331,6 @@ class Operators:
         predicates evaluation. (The chain is not actually resampled; a
         virtual point only progresses along the curve using this
         resolution.)
-                :type sampling: float
         """
         ...
 
@@ -1445,9 +1356,7 @@ class Operators:
 
     @staticmethod
     def sequential_split(
-        starting_pred: UnaryPredicate0D,
-        stopping_pred: UnaryPredicate0D,
-        sampling: float = 0.0,
+        starting_pred: UnaryPredicate0D, stopping_pred: UnaryPredicate0D, 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)
@@ -1465,12 +1374,11 @@ 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: float = 0.0):
+    def sequential_split(pred: UnaryPredicate0D, 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
@@ -1485,7 +1393,6 @@ class Operators:
         predicates evaluation. (The chain is not actually resampled;
         a virtual point only progresses along the curve using this
         resolution.)
-                :type sampling: float
         """
         ...
 
@@ -1595,11 +1502,8 @@ 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: int
-    """ The number of different normals for this SVertex.
-
-    :type: int
-    """
+    normals_size: typing.Any
+    """ The number of different normals for this SVertex."""
 
     point_2d: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The projected 3D coordinates of the SVertex.
@@ -1680,17 +1584,11 @@ class SVertexIterator:
     :type: SVertex
     """
 
-    t: float
-    """ The curvilinear abscissa of the current point.
+    t: typing.Any
+    """ 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).
-
-    :type: float
-    """
+    u: typing.Any
+    """ The point parameter at the current point in the 1D element (0 <= u <= 1)."""
 
     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."""
@@ -1705,12 +1603,7 @@ class SVertexIterator:
         ...
 
     def __init__(
-        self,
-        vertex: SVertex,
-        begin: SVertex,
-        previous_edge: FEdge,
-        next_edge: FEdge,
-        t: float,
+        self, vertex: SVertex, begin: SVertex, previous_edge: FEdge, next_edge: FEdge, t
     ):
         """Build an SVertexIterator using either the default constructor, copy constructor,or the overloaded constructor that starts iteration from an SVertex object vertex.
 
@@ -1723,7 +1616,6 @@ 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
         """
         ...
 
@@ -1740,11 +1632,8 @@ class Stroke:
     :type: Id
     """
 
-    length_2d: float
-    """ The 2D length of the Stroke.
-
-    :type: float
-    """
+    length_2d: typing.Any
+    """ The 2D length of the Stroke."""
 
     medium_type: MediumType
     """ The MediumType used for this Stroke.
@@ -1752,11 +1641,8 @@ class Stroke:
     :type: MediumType
     """
 
-    texture_id: int
-    """ The ID of the texture used to simulate th marks system for this Stroke.
-
-    :type: int
-    """
+    texture_id: typing.Any
+    """ The ID of the texture used to simulate th marks system for this Stroke."""
 
     tips: bool
     """ True if this Stroke uses a texture with tips, and false otherwise.
@@ -1775,7 +1661,7 @@ class Stroke:
         """
         ...
 
-    def compute_sampling(self, n: int) -> int:
+    def compute_sampling(self, n):
         """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,
@@ -1783,10 +1669,8 @@ 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
         """
         ...
 
@@ -1816,7 +1700,7 @@ class Stroke:
         """
         ...
 
-    def resample(self, n: int):
+    def resample(self, n):
         """Resamples the stroke so using one of two methods with the goal
         of creating a stroke with fewer points and the same shape.
 
@@ -1824,28 +1708,25 @@ 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: float):
+    def resample(self, sampling):
         """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: float = 0.0) -> float:
+    def stroke_vertices_begin(self, t=0.0):
         """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
         """
@@ -1864,7 +1745,6 @@ class Stroke:
         """Returns the number of StrokeVertex constituting the Stroke.
 
         :return: The number of stroke vertices.
-        :rtype: int
         """
         ...
 
@@ -1878,11 +1758,8 @@ class StrokeAttribute:
     Vertex.
     """
 
-    alpha: float
-    """ Alpha component of the stroke color.
-
-    :type: float
-    """
+    alpha: typing.Any
+    """ Alpha component of the stroke color."""
 
     color: typing.Union[typing.Sequence[float], mathutils.Color]
     """ RGB components of the stroke color.
@@ -1922,37 +1799,21 @@ when following the stroke.
         """
         ...
 
-    def __init__(
-        self,
-        red: float,
-        green: float,
-        blue: float,
-        alpha: float,
-        thickness_right: float,
-        thickness_left: float,
-    ):
+    def __init__(self, red, green, blue, alpha, thickness_right, thickness_left):
         """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
-    ):
+    def __init__(self, attribute1: StrokeAttribute, attribute2: StrokeAttribute, t):
         """Creates a `StrokeAttribute` object using either a default constructor,
         copy constructor, overloaded constructor, or and interpolation constructor
         to interpolate between two `StrokeAttribute` objects.
@@ -1962,7 +1823,6 @@ when following the stroke.
                 :param attribute2: The second StrokeAttribute object.
                 :type attribute2: StrokeAttribute
                 :param t: The interpolation parameter (0 <= t <= 1).
-                :type t: float
         """
         ...
 
@@ -1972,7 +1832,6 @@ when following the stroke.
         :param name: The name of the attribute.
         :type name: str
         :return: The attribute value.
-        :rtype: float
         """
         ...
 
@@ -2028,7 +1887,7 @@ when following the stroke.
         """
         ...
 
-    def set_attribute_real(self, name: str, value: float):
+    def set_attribute_real(self, name: str, value):
         """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.
@@ -2036,7 +1895,6 @@ when following the stroke.
                 :param name: The name of the attribute.
                 :type name: str
                 :param value: The attribute value.
-                :type value: float
         """
         ...
 
@@ -2109,11 +1967,8 @@ class StrokeVertex:
     :type: StrokeAttribute
     """
 
-    curvilinear_abscissa: float
-    """ Curvilinear abscissa of this StrokeVertex in the Stroke.
-
-    :type: float
-    """
+    curvilinear_abscissa: typing.Any
+    """ Curvilinear abscissa of this StrokeVertex in the Stroke."""
 
     point: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ 2D point coordinates.
@@ -2121,18 +1976,12 @@ class StrokeVertex:
     :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
-    stroke_length: float
+    stroke_length: typing.Any
     """ 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)."""
 
-    :type: float
-    """
-
-    u: float
-    """ Curvilinear abscissa of this StrokeVertex in the Stroke.
-
-    :type: float
-    """
+    u: typing.Any
+    """ Curvilinear abscissa of this StrokeVertex in the Stroke."""
 
     def __init__(self):
         """Builds a `StrokeVertex` using the default constructor,
@@ -2152,9 +2001,7 @@ and it won't change the real stroke length).
         """
         ...
 
-    def __init__(
-        self, first_vertex: StrokeVertex, second_vertex: StrokeVertex, t3d: float
-    ):
+    def __init__(self, first_vertex: StrokeVertex, second_vertex: StrokeVertex, t3d):
         """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.
@@ -2164,7 +2011,6 @@ 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
         """
         ...
 
@@ -2229,17 +2075,11 @@ For its counterpart (pointing to the first valid element), use it.is_begin.
     :type: StrokeVertex
     """
 
-    t: float
-    """ The curvilinear abscissa of the current point.
-
-    :type: float
-    """
+    t: typing.Any
+    """ The curvilinear abscissa of the current point."""
 
-    u: float
-    """ The point parameter at the current point in the stroke (0 <= u <= 1).
-
-    :type: float
-    """
+    u: typing.Any
+    """ The point parameter at the current point in the stroke (0 <= u <= 1)."""
 
     def __init__(self):
         """Creates a `StrokeVertexIterator` using either the
@@ -2739,11 +2579,8 @@ class ViewEdge:
     a set of FEdges.
     """
 
-    chaining_time_stamp: int
-    """ The time stamp of this ViewEdge.
-
-    :type: int
-    """
+    chaining_time_stamp: typing.Any
+    """ The time stamp of this ViewEdge."""
 
     first_fedge: FEdge
     """ The first FEdge that constitutes this ViewEdge.
@@ -2794,11 +2631,8 @@ belongs to. If no object is occluded, this property is set to None.
     :type: ViewShape
     """
 
-    qi: int
-    """ The quantitative invisibility.
-
-    :type: int
-    """
+    qi: typing.Any
+    """ The quantitative invisibility."""
 
     viewshape: ViewShape
     """ The ViewShape to which this ViewEdge belongs to.
@@ -2896,25 +2730,21 @@ class ViewMap:
         """Default constructor."""
         ...
 
-    def get_closest_fedge(self, x: float, y: float) -> float:
+    def get_closest_fedge(self, x, y):
         """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: float, y: float) -> float:
+    def get_closest_viewedge(self, x, y):
         """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
         """