fake-bpy-module 20240620__py3-none-any.whl → 20240621__py3-none-any.whl

bpy/ops/transform/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import bpy.types
+import mathutils
 
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
@@ -10,18 +11,16 @@ def bbone_resize(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = (1.0, 1.0, 1.0),
+    value: collections.abc.Sequence[float] | mathutils.Vector | None = (1.0, 1.0, 1.0),
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    mirror: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    mirror: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Scale selected bendy bones display size
 
@@ -29,21 +28,21 @@ def bbone_resize(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Display Size
-    :type value: typing.Any | None
+    :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -53,18 +52,22 @@ def bend(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    value: collections.abc.Iterable[float] | None = 0.0,
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    gpencil_strokes: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
+    gpencil_strokes: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Bend selected items between the 3D cursor and the mouse
 
@@ -72,29 +75,29 @@ def bend(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Angle
-    :type value: typing.Any | None
+    :type value: collections.abc.Iterable[float] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -104,10 +107,10 @@ def create_orientation(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    name: str | typing.Any = "",
-    use_view: bool | typing.Any | None = False,
-    use: bool | typing.Any | None = False,
-    overwrite: bool | typing.Any | None = False,
+    name: str = "",
+    use_view: bool | None = False,
+    use: bool | None = False,
+    overwrite: bool | None = False,
 ):
     """Create transformation orientation from selection
 
@@ -115,13 +118,13 @@ def create_orientation(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param name: Name, Name of the new custom orientation
-    :type name: str | typing.Any
+    :type name: str
     :param use_view: Use View, Use the current view instead of the active object to create the new orientation
-    :type use_view: bool | typing.Any | None
+    :type use_view: bool | None
     :param use: Use After Creation, Select orientation after its creation
-    :type use: bool | typing.Any | None
+    :type use: bool | None
     :param overwrite: Overwrite Previous, Overwrite previously created orientation with same name
-    :type overwrite: bool | typing.Any | None
+    :type overwrite: bool | None
     """
 
     ...
@@ -145,10 +148,10 @@ def edge_bevelweight(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    snap: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    snap: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Change the bevel weight of edges
 
@@ -156,13 +159,13 @@ def edge_bevelweight(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Factor
-    :type value: typing.Any | None
+    :type value: float | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -172,10 +175,10 @@ def edge_crease(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    snap: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    snap: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Change the crease of edges
 
@@ -183,13 +186,13 @@ def edge_crease(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Factor
-    :type value: typing.Any | None
+    :type value: float | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -199,24 +202,28 @@ def edge_slide(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    single_side: bool | typing.Any | None = False,
-    use_even: bool | typing.Any | None = False,
-    flipped: bool | typing.Any | None = False,
-    use_clamp: bool | typing.Any | None = True,
-    mirror: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    single_side: bool | None = False,
+    use_even: bool | None = False,
+    flipped: bool | None = False,
+    use_clamp: bool | None = True,
+    mirror: bool | None = False,
+    snap: bool | None = False,
     snap_elements: set[str] | None = {"INCREMENT"},
-    use_snap_project: bool | typing.Any | None = False,
+    use_snap_project: bool | None = False,
     snap_target: str | None = "CLOSEST",
-    use_snap_self: bool | typing.Any | None = True,
-    use_snap_edit: bool | typing.Any | None = True,
-    use_snap_nonedit: bool | typing.Any | None = True,
-    use_snap_selectable: bool | typing.Any | None = False,
-    snap_point: typing.Any | None = (0.0, 0.0, 0.0),
-    correct_uv: bool | typing.Any | None = True,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    use_snap_self: bool | None = True,
+    use_snap_edit: bool | None = True,
+    use_snap_nonedit: bool | None = True,
+    use_snap_selectable: bool | None = False,
+    snap_point: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    correct_uv: bool | None = True,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Slide an edge loop along a mesh
 
@@ -224,41 +231,41 @@ def edge_slide(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Factor
-    :type value: typing.Any | None
+    :type value: float | None
     :param single_side: Single Side
-    :type single_side: bool | typing.Any | None
+    :type single_side: bool | None
     :param use_even: Even, Make the edge loop match the shape of the adjacent edge loop
-    :type use_even: bool | typing.Any | None
+    :type use_even: bool | None
     :param flipped: Flipped, When Even mode is active, flips between the two adjacent edge loops
-    :type flipped: bool | typing.Any | None
+    :type flipped: bool | None
     :param use_clamp: Clamp, Clamp within the edge extents
-    :type use_clamp: bool | typing.Any | None
+    :type use_clamp: bool | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param snap_elements: Snap to Elements
     :type snap_elements: set[str] | None
     :param use_snap_project: Project Individual Elements
-    :type use_snap_project: bool | typing.Any | None
+    :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
     :type snap_target: str | None
     :param use_snap_self: Target: Include Active
-    :type use_snap_self: bool | typing.Any | None
+    :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
-    :type use_snap_edit: bool | typing.Any | None
+    :type use_snap_edit: bool | None
     :param use_snap_nonedit: Target: Include Non-Edited
-    :type use_snap_nonedit: bool | typing.Any | None
+    :type use_snap_nonedit: bool | None
     :param use_snap_selectable: Target: Exclude Non-Selectable
-    :type use_snap_selectable: bool | typing.Any | None
+    :type use_snap_selectable: bool | None
     :param snap_point: Point
-    :type snap_point: typing.Any | None
+    :type snap_point: collections.abc.Sequence[float] | mathutils.Vector | None
     :param correct_uv: Correct UVs, Correct UV coordinates when transforming
-    :type correct_uv: bool | typing.Any | None
+    :type correct_uv: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -283,17 +290,19 @@ def mirror(
     undo: bool | None = None,
     *,
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    gpencil_strokes: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    gpencil_strokes: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Mirror selected items around one or more axes
 
@@ -303,19 +312,19 @@ def mirror(
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -325,17 +334,21 @@ def push_pull(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Push/Pull selected items
 
@@ -343,27 +356,27 @@ def push_pull(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Distance
-    :type value: typing.Any | None
+    :type value: float | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -373,38 +386,48 @@ def resize(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = (1.0, 1.0, 1.0),
-    mouse_dir_constraint: typing.Any | None = (0.0, 0.0, 0.0),
-    orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
+    value: collections.abc.Sequence[float] | mathutils.Vector | None = (1.0, 1.0, 1.0),
+    mouse_dir_constraint: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
     ),
+    orient_type: str | None = "GLOBAL",
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
     snap_elements: set[str] | None = {"INCREMENT"},
-    use_snap_project: bool | typing.Any | None = False,
+    use_snap_project: bool | None = False,
     snap_target: str | None = "CLOSEST",
-    use_snap_self: bool | typing.Any | None = True,
-    use_snap_edit: bool | typing.Any | None = True,
-    use_snap_nonedit: bool | typing.Any | None = True,
-    use_snap_selectable: bool | typing.Any | None = False,
-    snap_point: typing.Any | None = (0.0, 0.0, 0.0),
-    gpencil_strokes: bool | typing.Any | None = False,
-    texture_space: bool | typing.Any | None = False,
-    remove_on_cancel: bool | typing.Any | None = False,
-    use_duplicated_keyframes: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    use_snap_self: bool | None = True,
+    use_snap_edit: bool | None = True,
+    use_snap_nonedit: bool | None = True,
+    use_snap_selectable: bool | None = False,
+    snap_point: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    gpencil_strokes: bool | None = False,
+    texture_space: bool | None = False,
+    remove_on_cancel: bool | None = False,
+    use_duplicated_keyframes: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Scale (resize) selected items
 
@@ -412,61 +435,61 @@ def resize(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Scale
-    :type value: typing.Any | None
+    :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param mouse_dir_constraint: Mouse Directional Constraint
-    :type mouse_dir_constraint: typing.Any | None
+    :type mouse_dir_constraint: collections.abc.Sequence[float] | mathutils.Vector | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param snap_elements: Snap to Elements
     :type snap_elements: set[str] | None
     :param use_snap_project: Project Individual Elements
-    :type use_snap_project: bool | typing.Any | None
+    :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
     :type snap_target: str | None
     :param use_snap_self: Target: Include Active
-    :type use_snap_self: bool | typing.Any | None
+    :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
-    :type use_snap_edit: bool | typing.Any | None
+    :type use_snap_edit: bool | None
     :param use_snap_nonedit: Target: Include Non-Edited
-    :type use_snap_nonedit: bool | typing.Any | None
+    :type use_snap_nonedit: bool | None
     :param use_snap_selectable: Target: Exclude Non-Selectable
-    :type use_snap_selectable: bool | typing.Any | None
+    :type use_snap_selectable: bool | None
     :param snap_point: Point
-    :type snap_point: typing.Any | None
+    :type snap_point: collections.abc.Sequence[float] | mathutils.Vector | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param texture_space: Edit Texture Space, Edit object data texture space
-    :type texture_space: bool | typing.Any | None
+    :type texture_space: bool | None
     :param remove_on_cancel: Remove on Cancel, Remove elements on cancel
-    :type remove_on_cancel: bool | typing.Any | None
+    :type remove_on_cancel: bool | None
     :param use_duplicated_keyframes: Duplicated Keyframes, Transform duplicated keyframes
-    :type use_duplicated_keyframes: bool | typing.Any | None
+    :type use_duplicated_keyframes: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -476,35 +499,41 @@ def rotate(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
+    value: float | None = 0.0,
     orient_axis: str | None = "Z",
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
     snap_elements: set[str] | None = {"INCREMENT"},
-    use_snap_project: bool | typing.Any | None = False,
+    use_snap_project: bool | None = False,
     snap_target: str | None = "CLOSEST",
-    use_snap_self: bool | typing.Any | None = True,
-    use_snap_edit: bool | typing.Any | None = True,
-    use_snap_nonedit: bool | typing.Any | None = True,
-    use_snap_selectable: bool | typing.Any | None = False,
-    snap_point: typing.Any | None = (0.0, 0.0, 0.0),
-    gpencil_strokes: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    use_snap_self: bool | None = True,
+    use_snap_edit: bool | None = True,
+    use_snap_nonedit: bool | None = True,
+    use_snap_selectable: bool | None = False,
+    snap_point: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    gpencil_strokes: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Rotate selected items
 
@@ -512,55 +541,55 @@ def rotate(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Angle
-    :type value: typing.Any | None
+    :type value: float | None
     :param orient_axis: Axis
     :type orient_axis: str | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param snap_elements: Snap to Elements
     :type snap_elements: set[str] | None
     :param use_snap_project: Project Individual Elements
-    :type use_snap_project: bool | typing.Any | None
+    :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
     :type snap_target: str | None
     :param use_snap_self: Target: Include Active
-    :type use_snap_self: bool | typing.Any | None
+    :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
-    :type use_snap_edit: bool | typing.Any | None
+    :type use_snap_edit: bool | None
     :param use_snap_nonedit: Target: Include Non-Edited
-    :type use_snap_nonedit: bool | typing.Any | None
+    :type use_snap_nonedit: bool | None
     :param use_snap_selectable: Target: Exclude Non-Selectable
-    :type use_snap_selectable: bool | typing.Any | None
+    :type use_snap_selectable: bool | None
     :param snap_point: Point
-    :type snap_point: typing.Any | None
+    :type snap_point: collections.abc.Sequence[float] | mathutils.Vector | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -570,19 +599,17 @@ def rotate_normal(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
+    value: float | None = 0.0,
     orient_axis: str | None = "Z",
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    mirror: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    mirror: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Rotate split normal of selected items
 
@@ -590,23 +617,23 @@ def rotate_normal(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Angle
-    :type value: typing.Any | None
+    :type value: float | None
     :param orient_axis: Axis
     :type orient_axis: str | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -634,12 +661,12 @@ def seq_slide(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = (0.0, 0.0),
-    use_restore_handle_selection: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    view2d_edge_pan: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    value: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
+    use_restore_handle_selection: bool | None = False,
+    snap: bool | None = False,
+    view2d_edge_pan: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Slide a sequence strip in time
 
@@ -647,17 +674,17 @@ def seq_slide(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Offset
-    :type value: typing.Any | None
+    :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param use_restore_handle_selection: Restore Handle Selection, Restore handle selection after tweaking
-    :type use_restore_handle_selection: bool | typing.Any | None
+    :type use_restore_handle_selection: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param view2d_edge_pan: Edge Pan, Enable edge panning in 2D view
-    :type view2d_edge_pan: bool | typing.Any | None
+    :type view2d_edge_pan: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -667,26 +694,24 @@ def shear(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
+    value: float | None = 0.0,
     orient_axis: str | None = "Z",
     orient_axis_ortho: str | None = "X",
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    gpencil_strokes: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
+    gpencil_strokes: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Shear selected items along the given axis
 
@@ -694,7 +719,7 @@ def shear(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Offset
-    :type value: typing.Any | None
+    :type value: float | None
     :param orient_axis: Axis
     :type orient_axis: str | None
     :param orient_axis_ortho: Axis Ortho
@@ -702,29 +727,29 @@ def shear(
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -734,17 +759,17 @@ def shrink_fatten(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    use_even_offset: bool | typing.Any | None = False,
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    use_even_offset: bool | None = False,
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Shrink/fatten selected vertices along normals
 
@@ -752,27 +777,27 @@ def shrink_fatten(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Offset
-    :type value: typing.Any | None
+    :type value: float | None
     :param use_even_offset: Offset Even, Scale the offset to give more even thickness
-    :type use_even_offset: bool | typing.Any | None
+    :type use_even_offset: bool | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -782,32 +807,34 @@ def skin_resize(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = (1.0, 1.0, 1.0),
+    value: collections.abc.Sequence[float] | mathutils.Vector | None = (1.0, 1.0, 1.0),
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
     snap_elements: set[str] | None = {"INCREMENT"},
-    use_snap_project: bool | typing.Any | None = False,
+    use_snap_project: bool | None = False,
     snap_target: str | None = "CLOSEST",
-    use_snap_self: bool | typing.Any | None = True,
-    use_snap_edit: bool | typing.Any | None = True,
-    use_snap_nonedit: bool | typing.Any | None = True,
-    use_snap_selectable: bool | typing.Any | None = False,
-    snap_point: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    use_snap_self: bool | None = True,
+    use_snap_edit: bool | None = True,
+    use_snap_nonedit: bool | None = True,
+    use_snap_selectable: bool | None = False,
+    snap_point: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Scale selected vertices' skin radii
 
@@ -815,49 +842,49 @@ def skin_resize(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Scale
-    :type value: typing.Any | None
+    :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param snap_elements: Snap to Elements
     :type snap_elements: set[str] | None
     :param use_snap_project: Project Individual Elements
-    :type use_snap_project: bool | typing.Any | None
+    :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
     :type snap_target: str | None
     :param use_snap_self: Target: Include Active
-    :type use_snap_self: bool | typing.Any | None
+    :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
-    :type use_snap_edit: bool | typing.Any | None
+    :type use_snap_edit: bool | None
     :param use_snap_nonedit: Target: Include Non-Edited
-    :type use_snap_nonedit: bool | typing.Any | None
+    :type use_snap_nonedit: bool | None
     :param use_snap_selectable: Target: Exclude Non-Selectable
-    :type use_snap_selectable: bool | typing.Any | None
+    :type use_snap_selectable: bool | None
     :param snap_point: Point
-    :type snap_point: typing.Any | None
+    :type snap_point: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -867,16 +894,16 @@ def tilt(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Tilt selected control vertices of 3D curve
 
@@ -884,25 +911,25 @@ def tilt(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Angle
-    :type value: typing.Any | None
+    :type value: float | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -912,18 +939,22 @@ def tosphere(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    gpencil_strokes: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
+    gpencil_strokes: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Move selected items outward in a spherical shape around geometric center
 
@@ -931,29 +962,29 @@ def tosphere(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Factor
-    :type value: typing.Any | None
+    :type value: float | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -963,18 +994,22 @@ def trackball(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = (0.0, 0.0),
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    value: collections.abc.Iterable[float] | None = (0.0, 0.0),
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
-    gpencil_strokes: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
+    gpencil_strokes: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Trackball style rotation of selected items
 
@@ -982,29 +1017,29 @@ def trackball(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Angle
-    :type value: typing.Any | None
+    :type value: collections.abc.Iterable[float] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -1015,41 +1050,56 @@ def transform(
     undo: bool | None = None,
     *,
     mode: str | None = "TRANSLATION",
-    value: typing.Any | None = (0.0, 0.0, 0.0, 0.0),
+    value: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+    ),
     orient_axis: str | None = "Z",
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
     snap_elements: set[str] | None = {"INCREMENT"},
-    use_snap_project: bool | typing.Any | None = False,
+    use_snap_project: bool | None = False,
     snap_target: str | None = "CLOSEST",
-    use_snap_self: bool | typing.Any | None = True,
-    use_snap_edit: bool | typing.Any | None = True,
-    use_snap_nonedit: bool | typing.Any | None = True,
-    use_snap_selectable: bool | typing.Any | None = False,
-    snap_point: typing.Any | None = (0.0, 0.0, 0.0),
-    snap_align: bool | typing.Any | None = False,
-    snap_normal: typing.Any | None = (0.0, 0.0, 0.0),
-    gpencil_strokes: bool | typing.Any | None = False,
-    texture_space: bool | typing.Any | None = False,
-    remove_on_cancel: bool | typing.Any | None = False,
-    use_duplicated_keyframes: bool | typing.Any | None = False,
-    center_override: typing.Any | None = (0.0, 0.0, 0.0),
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
-    use_automerge_and_split: bool | typing.Any | None = False,
+    use_snap_self: bool | None = True,
+    use_snap_edit: bool | None = True,
+    use_snap_nonedit: bool | None = True,
+    use_snap_selectable: bool | None = False,
+    snap_point: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    snap_align: bool | None = False,
+    snap_normal: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    gpencil_strokes: bool | None = False,
+    texture_space: bool | None = False,
+    remove_on_cancel: bool | None = False,
+    use_duplicated_keyframes: bool | None = False,
+    center_override: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
+    use_automerge_and_split: bool | None = False,
 ):
     """Transform selected items by mode type
 
@@ -1059,67 +1109,67 @@ def transform(
     :param mode: Mode
     :type mode: str | None
     :param value: Values
-    :type value: typing.Any | None
+    :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param orient_axis: Axis
     :type orient_axis: str | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param snap_elements: Snap to Elements
     :type snap_elements: set[str] | None
     :param use_snap_project: Project Individual Elements
-    :type use_snap_project: bool | typing.Any | None
+    :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
     :type snap_target: str | None
     :param use_snap_self: Target: Include Active
-    :type use_snap_self: bool | typing.Any | None
+    :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
-    :type use_snap_edit: bool | typing.Any | None
+    :type use_snap_edit: bool | None
     :param use_snap_nonedit: Target: Include Non-Edited
-    :type use_snap_nonedit: bool | typing.Any | None
+    :type use_snap_nonedit: bool | None
     :param use_snap_selectable: Target: Exclude Non-Selectable
-    :type use_snap_selectable: bool | typing.Any | None
+    :type use_snap_selectable: bool | None
     :param snap_point: Point
-    :type snap_point: typing.Any | None
+    :type snap_point: collections.abc.Sequence[float] | mathutils.Vector | None
     :param snap_align: Align with Point Normal
-    :type snap_align: bool | typing.Any | None
+    :type snap_align: bool | None
     :param snap_normal: Normal
-    :type snap_normal: typing.Any | None
+    :type snap_normal: collections.abc.Sequence[float] | mathutils.Vector | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param texture_space: Edit Texture Space, Edit object data texture space
-    :type texture_space: bool | typing.Any | None
+    :type texture_space: bool | None
     :param remove_on_cancel: Remove on Cancel, Remove elements on cancel
-    :type remove_on_cancel: bool | typing.Any | None
+    :type remove_on_cancel: bool | None
     :param use_duplicated_keyframes: Duplicated Keyframes, Transform duplicated keyframes
-    :type use_duplicated_keyframes: bool | typing.Any | None
+    :type use_duplicated_keyframes: bool | None
     :param center_override: Center Override, Force using this center value (when set)
-    :type center_override: typing.Any | None
+    :type center_override: collections.abc.Sequence[float] | mathutils.Vector | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     :param use_automerge_and_split: Auto Merge & Split, Forces the use of Auto Merge and Split
-    :type use_automerge_and_split: bool | typing.Any | None
+    :type use_automerge_and_split: bool | None
     """
 
     ...
@@ -1129,41 +1179,47 @@ def translate(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = (0.0, 0.0, 0.0),
+    value: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0, 0.0),
     orient_type: str | None = "GLOBAL",
-    orient_matrix: typing.Any | None = (
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-        (0.0, 0.0, 0.0),
-    ),
+    orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)),
     orient_matrix_type: str | None = "GLOBAL",
-    constraint_axis: list[bool] | typing.Any | None = (False, False, False),
-    mirror: bool | typing.Any | None = False,
-    use_proportional_edit: bool | typing.Any | None = False,
+    constraint_axis: list[bool] | None = (False, False, False),
+    mirror: bool | None = False,
+    use_proportional_edit: bool | None = False,
     proportional_edit_falloff: str | None = "SMOOTH",
-    proportional_size: typing.Any | None = 1.0,
-    use_proportional_connected: bool | typing.Any | None = False,
-    use_proportional_projected: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
+    proportional_size: float | None = 1.0,
+    use_proportional_connected: bool | None = False,
+    use_proportional_projected: bool | None = False,
+    snap: bool | None = False,
     snap_elements: set[str] | None = {"INCREMENT"},
-    use_snap_project: bool | typing.Any | None = False,
+    use_snap_project: bool | None = False,
     snap_target: str | None = "CLOSEST",
-    use_snap_self: bool | typing.Any | None = True,
-    use_snap_edit: bool | typing.Any | None = True,
-    use_snap_nonedit: bool | typing.Any | None = True,
-    use_snap_selectable: bool | typing.Any | None = False,
-    snap_point: typing.Any | None = (0.0, 0.0, 0.0),
-    snap_align: bool | typing.Any | None = False,
-    snap_normal: typing.Any | None = (0.0, 0.0, 0.0),
-    gpencil_strokes: bool | typing.Any | None = False,
-    cursor_transform: bool | typing.Any | None = False,
-    texture_space: bool | typing.Any | None = False,
-    remove_on_cancel: bool | typing.Any | None = False,
-    use_duplicated_keyframes: bool | typing.Any | None = False,
-    view2d_edge_pan: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
-    use_automerge_and_split: bool | typing.Any | None = False,
+    use_snap_self: bool | None = True,
+    use_snap_edit: bool | None = True,
+    use_snap_nonedit: bool | None = True,
+    use_snap_selectable: bool | None = False,
+    snap_point: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    snap_align: bool | None = False,
+    snap_normal: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    gpencil_strokes: bool | None = False,
+    cursor_transform: bool | None = False,
+    texture_space: bool | None = False,
+    remove_on_cancel: bool | None = False,
+    use_duplicated_keyframes: bool | None = False,
+    view2d_edge_pan: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
+    use_automerge_and_split: bool | None = False,
 ):
     """Move selected items
 
@@ -1171,67 +1227,67 @@ def translate(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Move
-    :type value: typing.Any | None
+    :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
-    :type orient_matrix: typing.Any | None
+    :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
     :type orient_matrix_type: str | None
     :param constraint_axis: Constraint Axis
-    :type constraint_axis: list[bool] | typing.Any | None
+    :type constraint_axis: list[bool] | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param use_proportional_edit: Proportional Editing
-    :type use_proportional_edit: bool | typing.Any | None
+    :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
     :type proportional_edit_falloff: str | None
     :param proportional_size: Proportional Size
-    :type proportional_size: typing.Any | None
+    :type proportional_size: float | None
     :param use_proportional_connected: Connected
-    :type use_proportional_connected: bool | typing.Any | None
+    :type use_proportional_connected: bool | None
     :param use_proportional_projected: Projected (2D)
-    :type use_proportional_projected: bool | typing.Any | None
+    :type use_proportional_projected: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param snap_elements: Snap to Elements
     :type snap_elements: set[str] | None
     :param use_snap_project: Project Individual Elements
-    :type use_snap_project: bool | typing.Any | None
+    :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
     :type snap_target: str | None
     :param use_snap_self: Target: Include Active
-    :type use_snap_self: bool | typing.Any | None
+    :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
-    :type use_snap_edit: bool | typing.Any | None
+    :type use_snap_edit: bool | None
     :param use_snap_nonedit: Target: Include Non-Edited
-    :type use_snap_nonedit: bool | typing.Any | None
+    :type use_snap_nonedit: bool | None
     :param use_snap_selectable: Target: Exclude Non-Selectable
-    :type use_snap_selectable: bool | typing.Any | None
+    :type use_snap_selectable: bool | None
     :param snap_point: Point
-    :type snap_point: typing.Any | None
+    :type snap_point: collections.abc.Sequence[float] | mathutils.Vector | None
     :param snap_align: Align with Point Normal
-    :type snap_align: bool | typing.Any | None
+    :type snap_align: bool | None
     :param snap_normal: Normal
-    :type snap_normal: typing.Any | None
+    :type snap_normal: collections.abc.Sequence[float] | mathutils.Vector | None
     :param gpencil_strokes: Edit Grease Pencil, Edit selected Grease Pencil strokes
-    :type gpencil_strokes: bool | typing.Any | None
+    :type gpencil_strokes: bool | None
     :param cursor_transform: Transform Cursor
-    :type cursor_transform: bool | typing.Any | None
+    :type cursor_transform: bool | None
     :param texture_space: Edit Texture Space, Edit object data texture space
-    :type texture_space: bool | typing.Any | None
+    :type texture_space: bool | None
     :param remove_on_cancel: Remove on Cancel, Remove elements on cancel
-    :type remove_on_cancel: bool | typing.Any | None
+    :type remove_on_cancel: bool | None
     :param use_duplicated_keyframes: Duplicated Keyframes, Transform duplicated keyframes
-    :type use_duplicated_keyframes: bool | typing.Any | None
+    :type use_duplicated_keyframes: bool | None
     :param view2d_edge_pan: Edge Pan, Enable edge panning in 2D view
-    :type view2d_edge_pan: bool | typing.Any | None
+    :type view2d_edge_pan: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     :param use_automerge_and_split: Auto Merge & Split, Forces the use of Auto Merge and Split
-    :type use_automerge_and_split: bool | typing.Any | None
+    :type use_automerge_and_split: bool | None
     """
 
     ...
@@ -1241,10 +1297,10 @@ def vert_crease(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    snap: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    snap: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Change the crease of vertices
 
@@ -1252,13 +1308,13 @@ def vert_crease(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Factor
-    :type value: typing.Any | None
+    :type value: float | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -1268,23 +1324,27 @@ def vert_slide(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    value: typing.Any | None = 0.0,
-    use_even: bool | typing.Any | None = False,
-    flipped: bool | typing.Any | None = False,
-    use_clamp: bool | typing.Any | None = True,
-    mirror: bool | typing.Any | None = False,
-    snap: bool | typing.Any | None = False,
+    value: float | None = 0.0,
+    use_even: bool | None = False,
+    flipped: bool | None = False,
+    use_clamp: bool | None = True,
+    mirror: bool | None = False,
+    snap: bool | None = False,
     snap_elements: set[str] | None = {"INCREMENT"},
-    use_snap_project: bool | typing.Any | None = False,
+    use_snap_project: bool | None = False,
     snap_target: str | None = "CLOSEST",
-    use_snap_self: bool | typing.Any | None = True,
-    use_snap_edit: bool | typing.Any | None = True,
-    use_snap_nonedit: bool | typing.Any | None = True,
-    use_snap_selectable: bool | typing.Any | None = False,
-    snap_point: typing.Any | None = (0.0, 0.0, 0.0),
-    correct_uv: bool | typing.Any | None = True,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
+    use_snap_self: bool | None = True,
+    use_snap_edit: bool | None = True,
+    use_snap_nonedit: bool | None = True,
+    use_snap_selectable: bool | None = False,
+    snap_point: collections.abc.Sequence[float] | mathutils.Vector | None = (
+        0.0,
+        0.0,
+        0.0,
+    ),
+    correct_uv: bool | None = True,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
 ):
     """Slide a vertex along a mesh
 
@@ -1292,39 +1352,39 @@ def vert_slide(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param value: Factor
-    :type value: typing.Any | None
+    :type value: float | None
     :param use_even: Even, Make the edge loop match the shape of the adjacent edge loop
-    :type use_even: bool | typing.Any | None
+    :type use_even: bool | None
     :param flipped: Flipped, When Even mode is active, flips between the two adjacent edge loops
-    :type flipped: bool | typing.Any | None
+    :type flipped: bool | None
     :param use_clamp: Clamp, Clamp within the edge extents
-    :type use_clamp: bool | typing.Any | None
+    :type use_clamp: bool | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param snap: Use Snapping Options
-    :type snap: bool | typing.Any | None
+    :type snap: bool | None
     :param snap_elements: Snap to Elements
     :type snap_elements: set[str] | None
     :param use_snap_project: Project Individual Elements
-    :type use_snap_project: bool | typing.Any | None
+    :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
     :type snap_target: str | None
     :param use_snap_self: Target: Include Active
-    :type use_snap_self: bool | typing.Any | None
+    :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
-    :type use_snap_edit: bool | typing.Any | None
+    :type use_snap_edit: bool | None
     :param use_snap_nonedit: Target: Include Non-Edited
-    :type use_snap_nonedit: bool | typing.Any | None
+    :type use_snap_nonedit: bool | None
     :param use_snap_selectable: Target: Exclude Non-Selectable
-    :type use_snap_selectable: bool | typing.Any | None
+    :type use_snap_selectable: bool | None
     :param snap_point: Point
-    :type snap_point: typing.Any | None
+    :type snap_point: collections.abc.Sequence[float] | mathutils.Vector | None
     :param correct_uv: Correct UVs, Correct UV coordinates when transforming
-    :type correct_uv: bool | typing.Any | None
+    :type correct_uv: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :type use_accurate: bool | None
     """
 
     ...
@@ -1334,11 +1394,11 @@ def vertex_random(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    offset: typing.Any | None = 0.0,
-    uniform: typing.Any | None = 0.0,
-    normal: typing.Any | None = 0.0,
-    seed: typing.Any | None = 0,
-    wait_for_input: bool | typing.Any | None = True,
+    offset: float | None = 0.0,
+    uniform: float | None = 0.0,
+    normal: float | None = 0.0,
+    seed: int | None = 0,
+    wait_for_input: bool | None = True,
 ):
     """Randomize vertices
 
@@ -1346,15 +1406,15 @@ def vertex_random(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param offset: Amount, Distance to offset
-    :type offset: typing.Any | None
+    :type offset: float | None
     :param uniform: Uniform, Increase for uniform offset distance
-    :type uniform: typing.Any | None
+    :type uniform: float | None
     :param normal: Normal, Align offset direction to normals
-    :type normal: typing.Any | None
+    :type normal: float | None
     :param seed: Random Seed, Seed for the random number generator
-    :type seed: typing.Any | None
+    :type seed: int | None
     :param wait_for_input: Wait for Input
-    :type wait_for_input: bool | typing.Any | None
+    :type wait_for_input: bool | None
     """
 
     ...
@@ -1364,17 +1424,19 @@ def vertex_warp(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    warp_angle: typing.Any | None = 6.28319,
-    offset_angle: typing.Any | None = 0.0,
-    min: typing.Any | None = -1.0,
-    max: typing.Any | None = 1.0,
-    viewmat: typing.Any | None = (
+    warp_angle: float | None = 6.28319,
+    offset_angle: float | None = 0.0,
+    min: float | None = -1.0,
+    max: float | None = 1.0,
+    viewmat: collections.abc.Sequence[collections.abc.Sequence[float]]
+    | mathutils.Matrix
+    | None = (
         (0.0, 0.0, 0.0, 0.0),
         (0.0, 0.0, 0.0, 0.0),
         (0.0, 0.0, 0.0, 0.0),
         (0.0, 0.0, 0.0, 0.0),
     ),
-    center: typing.Any | None = (0.0, 0.0, 0.0),
+    center: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0, 0.0),
 ):
     """Warp vertices around the cursor
 
@@ -1382,17 +1444,17 @@ def vertex_warp(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param warp_angle: Warp Angle, Amount to warp about the cursor
-    :type warp_angle: typing.Any | None
+    :type warp_angle: float | None
     :param offset_angle: Offset Angle, Angle to use as the basis for warping
-    :type offset_angle: typing.Any | None
+    :type offset_angle: float | None
     :param min: Min
-    :type min: typing.Any | None
+    :type min: float | None
     :param max: Max
-    :type max: typing.Any | None
+    :type max: float | None
     :param viewmat: Matrix
-    :type viewmat: typing.Any | None
+    :type viewmat: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param center: Center
-    :type center: typing.Any | None
+    :type center: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
     ...