fake-bpy-module 20240601__py3-none-any.whl → 20240605__py3-none-any.whl

mathutils/__init__.pyi

@@ -58,10 +58,10 @@ class Color:
     :type: float
     """
 
-    hsv: collections.abc.Sequence[float] | Vector
+    hsv: Vector | collections.abc.Sequence[float]
     """ HSV Values in [0, 1].
 
-    :type: collections.abc.Sequence[float] | Vector
+    :type: Vector | collections.abc.Sequence[float]
     """
 
     is_frozen: bool
@@ -190,121 +190,140 @@ class Color:
         """
         ...
 
-    def __add__(self, other: collections.abc.Sequence[float] | Color) -> Color:
+    def __get__(self, instance, owner) -> Color:
+        """
+
+        :param instance:
+        :param owner:
+        :return:
+        :rtype: Color
+        """
+        ...
+
+    def __set__(self, instance, value: Color | collections.abc.Sequence[float]):
+        """
+
+        :param instance:
+        :param value:
+        :type value: Color | collections.abc.Sequence[float]
+        """
+        ...
+
+    def __add__(self, other: Color | collections.abc.Sequence[float]) -> Color:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Color
+        :type other: Color | collections.abc.Sequence[float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __sub__(self, other: collections.abc.Sequence[float] | Color) -> Color:
+    def __sub__(self, other: Color | collections.abc.Sequence[float]) -> Color:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Color
+        :type other: Color | collections.abc.Sequence[float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __mul__(self, other: int | float) -> Color:
+    def __mul__(self, other: float | int) -> Color:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Color
         """
         ...
 
-    def __truediv__(self, other: int | float) -> Color:
+    def __truediv__(self, other: float | int) -> Color:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Color
         """
         ...
 
-    def __radd__(self, other: collections.abc.Sequence[float] | Color) -> Color:
+    def __radd__(self, other: Color | collections.abc.Sequence[float]) -> Color:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Color
+        :type other: Color | collections.abc.Sequence[float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __rsub__(self, other: collections.abc.Sequence[float] | Color) -> Color:
+    def __rsub__(self, other: Color | collections.abc.Sequence[float]) -> Color:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Color
+        :type other: Color | collections.abc.Sequence[float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __rmul__(self, other: int | float) -> Color:
+    def __rmul__(self, other: float | int) -> Color:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Color
         """
         ...
 
-    def __rtruediv__(self, other: int | float) -> Color:
+    def __rtruediv__(self, other: float | int) -> Color:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Color
         """
         ...
 
-    def __iadd__(self, other: collections.abc.Sequence[float] | Color) -> Color:
+    def __iadd__(self, other: Color | collections.abc.Sequence[float]) -> Color:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Color
+        :type other: Color | collections.abc.Sequence[float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __isub__(self, other: collections.abc.Sequence[float] | Color) -> Color:
+    def __isub__(self, other: Color | collections.abc.Sequence[float]) -> Color:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Color
+        :type other: Color | collections.abc.Sequence[float]
         :return:
         :rtype: Color
         """
         ...
 
-    def __imul__(self, other: int | float) -> Color:
+    def __imul__(self, other: float | int) -> Color:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Color
         """
         ...
 
-    def __itruediv__(self, other: int | float) -> Color:
+    def __itruediv__(self, other: float | int) -> Color:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Color
         """
@@ -391,17 +410,16 @@ class Euler:
 
     def rotate(
         self,
-        other: collections.abc.Sequence[float]
-        | Euler
-        | collections.abc.Sequence[float]
+        other: Euler
+        | Matrix
         | Quaternion
-        | collections.abc.Sequence[float]
-        | Matrix,
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float],
     ):
         """Rotates the euler by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
+        :type other: Euler | Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         """
         ...
 
@@ -444,6 +462,25 @@ class Euler:
         """
         ...
 
+    def __get__(self, instance, owner) -> Euler:
+        """
+
+        :param instance:
+        :param owner:
+        :return:
+        :rtype: Euler
+        """
+        ...
+
+    def __set__(self, instance, value: Euler | collections.abc.Sequence[float]):
+        """
+
+        :param instance:
+        :param value:
+        :type value: Euler | collections.abc.Sequence[float]
+        """
+        ...
+
     def __getitem__(self, key: int) -> float:
         """
 
@@ -523,11 +560,11 @@ class Matrix:
     """
 
     @classmethod
-    def Diagonal(cls, vector: collections.abc.Sequence[float] | Vector) -> Matrix:
+    def Diagonal(cls, vector: Vector | collections.abc.Sequence[float]) -> Matrix:
         """Create a diagonal (scaling) matrix using the values from the vector.
 
         :param vector: The vector of values for the diagonal.
-        :type vector: collections.abc.Sequence[float] | Vector
+        :type vector: Vector | collections.abc.Sequence[float]
         :return: A diagonal matrix.
         :rtype: Matrix
         """
@@ -547,23 +584,19 @@ class Matrix:
     @classmethod
     def LocRotScale(
         cls,
-        location: collections.abc.Sequence[float] | Vector | None,
-        rotation: collections.abc.Sequence[float]
-        | Quaternion
-        | collections.abc.Sequence[float]
-        | Euler
-        | None,
-        scale: collections.abc.Sequence[float] | Vector | None,
+        location: Vector | collections.abc.Sequence[float] | None,
+        rotation: Euler | Quaternion | collections.abc.Sequence[float] | None,
+        scale: Vector | collections.abc.Sequence[float] | None,
     ) -> Matrix:
         """Create a matrix combining translation, rotation and scale,
         acting as the inverse of the decompose() method.Any of the inputs may be replaced with None if not needed.
 
                 :param location: The translation component.
-                :type location: collections.abc.Sequence[float] | Vector | None
+                :type location: Vector | collections.abc.Sequence[float] | None
                 :param rotation: The rotation component.
-                :type rotation: collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Euler | None
+                :type rotation: Euler | Quaternion | collections.abc.Sequence[float] | None
                 :param scale: The scale component.
-                :type scale: collections.abc.Sequence[float] | Vector | None
+                :type scale: Vector | collections.abc.Sequence[float] | None
                 :return: Combined transformation matrix.
                 :rtype: Matrix
         """
@@ -571,14 +604,14 @@ class Matrix:
 
     @classmethod
     def OrthoProjection(
-        cls, axis: str | collections.abc.Sequence[float] | Vector, size: int
+        cls, axis: Vector | collections.abc.Sequence[float] | str, size: int
     ) -> Matrix:
         """Create a matrix to represent an orthographic projection.
 
                 :param axis: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
         where a single axis is for a 2D matrix.
         Or a vector for an arbitrary axis
-                :type axis: str | collections.abc.Sequence[float] | Vector
+                :type axis: Vector | collections.abc.Sequence[float] | str
                 :param size: The size of the projection matrix to construct [2, 4].
                 :type size: int
                 :return: A new projection matrix.
@@ -591,7 +624,7 @@ class Matrix:
         cls,
         angle: float,
         size: int,
-        axis: str | collections.abc.Sequence[float] | Vector | None,
+        axis: Vector | collections.abc.Sequence[float] | str | None,
     ) -> Matrix:
         """Create a matrix representing a rotation.
 
@@ -601,7 +634,7 @@ class Matrix:
                 :type size: int
                 :param axis: a string in ['X', 'Y', 'Z'] or a 3D Vector Object
         (optional when size is 2).
-                :type axis: str | collections.abc.Sequence[float] | Vector | None
+                :type axis: Vector | collections.abc.Sequence[float] | str | None
                 :return: A new rotation matrix.
                 :rtype: Matrix
         """
@@ -612,7 +645,7 @@ class Matrix:
         cls,
         factor: float,
         size: int,
-        axis: collections.abc.Sequence[float] | Vector | None,
+        axis: Vector | collections.abc.Sequence[float] | None,
     ) -> Matrix:
         """Create a matrix representing a scaling.
 
@@ -621,7 +654,7 @@ class Matrix:
         :param size: The size of the scale matrix to construct [2, 4].
         :type size: int
         :param axis: Direction to influence scale. (optional).
-        :type axis: collections.abc.Sequence[float] | Vector | None
+        :type axis: Vector | collections.abc.Sequence[float] | None
         :return: A new scale matrix.
         :rtype: Matrix
         """
@@ -645,11 +678,11 @@ class Matrix:
         ...
 
     @classmethod
-    def Translation(cls, vector: collections.abc.Sequence[float] | Vector) -> Matrix:
+    def Translation(cls, vector: Vector | collections.abc.Sequence[float]) -> Matrix:
         """Create a matrix representing a translation.
 
         :param vector: The translation vector.
-        :type vector: collections.abc.Sequence[float] | Vector
+        :type vector: Vector | collections.abc.Sequence[float]
         :return: An identity matrix with a translation.
         :rtype: Matrix
         """
@@ -703,12 +736,16 @@ class Matrix:
         """Set the matrix to the identity matrix.`Identity matrix <https://en.wikipedia.org/wiki/Identity_matrix>`__ on Wikipedia."""
         ...
 
-    def invert(self, fallback: collections.abc.Sequence[float] | Matrix = None):
+    def invert(
+        self,
+        fallback: Matrix
+        | collections.abc.Sequence[collections.abc.Sequence[float]] = None,
+    ):
         """Set the matrix to its inverse.`Inverse matrix <https://en.wikipedia.org/wiki/Inverse_matrix>`__ on Wikipedia.
 
                 :param fallback: Set the matrix to this value when the inverse cannot be calculated
         (instead of raising a `ValueError` exception).
-                :type fallback: collections.abc.Sequence[float] | Matrix
+                :type fallback: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         """
         ...
 
@@ -742,12 +779,14 @@ class Matrix:
         ...
 
     def lerp(
-        self, other: collections.abc.Sequence[float] | Matrix, factor: float
+        self,
+        other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]],
+        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: collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated matrix.
@@ -773,17 +812,16 @@ class Matrix:
 
     def rotate(
         self,
-        other: collections.abc.Sequence[float]
-        | Euler
-        | collections.abc.Sequence[float]
+        other: Euler
+        | Matrix
         | Quaternion
-        | collections.abc.Sequence[float]
-        | Matrix,
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float],
     ):
         """Rotates the matrix by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
+        :type other: Euler | Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         """
         ...
 
@@ -814,7 +852,7 @@ class Matrix:
     def to_euler(
         self,
         order: str | None,
-        euler_compat: collections.abc.Sequence[float] | Euler | None,
+        euler_compat: Euler | collections.abc.Sequence[float] | None,
     ) -> Euler:
         """Return an Euler representation of the rotation matrix
         (3x3 or 4x4 matrix only).
@@ -825,7 +863,7 @@ class Matrix:
                 :param euler_compat: Optional euler argument the new euler will be made
         compatible with (no axis flipping between them).
         Useful for converting a series of matrices to animation curves.
-                :type euler_compat: collections.abc.Sequence[float] | Euler | None
+                :type euler_compat: Euler | collections.abc.Sequence[float] | None
                 :return: Euler representation of the matrix.
                 :rtype: Euler
         """
@@ -886,6 +924,29 @@ class Matrix:
         """
         ...
 
+    def __get__(self, instance, owner) -> Matrix:
+        """
+
+        :param instance:
+        :param owner:
+        :return:
+        :rtype: Matrix
+        """
+        ...
+
+    def __set__(
+        self,
+        instance,
+        value: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]],
+    ):
+        """
+
+        :param instance:
+        :param value:
+        :type value: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
+        """
+        ...
+
     def __getitem__(self, key: int) -> Vector:
         """
 
@@ -904,53 +965,59 @@ class Matrix:
         """
         ...
 
-    def __add__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
+    def __add__(
+        self, other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
+    ) -> Matrix:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __sub__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
+    def __sub__(
+        self, other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
+    ) -> Matrix:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __mul__(self, other: int | float) -> Matrix:
+    def __mul__(self, other: float | int) -> Matrix:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Matrix
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
+    def __matmul__(
+        self, other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
+    ) -> Matrix:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         :return:
         :rtype: Matrix
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __matmul__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
@@ -958,55 +1025,59 @@ class Matrix:
 
     def __matmul__(
         self,
-        other: collections.abc.Sequence[float]
-        | Matrix
-        | collections.abc.Sequence[float]
-        | Vector,
+        other: Matrix
+        | Vector
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float],
     ) -> Matrix | Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Matrix | collections.abc.Sequence[float] | Vector
+        :type other: Matrix | Vector | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         :return:
         :rtype: Matrix | Vector
         """
         ...
 
-    def __radd__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
+    def __radd__(
+        self, other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
+    ) -> Matrix:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __rsub__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
+    def __rsub__(
+        self, other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
+    ) -> Matrix:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __rmul__(self, other: int | float) -> Matrix:
+    def __rmul__(self, other: float | int) -> Matrix:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __imul__(self, other: int | float) -> Matrix:
+    def __imul__(self, other: float | int) -> Matrix:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Matrix
         """
@@ -1021,10 +1092,10 @@ class Quaternion:
     :type: float
     """
 
-    axis: collections.abc.Sequence[float] | Vector
+    axis: Vector
     """ Quaternion axis as a vector.
 
-    :type: collections.abc.Sequence[float] | Vector
+    :type: Vector
     """
 
     is_frozen: bool
@@ -1098,21 +1169,21 @@ class Quaternion:
         """
         ...
 
-    def cross(self, other: collections.abc.Sequence[float] | Quaternion) -> Quaternion:
+    def cross(self, other: Quaternion | collections.abc.Sequence[float]) -> Quaternion:
         """Return the cross product of this quaternion and another.
 
         :param other: The other quaternion to perform the cross product with.
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return: The cross product.
         :rtype: Quaternion
         """
         ...
 
-    def dot(self, other: collections.abc.Sequence[float] | Quaternion) -> float:
+    def dot(self, other: Quaternion | collections.abc.Sequence[float]) -> float:
         """Return the dot product of this quaternion and another.
 
         :param other: The other quaternion to perform the dot product with.
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return: The dot product.
         :rtype: float
         """
@@ -1168,39 +1239,38 @@ class Quaternion:
 
     def rotate(
         self,
-        other: collections.abc.Sequence[float]
-        | Euler
-        | collections.abc.Sequence[float]
+        other: Euler
+        | Matrix
         | Quaternion
-        | collections.abc.Sequence[float]
-        | Matrix,
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float],
     ):
         """Rotates the quaternion by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
+        :type other: Euler | Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         """
         ...
 
     def rotation_difference(
-        self, other: collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float]
     ) -> Quaternion:
         """Returns a quaternion representing the rotational difference.
 
         :param other: second quaternion.
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return: the rotational difference between the two quat rotations.
         :rtype: Quaternion
         """
         ...
 
     def slerp(
-        self, other: collections.abc.Sequence[float] | Quaternion, factor: float
+        self, other: Quaternion | collections.abc.Sequence[float], factor: float
     ) -> Quaternion:
         """Returns the interpolation of two quaternions.
 
         :param other: value to interpolate with.
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated rotation.
@@ -1219,7 +1289,7 @@ class Quaternion:
     def to_euler(
         self,
         order: str | None,
-        euler_compat: collections.abc.Sequence[float] | Euler | None,
+        euler_compat: Euler | collections.abc.Sequence[float] | None,
     ) -> Euler:
         """Return Euler representation of the quaternion.
 
