fake-bpy-module 20240417__py3-none-any.whl → 20240419__py3-none-any.whl

mathutils/__init__.pyi

@@ -1,3 +1,31 @@
+"""
+This module provides access to math operations.
+
+[NOTE]
+Classes, methods and attributes that accept vectors also accept other numeric sequences,
+such as tuples, lists.
+
+The mathutils module provides the following classes:
+
+* Color,
+* Euler,
+* Matrix,
+* Quaternion,
+* Vector,
+
+mathutils.geometry.rst
+mathutils.bvhtree.rst
+mathutils.kdtree.rst
+mathutils.interpolate.rst
+mathutils.noise.rst
+
+:maxdepth: 1
+:caption: Submodules
+
+```../examples/mathutils.py```
+
+"""
+
 import typing
 from . import bvhtree
 from . import geometry
@@ -10,14 +38,23 @@ GenericType = typing.TypeVar("GenericType")
 class Color:
     """This object gives access to Colors in Blender.Most colors returned by Blender APIs are in scene linear color space, as defined by    the OpenColorIO configuration. The notable exception is user interface theming colors,    which are in sRGB color space."""
 
-    b: typing.Any
-    """ Blue color channel."""
+    b: float
+    """ Blue color channel.
 
-    g: typing.Any
-    """ Green color channel."""
+    :type: float
+    """
+
+    g: float
+    """ Green color channel.
+
+    :type: float
+    """
 
-    h: typing.Any
-    """ HSV Hue component in [0, 1]."""
+    h: float
+    """ HSV Hue component in [0, 1].
+
+    :type: float
+    """
 
     hsv: typing.Union[typing.Sequence[float], Vector]
     """ HSV Values in [0, 1].
@@ -46,16 +83,25 @@ class Color:
     owner: typing.Any
     """ The item this is wrapping or None  (read-only)."""
 
-    r: typing.Any
-    """ Red color channel."""
+    r: float
+    """ Red color channel.
 
-    s: typing.Any
-    """ HSV Saturation component in [0, 1]."""
+    :type: float
+    """
 
-    v: typing.Any
-    """ HSV Value component in [0, 1]."""
+    s: float
+    """ HSV Saturation component in [0, 1].
 
-    def copy(self):
+    :type: float
+    """
+
+    v: float
+    """ HSV Value component in [0, 1].
+
+    :type: float
+    """
+
+    def copy(self) -> Color:
         """Returns a copy of this color.
 
         :return: A copy of the color.
@@ -63,14 +109,14 @@ class Color:
         """
         ...
 
-    def freeze(self) -> Color:
+    def freeze(self):
         """Make this object immutable.After this the object can be hashed, used in dictionaries & sets.
 
         :return: An instance of this object.
         """
         ...
 
-    def from_aces_to_scene_linear(self):
+    def from_aces_to_scene_linear(self) -> Color:
         """Convert from ACES2065-1 linear to scene linear color space.
 
         :return: A color in scene linear color space.
@@ -141,9 +187,7 @@ class Color:
         """
         ...
 
-    def __add__(
-        self, other: typing.Union[typing.Sequence[float], Color]
-    ) -> typing.Union[typing.Sequence[float], Color]:
+    def __add__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
         """
 
         :param other:
@@ -153,9 +197,7 @@ class Color:
         """
         ...
 
-    def __sub__(
-        self, other: typing.Union[typing.Sequence[float], Color]
-    ) -> typing.Union[typing.Sequence[float], Color]:
+    def __sub__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
         """
 
         :param other:
@@ -165,27 +207,27 @@ class Color:
         """
         ...
 
-    def __mul__(self, other):
+    def __mul__(self, other: typing.Union[int, float]) -> Color:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __truediv__(self, other):
+    def __truediv__(self, other: typing.Union[int, float]) -> Color:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __radd__(
-        self, other: typing.Union[typing.Sequence[float], Color]
-    ) -> typing.Union[typing.Sequence[float], Color]:
+    def __radd__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
         """
 
         :param other:
@@ -195,9 +237,7 @@ class Color:
         """
         ...
 
-    def __rsub__(
-        self, other: typing.Union[typing.Sequence[float], Color]
-    ) -> typing.Union[typing.Sequence[float], Color]:
+    def __rsub__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
         """
 
         :param other:
@@ -207,27 +247,27 @@ class Color:
         """
         ...
 
-    def __rmul__(self, other):
+    def __rmul__(self, other: typing.Union[int, float]) -> Color:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __rtruediv__(self, other):
+    def __rtruediv__(self, other: typing.Union[int, float]) -> Color:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __iadd__(
-        self, other: typing.Union[typing.Sequence[float], Color]
-    ) -> typing.Union[typing.Sequence[float], Color]:
+    def __iadd__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
         """
 
         :param other:
@@ -237,9 +277,7 @@ class Color:
         """
         ...
 
-    def __isub__(
-        self, other: typing.Union[typing.Sequence[float], Color]
-    ) -> typing.Union[typing.Sequence[float], Color]:
+    def __isub__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
         """
 
         :param other:
@@ -249,19 +287,21 @@ class Color:
         """
         ...
 
-    def __imul__(self, other):
+    def __imul__(self, other: typing.Union[int, float]) -> Color:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __itruediv__(self, other):
+    def __itruediv__(self, other: typing.Union[int, float]) -> Color:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Color
         """
@@ -294,16 +334,25 @@ class Euler:
     owner: typing.Any
     """ The item this is wrapping or None  (read-only)."""
 
-    x: typing.Any
-    """ Euler axis angle in radians."""
+    x: float
+    """ Euler axis angle in radians.
 
-    y: typing.Any
-    """ Euler axis angle in radians."""
+    :type: float
+    """
+
+    y: float
+    """ Euler axis angle in radians.
+
+    :type: float
+    """
 
-    z: typing.Any
-    """ Euler axis angle in radians."""
+    z: float
+    """ Euler axis angle in radians.
 
-    def copy(self):
+    :type: float
+    """
+
+    def copy(self) -> Euler:
         """Returns a copy of this euler.
 
         :return: A copy of the euler.
@@ -311,7 +360,7 @@ class Euler:
         """
         ...
 
-    def freeze(self) -> Euler:
+    def freeze(self):
         """Make this object immutable.After this the object can be hashed, used in dictionaries & sets.
 
         :return: An instance of this object.
@@ -344,17 +393,18 @@ class Euler:
         """
         ...
 
-    def rotate_axis(self, axis: str, angle):
+    def rotate_axis(self, axis: str, angle: float):
         """Rotates the euler a certain amount and returning a unique euler rotation
         (no 720 degree pitches).
 
                 :param axis: single character in ['X, 'Y', 'Z'].
                 :type axis: str
                 :param angle: angle in radians.
+                :type angle: float
         """
         ...
 
-    def to_matrix(self):
+    def to_matrix(self) -> Matrix:
         """Return a matrix representation of the euler.
 
         :return: A 3x3 rotation matrix representation of the euler.
@@ -362,7 +412,7 @@ class Euler:
         """
         ...
 
-    def to_quaternion(self) -> Matrix:
+    def to_quaternion(self) -> Quaternion:
         """Return a quaternion representation of the euler.
 
         :return: Quaternion representation of the euler.
@@ -432,8 +482,11 @@ class Matrix:
     :type: bool
     """
 
-    median_scale: typing.Any
-    """ The average scale applied to each axis (read-only)."""
+    median_scale: float
+    """ The average scale applied to each axis (read-only).
+
+    :type: float
+    """
 
     owner: typing.Any
     """ The item this is wrapping or None  (read-only)."""
@@ -448,9 +501,7 @@ class Matrix:
     """
 
     @classmethod
-    def Diagonal(
-        cls, vector: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def Diagonal(cls, vector: typing.Union[typing.Sequence[float], Vector]) -> Matrix:
         """Create a diagonal (scaling) matrix using the values from the vector.
 
         :param vector: The vector of values for the diagonal.
@@ -461,10 +512,11 @@ class Matrix:
         ...
 
     @classmethod
-    def Identity(cls, size):
+    def Identity(cls, size: int) -> Matrix:
         """Create an identity matrix.
 
         :param size: The size of the identity matrix to construct [2, 4].
+        :type size: int
         :return: A new identity matrix.
         :rtype: Matrix
         """
@@ -492,8 +544,8 @@ class Matrix:
 
     @classmethod
     def OrthoProjection(
-        cls, axis: typing.Union[str, typing.Sequence[float], Vector], size
-    ):
+        cls, axis: typing.Union[str, typing.Sequence[float], Vector], size: int
+    ) -> Matrix:
         """Create a matrix to represent an orthographic projection.
 
                 :param axis: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
@@ -501,6 +553,7 @@ class Matrix:
         Or a vector for an arbitrary axis
                 :type axis: typing.Union[str, typing.Sequence[float], Vector]
                 :param size: The size of the projection matrix to construct [2, 4].
+                :type size: int
                 :return: A new projection matrix.
                 :rtype: Matrix
         """