@@ -1229,7 +1299,7 @@ class Quaternion:
                 :param euler_compat: Optional euler argument the new euler will be made
         compatible with (no axis flipping between them).
         Useful for converting a series of matrices to animation curves.
-                :type euler_compat: collections.abc.Sequence[float] | Euler | None
+                :type euler_compat: Euler | collections.abc.Sequence[float] | None
                 :return: Euler representation of the quaternion.
                 :rtype: Euler
         """
@@ -1268,6 +1338,25 @@ class Quaternion:
         """
         ...
 
+    def __get__(self, instance, owner) -> Quaternion:
+        """
+
+        :param instance:
+        :param owner:
+        :return:
+        :rtype: Quaternion
+        """
+        ...
+
+    def __set__(self, instance, value: Quaternion | collections.abc.Sequence[float]):
+        """
+
+        :param instance:
+        :param value:
+        :type value: Quaternion | collections.abc.Sequence[float]
+        """
+        ...
+
     def __len__(self) -> int:
         """
 
@@ -1299,36 +1388,36 @@ class Quaternion:
         ...
 
     def __add__(
-        self, other: collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float]
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __sub__(
-        self, other: collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float]
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __mul__(
-        self, other: int | float | collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float] | float | int
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: int | float | collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float] | float | int
         :return:
         :rtype: Quaternion
         """