@@ -508,12 +561,17 @@ class Matrix:
 
     @classmethod
     def Rotation(
-        cls, angle, size, axis: typing.Union[str, typing.Sequence[float], Vector]
-    ) -> typing.Union[str, typing.Sequence[float], Vector]:
+        cls,
+        angle: float,
+        size: int,
+        axis: typing.Union[str, typing.Sequence[float], Vector],
+    ) -> Matrix:
         """Create a matrix representing a rotation.
 
                 :param angle: The angle of rotation desired, in radians.
+                :type angle: float
                 :param size: The size of the rotation matrix to construct [2, 4].
+                :type size: int
                 :param axis: a string in ['X', 'Y', 'Z'] or a 3D Vector Object
         (optional when size is 2).
                 :type axis: typing.Union[str, typing.Sequence[float], Vector]
@@ -524,12 +582,17 @@ class Matrix:
 
     @classmethod
     def Scale(
-        cls, factor, size, axis: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+        cls,
+        factor: float,
+        size: int,
+        axis: typing.Union[typing.Sequence[float], Vector],
+    ) -> Matrix:
         """Create a matrix representing a scaling.
 
         :param factor: The factor of scaling to apply.
+        :type factor: float
         :param size: The size of the scale matrix to construct [2, 4].
+        :type size: int
         :param axis: Direction to influence scale. (optional).
         :type axis: typing.Union[typing.Sequence[float], Vector]
         :return: A new scale matrix.
@@ -538,15 +601,17 @@ class Matrix:
         ...
 
     @classmethod
-    def Shear(cls, plane: str, size, factor):
+    def Shear(cls, plane: str, size: int, factor: float) -> Matrix:
         """Create a matrix to represent an shear transformation.
 
                 :param plane: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
         where a single axis is for a 2D matrix only.
                 :type plane: str
                 :param size: The size of the shear matrix to construct [2, 4].
+                :type size: int
                 :param factor: The factor of shear to apply. For a 3 or 4 size matrix
         pass a pair of floats corresponding with the plane axis.
+                :type factor: float
                 :return: A new shear matrix.
                 :rtype: Matrix
         """
@@ -555,7 +620,7 @@ class Matrix:
     @classmethod
     def Translation(
         cls, vector: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    ) -> Matrix:
         """Create a matrix representing a translation.
 
         :param vector: The translation vector.
@@ -585,7 +650,7 @@ class Matrix:
         """
         ...
 
-    def decompose(self) -> Matrix:
+    def decompose(self) -> Quaternion:
         """Return the translation, rotation, and scale components of this matrix.
 
         :return: tuple of translation, rotation, and scale
@@ -593,10 +658,11 @@ class Matrix:
         """
         ...
 
-    def determinant(self) -> Quaternion:
+    def determinant(self) -> float:
         """Return the determinant of a matrix.`Determinant <https://en.wikipedia.org/wiki/Determinant>`__ on Wikipedia.
 
         :return: Return the determinant of a matrix.
+        :rtype: float
         """
         ...
 
@@ -628,7 +694,7 @@ class Matrix:
         """
         ...
 
-    def inverted(self, fallback: typing.Any = None) -> typing.Any:
+    def inverted(self, fallback: typing.Any = None) -> Matrix:
         """Return an inverted copy of the matrix.
 
                 :param fallback: return this when the inverse can't be calculated
@@ -649,12 +715,15 @@ class Matrix:
         """
         ...
 
-    def lerp(self, other: typing.Union[typing.Sequence[float], Matrix], factor):
+    def lerp(
+        self, other: typing.Union[typing.Sequence[float], Matrix], factor: float
+    ) -> Matrix:
         """Returns the interpolation of two matrices. Uses polar decomposition, see   "Matrix Animation and Polar Decomposition", Shoemake and Duff, 1992.
 
         :param other: value to interpolate with.
         :type other: typing.Union[typing.Sequence[float], Matrix]
         :param factor: The interpolation value in [0.0, 1.0].
+        :type factor: float
         :return: The interpolated matrix.
         :rtype: Matrix
         """
@@ -694,16 +763,7 @@ class Matrix:
         """
         ...
 
-    def to_2x2(
-        self,
-    ) -> typing.Union[
-        typing.Sequence[float],
-        Euler,
-        typing.Sequence[float],
-        Quaternion,
-        typing.Sequence[float],
-        Matrix,
-    ]:
+    def to_2x2(self) -> Matrix:
         """Return a 2x2 copy of this matrix.
 
         :return: a new matrix.
@@ -729,7 +789,7 @@ class Matrix:
 
     def to_euler(
         self, order: str, euler_compat: typing.Union[typing.Sequence[float], Euler]
-    ) -> typing.Union[typing.Sequence[float], Euler]:
+    ) -> Euler:
         """Return an Euler representation of the rotation matrix
         (3x3 or 4x4 matrix only).
 
@@ -745,7 +805,7 @@ class Matrix:
         """
         ...
 
-    def to_quaternion(self) -> Euler:
+    def to_quaternion(self) -> Quaternion:
         """Return a quaternion representation of the rotation matrix.
 
         :return: Quaternion representation of the rotation matrix.
@@ -753,7 +813,7 @@ class Matrix:
         """
         ...
 
-    def to_scale(self) -> Quaternion:
+    def to_scale(self) -> Vector:
         """Return the scale part of a 3x3 or 4x4 matrix.
 
         :return: Return the scale of a matrix.
@@ -773,7 +833,7 @@ class Matrix:
         """Set the matrix to its transpose.`Transpose <https://en.wikipedia.org/wiki/Transpose>`__ on Wikipedia."""
         ...
 
-    def transposed(self) -> Vector:
+    def transposed(self) -> Matrix:
         """Return a new, transposed matrix.
 
         :return: a transposed matrix
@@ -800,22 +860,25 @@ class Matrix:
         """
         ...
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: int) -> Vector:
         """
 
         :param key:
+        :type key: int
         :return:
         :rtype: Vector
         """
         ...
 
-    def __len__(self):
-        """ """
+    def __len__(self) -> int:
+        """
+
+        :return:
+        :rtype: int
+        """
         ...
 