@@ -1336,87 +1425,83 @@ class Quaternion:
 
     @typing.overload
     def __matmul__(
-        self, other: collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float]
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return:
         :rtype: Quaternion
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __matmul__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
         ...
 
     def __matmul__(
-        self,
-        other: collections.abc.Sequence[float]
-        | Vector
-        | collections.abc.Sequence[float]
-        | Quaternion,
-    ) -> Vector | Quaternion:
+        self, other: Quaternion | Vector | collections.abc.Sequence[float]
+    ) -> Quaternion | Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector | collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | Vector | collections.abc.Sequence[float]
         :return:
-        :rtype: Vector | Quaternion
+        :rtype: Quaternion | Vector
         """
         ...
 
     def __radd__(
-        self, other: collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float]
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __rsub__(
-        self, other: collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float]
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float]
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __rmul__(
-        self, other: int | float | collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float] | float | int
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: int | float | collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float] | float | int
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __imul__(
-        self, other: int | float | collections.abc.Sequence[float] | Quaternion
+        self, other: Quaternion | collections.abc.Sequence[float] | float | int
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: int | float | collections.abc.Sequence[float] | Quaternion
+        :type other: Quaternion | collections.abc.Sequence[float] | float | int
         :return:
         :rtype: Quaternion
         """
@@ -2545,13 +2630,13 @@ class Vector:
 
     def angle(
         self,
-        other: collections.abc.Sequence[float] | Vector,
+        other: Vector | collections.abc.Sequence[float],
         fallback: typing.Any = None,
     ) -> float:
         """Return the angle between two vectors.
 
                 :param other: another vector to compare the angle with
-                :type other: collections.abc.Sequence[float] | Vector
+                :type other: Vector | collections.abc.Sequence[float]
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
                 :type fallback: typing.Any
@@ -2561,12 +2646,12 @@ class Vector:
         ...
 
     def angle_signed(
-        self, other: collections.abc.Sequence[float] | Vector, fallback: typing.Any
+        self, other: Vector | collections.abc.Sequence[float], fallback: typing.Any
     ) -> float:
         """Return the signed angle between two 2D vectors (clockwise is positive).
 
                 :param other: another vector to compare the angle with
-                :type other: collections.abc.Sequence[float] | Vector
+                :type other: Vector | collections.abc.Sequence[float]
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
                 :type fallback: typing.Any
@@ -2583,21 +2668,21 @@ class Vector:
         """
         ...
 
-    def cross(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def cross(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """Return the cross product of this vector and another.
 
         :param other: The other vector to perform the cross product with.
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return: The cross product.
         :rtype: Vector
         """
         ...
 
-    def dot(self, other: collections.abc.Sequence[float] | Vector) -> float:
+    def dot(self, other: Vector | collections.abc.Sequence[float]) -> float:
         """Return the dot product of this vector and another.
 
         :param other: The other vector to perform the dot product with.
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return: The dot product.
         :rtype: float
         """
@@ -2612,12 +2697,12 @@ class Vector:
         ...
 
     def lerp(
-        self, other: collections.abc.Sequence[float] | Vector, factor: float
+        self, other: Vector | collections.abc.Sequence[float], factor: float
     ) -> Vector:
         """Returns the interpolation of two vectors.
 
         :param other: value to interpolate with.
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated vector.
@@ -2649,21 +2734,21 @@ class Vector:
         """
         ...
 
-    def project(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def project(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """Return the projection of this vector onto the other.
 
         :param other: second vector.
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return: the parallel projection vector
         :rtype: Vector
         """
         ...
 
-    def reflect(self, mirror: collections.abc.Sequence[float] | Vector) -> Vector:
+    def reflect(self, mirror: Vector | collections.abc.Sequence[float]) -> Vector:
         """Return the reflection vector from the mirror argument.
 
         :param mirror: This vector could be a normal from the reflecting surface.