-    def __add__(
-        self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    def __add__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
         """
 
         :param other:
@@ -825,9 +888,7 @@ class Matrix:
         """
         ...
 
-    def __sub__(
-        self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    def __sub__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
         """
 
         :param other:
@@ -837,10 +898,11 @@ class Matrix:
         """
         ...
 
-    def __mul__(self, other):
+    def __mul__(self, other: typing.Union[int, float]) -> Matrix:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Matrix
         """
@@ -851,7 +913,7 @@ class Matrix:
         other: typing.Union[
             typing.Sequence[float], Matrix, typing.Sequence[float], Vector
         ],
-    ) -> typing.Union[typing.Sequence[float], Matrix, typing.Sequence[float], Vector]:
+    ) -> typing.Union[Matrix, Vector]:
         """
 
         :param other:
@@ -861,9 +923,7 @@ class Matrix:
         """
         ...
 
-    def __radd__(
-        self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    def __radd__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
         """
 
         :param other:
@@ -873,9 +933,7 @@ class Matrix:
         """
         ...
 
-    def __rsub__(
-        self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    def __rsub__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
         """
 
         :param other:
@@ -885,10 +943,11 @@ class Matrix:
         """
         ...
 
-    def __rmul__(self, other):
+    def __rmul__(self, other: typing.Union[int, float]) -> Matrix:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Matrix
         """
@@ -896,7 +955,7 @@ class Matrix:
 
     def __rmatmul__(
         self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    ) -> Matrix:
         """
 
         :param other:
@@ -906,10 +965,11 @@ class Matrix:
         """
         ...
 
-    def __imul__(self, other):
+    def __imul__(self, other: typing.Union[int, float]) -> Matrix:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Matrix
         """
@@ -917,7 +977,7 @@ class Matrix:
 
     def __imatmul__(
         self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    ) -> Matrix:
         """
 
         :param other:
@@ -930,8 +990,11 @@ class Matrix:
 class Quaternion:
     """This object gives access to Quaternions in Blender.The constructor takes arguments in various forms:"""
 
-    angle: typing.Any
-    """ Angle of the quaternion."""
+    angle: float
+    """ Angle of the quaternion.
+
+    :type: float
+    """
 
     axis: typing.Union[typing.Sequence[float], Vector]
     """ Quaternion axis as a vector.
@@ -957,29 +1020,44 @@ class Quaternion:
     :type: bool
     """
 
-    magnitude: typing.Any
-    """ Size of the quaternion (read-only)."""
+    magnitude: float
+    """ Size of the quaternion (read-only).
+
+    :type: float
+    """
 
     owner: typing.Any
     """ The item this is wrapping or None  (read-only)."""
 
-    w: typing.Any
-    """ Quaternion axis value."""
+    w: float
+    """ Quaternion axis value.
 
-    x: typing.Any
-    """ Quaternion axis value."""
+    :type: float
+    """
 
-    y: typing.Any
-    """ Quaternion axis value."""
+    x: float
+    """ Quaternion axis value.
 
-    z: typing.Any
-    """ Quaternion axis value."""
+    :type: float
+    """
+
+    y: float
+    """ Quaternion axis value.
+
+    :type: float
+    """
+
+    z: float
+    """ Quaternion axis value.
+
+    :type: float
+    """
 
     def conjugate(self):
         """Set the quaternion to its conjugate (negate x, y, z)."""
         ...
 
-    def conjugated(self):
+    def conjugated(self) -> Quaternion:
         """Return a new conjugated quaternion.
 
         :return: a new quaternion.
@@ -997,7 +1075,7 @@ class Quaternion:
 
     def cross(
         self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+    ) -> Quaternion:
         """Return the cross product of this quaternion and another.
 
         :param other: The other quaternion to perform the cross product with.
@@ -1007,14 +1085,13 @@ class Quaternion:
         """
         ...
 
-    def dot(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+    def dot(self, other: typing.Union[typing.Sequence[float], Quaternion]) -> float:
         """Return the dot product of this quaternion and another.
 
         :param other: The other quaternion to perform the dot product with.
         :type other: typing.Union[typing.Sequence[float], Quaternion]
         :return: The dot product.
+        :rtype: float
         """
         ...
 
@@ -1033,7 +1110,7 @@ class Quaternion:
         """Set the quaternion to its inverse."""
         ...
 
-    def inverted(self):
+    def inverted(self) -> Quaternion:
         """Return a new, inverted quaternion.
 
         :return: the inverted value.
@@ -1057,7 +1134,7 @@ class Quaternion:
         """Normalize the quaternion."""
         ...
 
-    def normalized(self):
+    def normalized(self) -> Quaternion:
         """Return a new normalized quaternion.
 
         :return: a normalized copy.
@@ -1085,7 +1162,7 @@ class Quaternion:
 
     def rotation_difference(
         self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+    ) -> Quaternion:
         """Returns a quaternion representing the rotational difference.
 
         :param other: second quaternion.
@@ -1095,28 +1172,31 @@ class Quaternion:
         """
         ...
 
-    def slerp(self, other: typing.Union[typing.Sequence[float], Quaternion], factor):
+    def slerp(
+        self, other: typing.Union[typing.Sequence[float], Quaternion], factor: float
+    ) -> Quaternion:
         """Returns the interpolation of two quaternions.
 
         :param other: value to interpolate with.
         :type other: typing.Union[typing.Sequence[float], Quaternion]
         :param factor: The interpolation value in [0.0, 1.0].
+        :type factor: float
         :return: The interpolated rotation.
         :rtype: Quaternion
         """
         ...
 
-    def to_axis_angle(self) -> Quaternion:
+    def to_axis_angle(self) -> typing.Tuple[Vector, float]:
         """Return the axis, angle representation of the quaternion.
 
         :return: axis, angle.
-        :rtype: typing.Tuple[Vector]
+        :rtype: typing.Tuple[Vector, float]
         """
         ...
 
     def to_euler(
         self, order: str, euler_compat: typing.Union[typing.Sequence[float], Euler]
-    ) -> typing.Union[typing.Sequence[float], Euler]:
+    ) -> Euler:
         """Return Euler representation of the quaternion.
 
                 :param order: Optional rotation order argument in
@@ -1131,7 +1211,7 @@ class Quaternion:
         """
         ...
 
-    def to_exponential_map(self) -> Euler:
+    def to_exponential_map(self):
         """Return the exponential map representation of the quaternion.This representation consist of the rotation axis multiplied by the rotation angle.
         Such a representation is useful for interpolation between multiple orientations.To convert back to a quaternion, pass it to the `Quaternion` constructor.
 
@@ -1139,7 +1219,7 @@ class Quaternion:
         """
         ...
 
-    def to_matrix(self):
+    def to_matrix(self) -> Matrix:
         """Return a matrix representation of the quaternion.
 
         :return: A 3x3 rotation matrix representation of the quaternion.
@@ -1147,13 +1227,13 @@ class Quaternion:
         """
         ...
 
-    def to_swing_twist(self, axis):
+    def to_swing_twist(self, axis) -> typing.Tuple[Quaternion, float]:
         """Split the rotation into a swing quaternion with the specified
         axis fixed at zero, and the remaining twist rotation angle.
 
                 :param axis: twist axis as a string in ['X', 'Y', 'Z']
                 :return: swing, twist angle.
-                :rtype: typing.Tuple[Quaternion]
+                :rtype: typing.Tuple[Quaternion, float]
         """
         ...
 
@@ -1164,28 +1244,39 @@ class Quaternion:
         """
         ...
 
-    def __len__(self):
-        """ """
+    def __len__(self) -> int:
+        """
+
+        :return:
+        :rtype: int
+        """
         ...
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: int) -> float:
         """
 
         :param key:
+        :type key: int
+        :return:
+        :rtype: float
         """
         ...
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: int, value: float) -> float:
         """
 
         :param key:
+        :type key: int
         :param value:
+        :type value: float
+        :return:
+        :rtype: float
         """
         ...
 
     def __add__(
         self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+    ) -> Quaternion:
         """
 
         :param other:
@@ -1197,7 +1288,7 @@ class Quaternion:
 
     def __sub__(
         self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+    ) -> Quaternion:
         """
 
         :param other:
@@ -1208,12 +1299,12 @@ class Quaternion:
         ...
 
     def __mul__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+        self, other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Union[int, float, typing.Sequence[float], Quaternion]
         :return:
         :rtype: Quaternion
         """
@@ -1224,9 +1315,7 @@ class Quaternion:
         other: typing.Union[
             typing.Sequence[float], Vector, typing.Sequence[float], Quaternion
         ],
-    ) -> typing.Union[
-        typing.Sequence[float], Vector, typing.Sequence[float], Quaternion
-    ]:
+    ) -> typing.Union[Vector, Quaternion]:
         """
 
         :param other:
@@ -1238,7 +1327,7 @@ class Quaternion:
 
     def __radd__(
         self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+    ) -> Quaternion:
         """
 
         :param other:
@@ -1250,7 +1339,7 @@ class Quaternion:
 
     def __rsub__(
         self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+    ) -> Quaternion:
         """
 
         :param other:
@@ -1261,12 +1350,12 @@ class Quaternion:
         ...
 
     def __rmul__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+        self, other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Union[int, float, typing.Sequence[float], Quaternion]
         :return:
         :rtype: Quaternion
         """
@@ -1274,7 +1363,7 @@ class Quaternion:
 
     def __rmatmul__(
         self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    ) -> Vector:
         """
 
         :param other:
@@ -1285,12 +1374,12 @@ class Quaternion:
         ...
 
     def __imul__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> typing.Union[typing.Sequence[float], Quaternion]:
+        self, other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Union[int, float, typing.Sequence[float], Quaternion]
         :return:
         :rtype: Quaternion
         """
@@ -1298,7 +1387,7 @@ class Quaternion:
 
     def __imatmul__(
         self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    ) -> Vector:
         """
 
         :param other:
@@ -1329,20 +1418,32 @@ class Vector:
     :type: bool
     """
 
-    length: typing.Any
-    """ Vector Length."""
+    length: float
+    """ Vector Length.
+
+    :type: float
+    """
+
+    length_squared: float
+    """ Vector length squared (v.dot(v)).
 
-    length_squared: typing.Any
-    """ Vector length squared (v.dot(v))."""
+    :type: float
+    """
 
-    magnitude: typing.Any
-    """ Vector Length."""
+    magnitude: float
+    """ Vector Length.
+
+    :type: float
+    """
 
     owner: typing.Any
     """ The item this is wrapping or None  (read-only)."""
 
-    w: typing.Any
-    """ Vector W axis (4D Vectors only)."""
+    w: float
+    """ Vector W axis (4D Vectors only).
+
+    :type: float
+    """
 
     ww: typing.Any
     """ Undocumented, consider contributing."""
@@ -1596,8 +1697,11 @@ class Vector:
     wzzz: typing.Any
     """ Undocumented, consider contributing."""
 
-    x: typing.Any
-    """ Vector X axis."""
+    x: float
+    """ Vector X axis.
+
+    :type: float
+    """
 
     xw: typing.Any
     """ Undocumented, consider contributing."""
@@ -1851,8 +1955,11 @@ class Vector:
     xzzz: typing.Any
     """ Undocumented, consider contributing."""
 
-    y: typing.Any
-    """ Vector Y axis."""
+    y: float
+    """ Vector Y axis.
+
+    :type: float
+    """
 
     yw: typing.Any
     """ Undocumented, consider contributing."""
@@ -2106,8 +2213,11 @@ class Vector:
     yzzz: typing.Any
     """ Undocumented, consider contributing."""
 
-    z: typing.Any
-    """ Vector Z axis (3D Vectors only)."""
+    z: float
+    """ Vector Z axis (3D Vectors only).
+
+    :type: float
+    """
 
     zw: typing.Any
     """ Undocumented, consider contributing."""
@@ -2362,40 +2472,49 @@ class Vector:
     """ Undocumented, consider contributing."""
 
     @classmethod
-    def Fill(cls, size, fill=0.0):
+    def Fill(cls, size: int, fill: float = 0.0):
         """Create a vector of length size with all values set to fill.
 
         :param size: The length of the vector to be created.
+        :type size: int
         :param fill: The value used to fill the vector.
+        :type fill: float
         """
         ...
 
     @classmethod
-    def Linspace(cls, start, stop, size):
+    def Linspace(cls, start: int, stop: int, size: int):
         """Create a vector of the specified size which is filled with linearly spaced values between start and stop values.
 
         :param start: The start of the range used to fill the vector.
+        :type start: int
         :param stop: The end of the range used to fill the vector.
+        :type stop: int
         :param size: The size of the vector to be created.
+        :type size: int
         """
         ...
 
     @classmethod
-    def Range(cls, start, stop, step=1):
+    def Range(cls, start: int, stop: int, step: int = 1):
         """Create a filled with a range of values.
 
         :param start: The start of the range used to fill the vector.
+        :type start: int
         :param stop: The end of the range used to fill the vector.
+        :type stop: int
         :param step: The step between successive values in the vector.
+        :type step: int
         """
         ...
 
     @classmethod
-    def Repeat(cls, vector, size):
+    def Repeat(cls, vector, size: int):
         """Create a vector by repeating the values in vector until the required size is reached.
 
         :param vector:
         :param size: The size of the vector to be created.
+        :type size: int
         """
         ...
 
@@ -2403,7 +2522,7 @@ class Vector:
         self,
         other: typing.Union[typing.Sequence[float], Vector],
         fallback: typing.Any = None,
-    ) -> typing.Any:
+    ) -> float:
         """Return the angle between two vectors.
 
                 :param other: another vector to compare the angle with
@@ -2412,12 +2531,13 @@ class Vector:
         (instead of raising a `ValueError`).
                 :type fallback: typing.Any
                 :return: angle in radians or fallback when given
+                :rtype: float
         """
         ...
 
     def angle_signed(
         self, other: typing.Union[typing.Sequence[float], Vector], fallback: typing.Any
-    ) -> typing.Any:
+    ) -> float:
         """Return the signed angle between two 2D vectors (clockwise is positive).
 
                 :param other: another vector to compare the angle with
@@ -2426,10 +2546,11 @@ class Vector:
         (instead of raising a `ValueError`).
                 :type fallback: typing.Any
                 :return: angle in radians or fallback when given
+                :rtype: float
         """
         ...
 
-    def copy(self):
+    def copy(self) -> Vector:
         """Returns a copy of this vector.
 
         :return: A copy of the vector.
@@ -2437,9 +2558,7 @@ class Vector:
         """
         ...
 
-    def cross(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def cross(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """Return the cross product of this vector and another.
 
         :param other: The other vector to perform the cross product with.
@@ -2449,14 +2568,13 @@ class Vector:
         """
         ...
 
-    def dot(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def dot(self, other: typing.Union[typing.Sequence[float], Vector]) -> float:
         """Return the dot product of this vector and another.
 
         :param other: The other vector to perform the dot product with.
         :type other: typing.Union[typing.Sequence[float], Vector]
         :return: The dot product.
+        :rtype: float
         """
         ...
 
@@ -2467,12 +2585,15 @@ class Vector:
         """
         ...
 
-    def lerp(self, other: typing.Union[typing.Sequence[float], Vector], factor):
+    def lerp(
+        self, other: typing.Union[typing.Sequence[float], Vector], factor: float
+    ) -> Vector:
         """Returns the interpolation of two vectors.
 
         :param other: value to interpolate with.
         :type other: typing.Union[typing.Sequence[float], Vector]
         :param factor: The interpolation value in [0.0, 1.0].
+        :type factor: float
         :return: The interpolated vector.
         :rtype: Vector
         """
@@ -2502,9 +2623,7 @@ class Vector:
         """
         ...
 
-    def project(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def project(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """Return the projection of this vector onto the other.
 
         :param other: second vector.
@@ -2514,9 +2633,7 @@ class Vector:
         """
         ...
 
-    def reflect(
-        self, mirror: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def reflect(self, mirror: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """Return the reflection vector from the mirror argument.
 
         :param mirror: This vector could be a normal from the reflecting surface.
@@ -2545,7 +2662,7 @@ class Vector:
         """Resize the vector to 4D (x, y, z, w)."""
         ...
 
-    def resized(self, size=3):
+    def resized(self, size=3) -> Vector:
         """Return a resized copy of the vector with size number of elements.
 
         :param size:
@@ -2574,7 +2691,7 @@ class Vector:
 
     def rotation_difference(
         self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    ) -> Quaternion:
         """Returns a quaternion representing the rotational difference between this
         vector and another.
 