-        :type mirror: collections.abc.Sequence[float] | Vector
+        :type mirror: Vector | collections.abc.Sequence[float]
         :return: The reflected vector matching the size of this vector.
         :rtype: Vector
         """
@@ -2699,28 +2784,27 @@ class Vector:
 
     def rotate(
         self,
-        other: collections.abc.Sequence[float]
-        | Euler
-        | collections.abc.Sequence[float]
+        other: Euler
+        | Matrix
         | Quaternion
-        | collections.abc.Sequence[float]
-        | Matrix,
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float],
     ):
         """Rotate the vector by a rotation value.
 
         :param other: rotation component of mathutils value
-        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
+        :type other: Euler | Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         """
         ...
 
     def rotation_difference(
-        self, other: collections.abc.Sequence[float] | Vector
+        self, other: Vector | collections.abc.Sequence[float]
     ) -> Quaternion:
         """Returns a quaternion representing the rotational difference between this
         vector and another.
 
                 :param other: second vector.
-                :type other: collections.abc.Sequence[float] | Vector
+                :type other: Vector | collections.abc.Sequence[float]
                 :return: the rotational difference between the two vectors.
                 :rtype: Quaternion
         """
@@ -2728,14 +2812,14 @@ class Vector:
 
     def slerp(
         self,
-        other: collections.abc.Sequence[float] | Vector,
+        other: Vector | collections.abc.Sequence[float],
         factor: float,
         fallback: typing.Any = None,
     ) -> Vector:
         """Returns the interpolation of two non-zero vectors (spherical coordinates).
 
                 :param other: value to interpolate with.
-                :type other: collections.abc.Sequence[float] | Vector
+                :type other: Vector | collections.abc.Sequence[float]
                 :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),
@@ -2803,6 +2887,25 @@ class Vector:
         """
         ...
 
+    def __get__(self, instance, owner) -> Vector:
+        """
+
+        :param instance:
+        :param owner:
+        :return:
+        :rtype: Vector
+        """
+        ...
+
+    def __set__(self, instance, value: Vector | collections.abc.Sequence[float]):
+        """
+
+        :param instance:
+        :param value:
+        :type value: Vector | collections.abc.Sequence[float]
+        """
+        ...
+
     def __len__(self) -> int:
         """
 
@@ -2841,63 +2944,65 @@ class Vector:
         """
         ...
 
-    def __add__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __add__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __sub__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __sub__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __mul__(self, other: int | float) -> Vector:
+    def __mul__(self, other: float | int) -> Vector:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Vector
         """
         ...
 
-    def __truediv__(self, other: int | float) -> Vector:
+    def __truediv__(self, other: float | int) -> Vector:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Vector
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: collections.abc.Sequence[float] | Vector) -> float:
+    def __matmul__(self, other: Vector | collections.abc.Sequence[float]) -> float:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: float
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: collections.abc.Sequence[float] | Matrix) -> Vector:
+    def __matmul__(
+        self, other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
+    ) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | collections.abc.Sequence[collections.abc.Sequence[float]]
         :return:
         :rtype: Vector
         """
@@ -2905,95 +3010,95 @@ class Vector:
 
     def __matmul__(
         self,
-        other: collections.abc.Sequence[float]
+        other: Matrix
         | Vector
-        | collections.abc.Sequence[float]
-        | Matrix,
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float],
     ) -> Vector | float:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector | collections.abc.Sequence[float] | Matrix
+        :type other: Matrix | Vector | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         :return:
         :rtype: Vector | float
         """
         ...
 
-    def __radd__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __radd__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rsub__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __rsub__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rmul__(self, other: int | float) -> Vector:
+    def __rmul__(self, other: float | int) -> Vector:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rtruediv__(self, other: int | float) -> Vector:
+    def __rtruediv__(self, other: float | int) -> Vector:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Vector
         """
         ...
 
-    def __iadd__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __iadd__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __isub__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
+    def __isub__(self, other: Vector | collections.abc.Sequence[float]) -> Vector:
         """
 
         :param other:
-        :type other: collections.abc.Sequence[float] | Vector
+        :type other: Vector | collections.abc.Sequence[float]
         :return:
         :rtype: Vector
         """
         ...
 
-    def __imul__(self, other: int | float) -> Vector:
+    def __imul__(self, other: float | int) -> Vector:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Vector
         """
         ...
 
-    def __itruediv__(self, other: int | float) -> Vector:
+    def __itruediv__(self, other: float | int) -> Vector:
         """
 
         :param other:
-        :type other: int | float
+        :type other: float | int
         :return:
         :rtype: Vector
         """