@@ -2588,14 +2705,15 @@ class Vector:
     def slerp(
         self,
         other: typing.Union[typing.Sequence[float], Vector],
-        factor,
+        factor: float,
         fallback: typing.Any = None,
-    ) -> typing.Any:
+    ) -> Vector:
         """Returns the interpolation of two non-zero vectors (spherical coordinates).
 
                 :param other: value to interpolate with.
                 :type other: typing.Union[typing.Sequence[float], Vector]
                 :param factor: The interpolation value typically in [0.0, 1.0].
+                :type factor: float
                 :param fallback: return this when the vector can't be calculated (zero length vector or direct opposites),
         (instead of raising a `ValueError`).
                 :type fallback: typing.Any
@@ -2628,7 +2746,7 @@ class Vector:
         """
         ...
 
-    def to_track_quat(self, track: str, up: str) -> str:
+    def to_track_quat(self, track: str, up: str) -> Quaternion:
         """Return a quaternion rotation from the vector and the track and up axis.
 
         :param track: Track axis in ['X', 'Y', 'Z', '-X', '-Y', '-Z'].
@@ -2640,10 +2758,11 @@ class Vector:
         """
         ...
 
-    def to_tuple(self, precision=-1):
+    def to_tuple(self, precision: int = -1) -> typing.Tuple:
         """Return this vector as a tuple with.
 
         :param precision: The number to round the value to in [-1, 21].
+        :type precision: int
         :return: the values of the vector rounded by precision
         :rtype: typing.Tuple
         """
@@ -2660,26 +2779,37 @@ class Vector:
         """
         ...
 
-    def __len__(self):
-        """ """
+    def __len__(self) -> int:
+        """
+
+        :return:
+        :rtype: int
+        """
         ...
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: int) -> float:
         """
 
         :param key:
+        :type key: int
+        :return:
+        :rtype: float
         """
         ...
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: int, value: float) -> float:
         """
 
         :param key:
+        :type key: int
         :param value:
+        :type value: float
+        :return:
+        :rtype: float
         """
         ...
 
-    def __neg__(self):
+    def __neg__(self) -> Vector:
         """
 
         :return:
@@ -2687,9 +2817,7 @@ class Vector:
         """
         ...
 
-    def __add__(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def __add__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """
 
         :param other:
@@ -2699,9 +2827,7 @@ class Vector:
         """
         ...
 
-    def __sub__(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def __sub__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """
 
         :param other:
@@ -2711,27 +2837,27 @@ class Vector:
         """
         ...
 
-    def __mul__(self, other):
+    def __mul__(self, other: typing.Union[int, float]) -> Vector:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __truediv__(self, other):
+    def __truediv__(self, other: typing.Union[int, float]) -> Vector:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __matmul__(
-        self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    def __matmul__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Vector:
         """
 
         :param other:
@@ -2741,9 +2867,7 @@ class Vector:
         """
         ...
 
-    def __radd__(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def __radd__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """
 
         :param other:
@@ -2753,9 +2877,7 @@ class Vector:
         """
         ...
 
-    def __rsub__(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def __rsub__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """
 
         :param other:
@@ -2765,19 +2887,21 @@ class Vector:
         """
         ...
 
-    def __rmul__(self, other):
+    def __rmul__(self, other: typing.Union[int, float]) -> Vector:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rtruediv__(self, other):
+    def __rtruediv__(self, other: typing.Union[int, float]) -> Vector:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Vector
         """
@@ -2785,7 +2909,7 @@ class Vector:
 
     def __rmatmul__(
         self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    ) -> Vector:
         """
 
         :param other:
@@ -2795,9 +2919,7 @@ class Vector:
         """
         ...
 
-    def __iadd__(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def __iadd__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """
 
         :param other:
@@ -2807,9 +2929,7 @@ class Vector:
         """
         ...
 
-    def __isub__(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> typing.Union[typing.Sequence[float], Vector]:
+    def __isub__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
         """
 
         :param other:
@@ -2819,19 +2939,21 @@ class Vector:
         """
         ...
 
-    def __imul__(self, other):
+    def __imul__(self, other: typing.Union[int, float]) -> Vector:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __itruediv__(self, other):
+    def __itruediv__(self, other: typing.Union[int, float]) -> Vector:
         """
 
         :param other:
+        :type other: typing.Union[int, float]
         :return:
         :rtype: Vector
         """
@@ -2839,7 +2961,7 @@ class Vector:
 
     def __imatmul__(
         self, other: typing.Union[typing.Sequence[float], Matrix]
-    ) -> typing.Union[typing.Sequence[float], Matrix]:
+    ) -> Vector:
         """
 
         :param other: