fake-bpy-module 20240914__py3-none-any.whl → 20240916__py3-none-any.whl

bpy/ops/transform/__init__.pyi

@@ -2,10 +2,11 @@ import typing
 import collections.abc
 import typing_extensions
 import bpy.types
+import bpy.typing
 import mathutils
 
-GenericType1 = typing.TypeVar("GenericType1")
-GenericType2 = typing.TypeVar("GenericType2")
+_GenericType1 = typing.TypeVar("_GenericType1")
+_GenericType2 = typing.TypeVar("_GenericType2")
 
 def bbone_resize(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
@@ -46,8 +47,6 @@ def bbone_resize(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def bend(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -56,17 +55,7 @@ def bend(
     value: collections.abc.Iterable[float] | None = 0.0,
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     proportional_size: float | None = 1.0,
     use_proportional_connected: bool | None = False,
     use_proportional_projected: bool | None = False,
@@ -92,7 +81,7 @@ def bend(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -111,8 +100,6 @@ def bend(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def create_orientation(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -138,8 +125,6 @@ def create_orientation(
     :type overwrite: bool | None
     """
 
-    ...
-
 def delete_orientation(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -152,8 +137,6 @@ def delete_orientation(
     :type undo: bool | None
     """
 
-    ...
-
 def edge_bevelweight(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -179,8 +162,6 @@ def edge_bevelweight(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def edge_crease(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -206,8 +187,6 @@ def edge_crease(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def edge_slide(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -220,24 +199,9 @@ def edge_slide(
     use_clamp: bool | None = True,
     mirror: bool | None = False,
     snap: bool | None = False,
-    snap_elements: set[
-        typing.Literal[
-            "INCREMENT",
-            "GRID",
-            "VERTEX",
-            "EDGE",
-            "FACE",
-            "VOLUME",
-            "EDGE_MIDPOINT",
-            "EDGE_PERPENDICULAR",
-            "FACE_PROJECT",
-            "FACE_NEAREST",
-        ]
-    ]
-    | None = {"INCREMENT"},
+    snap_elements: set[bpy.typing.SnapElementItems] | None = {"INCREMENT"},
     use_snap_project: bool | None = False,
-    snap_target: typing.Literal["CLOSEST", "CENTER", "MEDIAN", "ACTIVE"]
-    | None = "CLOSEST",
+    snap_target: bpy.typing.SnapSourceItems | None = "CLOSEST",
     use_snap_self: bool | None = True,
     use_snap_edit: bool | None = True,
     use_snap_nonedit: bool | None = True,
@@ -271,11 +235,11 @@ def edge_slide(
     :param snap: Use Snapping Options
     :type snap: bool | None
     :param snap_elements: Snap to Elements
-    :type snap_elements: set[typing.Literal['INCREMENT', 'GRID', 'VERTEX', 'EDGE', 'FACE', 'VOLUME', 'EDGE_MIDPOINT', 'EDGE_PERPENDICULAR', 'FACE_PROJECT', 'FACE_NEAREST']] | None
+    :type snap_elements: set[bpy.typing.SnapElementItems] | None
     :param use_snap_project: Project Individual Elements
     :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
-    :type snap_target: typing.Literal['CLOSEST', 'CENTER', 'MEDIAN', 'ACTIVE'] | None
+    :type snap_target: bpy.typing.SnapSourceItems | None
     :param use_snap_self: Target: Include Active
     :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
@@ -294,8 +258,6 @@ def edge_slide(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def from_gizmo(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -308,8 +270,6 @@ def from_gizmo(
     :type undo: bool | None
     """
 
-    ...
-
 def mirror(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -353,8 +313,6 @@ def mirror(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def push_pull(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -363,17 +321,7 @@ def push_pull(
     value: float | None = 0.0,
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     proportional_size: float | None = 1.0,
     use_proportional_connected: bool | None = False,
     use_proportional_projected: bool | None = False,
@@ -398,7 +346,7 @@ def push_pull(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -415,8 +363,6 @@ def push_pull(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def resize(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -436,39 +382,14 @@ def resize(
     constraint_axis: collections.abc.Iterable[bool] | None = (False, False, False),
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     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[
-        typing.Literal[
-            "INCREMENT",
-            "GRID",
-            "VERTEX",
-            "EDGE",
-            "FACE",
-            "VOLUME",
-            "EDGE_MIDPOINT",
-            "EDGE_PERPENDICULAR",
-            "FACE_PROJECT",
-            "FACE_NEAREST",
-        ]
-    ]
-    | None = {"INCREMENT"},
+    snap_elements: set[bpy.typing.SnapElementItems] | None = {"INCREMENT"},
     use_snap_project: bool | None = False,
-    snap_target: typing.Literal["CLOSEST", "CENTER", "MEDIAN", "ACTIVE"]
-    | None = "CLOSEST",
+    snap_target: bpy.typing.SnapSourceItems | None = "CLOSEST",
     use_snap_self: bool | None = True,
     use_snap_edit: bool | None = True,
     use_snap_nonedit: bool | None = True,
@@ -512,7 +433,7 @@ def resize(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -522,11 +443,11 @@ def resize(
     :param snap: Use Snapping Options
     :type snap: bool | None
     :param snap_elements: Snap to Elements
-    :type snap_elements: set[typing.Literal['INCREMENT', 'GRID', 'VERTEX', 'EDGE', 'FACE', 'VOLUME', 'EDGE_MIDPOINT', 'EDGE_PERPENDICULAR', 'FACE_PROJECT', 'FACE_NEAREST']] | None
+    :type snap_elements: set[bpy.typing.SnapElementItems] | None
     :param use_snap_project: Project Individual Elements
     :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
-    :type snap_target: typing.Literal['CLOSEST', 'CENTER', 'MEDIAN', 'ACTIVE'] | None
+    :type snap_target: bpy.typing.SnapSourceItems | None
     :param use_snap_self: Target: Include Active
     :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
@@ -553,15 +474,13 @@ def resize(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def rotate(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
     value: float | None = 0.0,
-    orient_axis: typing.Literal["X", "Y", "Z"] | None = "Z",
+    orient_axis: bpy.typing.AxisXyzItems | None = "Z",
     orient_type: str | None = "GLOBAL",
     orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
     | mathutils.Matrix
@@ -570,39 +489,14 @@ def rotate(
     constraint_axis: collections.abc.Iterable[bool] | None = (False, False, False),
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     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[
-        typing.Literal[
-            "INCREMENT",
-            "GRID",
-            "VERTEX",
-            "EDGE",
-            "FACE",
-            "VOLUME",
-            "EDGE_MIDPOINT",
-            "EDGE_PERPENDICULAR",
-            "FACE_PROJECT",
-            "FACE_NEAREST",
-        ]
-    ]
-    | None = {"INCREMENT"},
+    snap_elements: set[bpy.typing.SnapElementItems] | None = {"INCREMENT"},
     use_snap_project: bool | None = False,
-    snap_target: typing.Literal["CLOSEST", "CENTER", "MEDIAN", "ACTIVE"]
-    | None = "CLOSEST",
+    snap_target: bpy.typing.SnapSourceItems | None = "CLOSEST",
     use_snap_self: bool | None = True,
     use_snap_edit: bool | None = True,
     use_snap_nonedit: bool | None = True,
@@ -629,7 +523,7 @@ def rotate(
     :param value: Angle
     :type value: float | None
     :param orient_axis: Axis
-    :type orient_axis: typing.Literal['X', 'Y', 'Z'] | None
+    :type orient_axis: bpy.typing.AxisXyzItems | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
@@ -643,7 +537,7 @@ def rotate(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -653,11 +547,11 @@ def rotate(
     :param snap: Use Snapping Options
     :type snap: bool | None
     :param snap_elements: Snap to Elements
-    :type snap_elements: set[typing.Literal['INCREMENT', 'GRID', 'VERTEX', 'EDGE', 'FACE', 'VOLUME', 'EDGE_MIDPOINT', 'EDGE_PERPENDICULAR', 'FACE_PROJECT', 'FACE_NEAREST']] | None
+    :type snap_elements: set[bpy.typing.SnapElementItems] | None
     :param use_snap_project: Project Individual Elements
     :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
-    :type snap_target: typing.Literal['CLOSEST', 'CENTER', 'MEDIAN', 'ACTIVE'] | None
+    :type snap_target: bpy.typing.SnapSourceItems | None
     :param use_snap_self: Target: Include Active
     :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
@@ -678,15 +572,13 @@ def rotate(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def rotate_normal(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
     value: float | None = 0.0,
-    orient_axis: typing.Literal["X", "Y", "Z"] | None = "Z",
+    orient_axis: bpy.typing.AxisXyzItems | None = "Z",
     orient_type: str | None = "GLOBAL",
     orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
     | mathutils.Matrix
@@ -705,7 +597,7 @@ def rotate_normal(
     :param value: Angle
     :type value: float | None
     :param orient_axis: Axis
-    :type orient_axis: typing.Literal['X', 'Y', 'Z'] | None
+    :type orient_axis: bpy.typing.AxisXyzItems | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
@@ -722,8 +614,6 @@ def rotate_normal(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def select_orientation(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -740,8 +630,6 @@ def select_orientation(
     :type orientation: str | None
     """
 
-    ...
-
 def seq_slide(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -773,16 +661,14 @@ def seq_slide(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def shear(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
     value: float | None = 0.0,
-    orient_axis: typing.Literal["X", "Y", "Z"] | None = "Z",
-    orient_axis_ortho: typing.Literal["X", "Y", "Z"] | None = "X",
+    orient_axis: bpy.typing.AxisXyzItems | None = "Z",
+    orient_axis_ortho: bpy.typing.AxisXyzItems | None = "X",
     orient_type: str | None = "GLOBAL",
     orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
     | mathutils.Matrix
@@ -790,17 +676,7 @@ def shear(
     orient_matrix_type: str | None = "GLOBAL",
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     proportional_size: float | None = 1.0,
     use_proportional_connected: bool | None = False,
     use_proportional_projected: bool | None = False,
@@ -817,9 +693,9 @@ def shear(
     :param value: Offset
     :type value: float | None
     :param orient_axis: Axis
-    :type orient_axis: typing.Literal['X', 'Y', 'Z'] | None
+    :type orient_axis: bpy.typing.AxisXyzItems | None
     :param orient_axis_ortho: Axis Ortho
-    :type orient_axis_ortho: typing.Literal['X', 'Y', 'Z'] | None
+    :type orient_axis_ortho: bpy.typing.AxisXyzItems | None
     :param orient_type: Orientation, Transformation orientation
     :type orient_type: str | None
     :param orient_matrix: Matrix
@@ -831,7 +707,7 @@ def shear(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -848,8 +724,6 @@ def shear(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def shrink_fatten(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -859,17 +733,7 @@ def shrink_fatten(
     use_even_offset: bool | None = False,
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     proportional_size: float | None = 1.0,
     use_proportional_connected: bool | None = False,
     use_proportional_projected: bool | None = False,
@@ -891,7 +755,7 @@ def shrink_fatten(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -906,8 +770,6 @@ def shrink_fatten(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def skin_resize(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -922,39 +784,14 @@ def skin_resize(
     constraint_axis: collections.abc.Iterable[bool] | None = (False, False, False),
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     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[
-        typing.Literal[
-            "INCREMENT",
-            "GRID",
-            "VERTEX",
-            "EDGE",
-            "FACE",
-            "VOLUME",
-            "EDGE_MIDPOINT",
-            "EDGE_PERPENDICULAR",
-            "FACE_PROJECT",
-            "FACE_NEAREST",
-        ]
-    ]
-    | None = {"INCREMENT"},
+    snap_elements: set[bpy.typing.SnapElementItems] | None = {"INCREMENT"},
     use_snap_project: bool | None = False,
-    snap_target: typing.Literal["CLOSEST", "CENTER", "MEDIAN", "ACTIVE"]
-    | None = "CLOSEST",
+    snap_target: bpy.typing.SnapSourceItems | None = "CLOSEST",
     use_snap_self: bool | None = True,
     use_snap_edit: bool | None = True,
     use_snap_nonedit: bool | None = True,
@@ -987,7 +824,7 @@ def skin_resize(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -997,11 +834,11 @@ def skin_resize(
     :param snap: Use Snapping Options
     :type snap: bool | None
     :param snap_elements: Snap to Elements
-    :type snap_elements: set[typing.Literal['INCREMENT', 'GRID', 'VERTEX', 'EDGE', 'FACE', 'VOLUME', 'EDGE_MIDPOINT', 'EDGE_PERPENDICULAR', 'FACE_PROJECT', 'FACE_NEAREST']] | None
+    :type snap_elements: set[bpy.typing.SnapElementItems] | None
     :param use_snap_project: Project Individual Elements
     :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
-    :type snap_target: typing.Literal['CLOSEST', 'CENTER', 'MEDIAN', 'ACTIVE'] | None
+    :type snap_target: bpy.typing.SnapSourceItems | None
     :param use_snap_self: Target: Include Active
     :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
@@ -1018,8 +855,6 @@ def skin_resize(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def tilt(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -1028,17 +863,7 @@ def tilt(
     value: float | None = 0.0,
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     proportional_size: float | None = 1.0,
     use_proportional_connected: bool | None = False,
     use_proportional_projected: bool | None = False,
@@ -1058,7 +883,7 @@ def tilt(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -1073,8 +898,6 @@ def tilt(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def tosphere(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -1083,17 +906,7 @@ def tosphere(
     value: float | None = 0.0,
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     proportional_size: float | None = 1.0,
     use_proportional_connected: bool | None = False,
     use_proportional_projected: bool | None = False,
@@ -1119,7 +932,7 @@ def tosphere(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -1138,8 +951,6 @@ def tosphere(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def trackball(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -1148,17 +959,7 @@ def trackball(
     value: collections.abc.Iterable[float] | None = (0.0, 0.0),
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     proportional_size: float | None = 1.0,
     use_proportional_connected: bool | None = False,
     use_proportional_projected: bool | None = False,
@@ -1184,7 +985,7 @@ def trackball(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -1203,103 +1004,35 @@ def trackball(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def transform(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    mode: typing.Literal[
-        "INIT",
-        "DUMMY",
-        "TRANSLATION",
-        "ROTATION",
-        "RESIZE",
-        "SKIN_RESIZE",
-        "TOSPHERE",
-        "SHEAR",
-        "BEND",
-        "SHRINKFATTEN",
-        "TILT",
-        "TRACKBALL",
-        "PUSHPULL",
-        "CREASE",
-        "VERTEX_CREASE",
-        "MIRROR",
-        "BONE_SIZE",
-        "BONE_ENVELOPE",
-        "BONE_ENVELOPE_DIST",
-        "CURVE_SHRINKFATTEN",
-        "MASK_SHRINKFATTEN",
-        "GPENCIL_SHRINKFATTEN",
-        "BONE_ROLL",
-        "TIME_TRANSLATE",
-        "TIME_SLIDE",
-        "TIME_SCALE",
-        "TIME_EXTEND",
-        "BAKE_TIME",
-        "BWEIGHT",
-        "ALIGN",
-        "EDGESLIDE",
-        "SEQSLIDE",
-        "GPENCIL_OPACITY",
-    ]
-    | None = "TRANSLATION",
+    mode: bpy.typing.TransformModeTypeItems | None = "TRANSLATION",
     value: collections.abc.Sequence[float] | mathutils.Vector | None = (
         0.0,
         0.0,
         0.0,
         0.0,
     ),
-    orient_axis: typing.Literal["X", "Y", "Z"] | None = "Z",
-    orient_type: typing.Literal[
-        "GLOBAL", "LOCAL", "NORMAL", "GIMBAL", "VIEW", "CURSOR", "PARENT"
-    ]
-    | None = "GLOBAL",
+    orient_axis: bpy.typing.AxisXyzItems | None = "Z",
+    orient_type: bpy.typing.TransformOrientationItems | 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: typing.Literal[
-        "GLOBAL", "LOCAL", "NORMAL", "GIMBAL", "VIEW", "CURSOR", "PARENT"
-    ]
-    | None = "GLOBAL",
+    orient_matrix_type: bpy.typing.TransformOrientationItems | None = "GLOBAL",
     constraint_axis: collections.abc.Iterable[bool] | None = (False, False, False),
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     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[
-        typing.Literal[
-            "INCREMENT",
-            "GRID",
-            "VERTEX",
-            "EDGE",
-            "FACE",
-            "VOLUME",
-            "EDGE_MIDPOINT",
-            "EDGE_PERPENDICULAR",
-            "FACE_PROJECT",
-            "FACE_NEAREST",
-        ]
-    ]
-    | None = {"INCREMENT"},
+    snap_elements: set[bpy.typing.SnapElementItems] | None = {"INCREMENT"},
     use_snap_project: bool | None = False,
-    snap_target: typing.Literal["CLOSEST", "CENTER", "MEDIAN", "ACTIVE"]
-    | None = "CLOSEST",
+    snap_target: bpy.typing.SnapSourceItems | None = "CLOSEST",
     use_snap_self: bool | None = True,
     use_snap_edit: bool | None = True,
     use_snap_nonedit: bool | None = True,
@@ -1334,17 +1067,17 @@ def transform(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
-    :type mode: typing.Literal['INIT', 'DUMMY', 'TRANSLATION', 'ROTATION', 'RESIZE', 'SKIN_RESIZE', 'TOSPHERE', 'SHEAR', 'BEND', 'SHRINKFATTEN', 'TILT', 'TRACKBALL', 'PUSHPULL', 'CREASE', 'VERTEX_CREASE', 'MIRROR', 'BONE_SIZE', 'BONE_ENVELOPE', 'BONE_ENVELOPE_DIST', 'CURVE_SHRINKFATTEN', 'MASK_SHRINKFATTEN', 'GPENCIL_SHRINKFATTEN', 'BONE_ROLL', 'TIME_TRANSLATE', 'TIME_SLIDE', 'TIME_SCALE', 'TIME_EXTEND', 'BAKE_TIME', 'BWEIGHT', 'ALIGN', 'EDGESLIDE', 'SEQSLIDE', 'GPENCIL_OPACITY'] | None
+    :type mode: bpy.typing.TransformModeTypeItems | None
     :param value: Values
     :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param orient_axis: Axis
-    :type orient_axis: typing.Literal['X', 'Y', 'Z'] | None
+    :type orient_axis: bpy.typing.AxisXyzItems | None
     :param orient_type: Orientation, Transformation orientation
-    :type orient_type: typing.Literal['GLOBAL', 'LOCAL', 'NORMAL', 'GIMBAL', 'VIEW', 'CURSOR', 'PARENT'] | None
+    :type orient_type: bpy.typing.TransformOrientationItems | None
     :param orient_matrix: Matrix
     :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
-    :type orient_matrix_type: typing.Literal['GLOBAL', 'LOCAL', 'NORMAL', 'GIMBAL', 'VIEW', 'CURSOR', 'PARENT'] | None
+    :type orient_matrix_type: bpy.typing.TransformOrientationItems | None
     :param constraint_axis: Constraint Axis
     :type constraint_axis: collections.abc.Iterable[bool] | None
     :param mirror: Mirror Editing
@@ -1352,7 +1085,7 @@ def transform(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -1362,11 +1095,11 @@ def transform(
     :param snap: Use Snapping Options
     :type snap: bool | None
     :param snap_elements: Snap to Elements
-    :type snap_elements: set[typing.Literal['INCREMENT', 'GRID', 'VERTEX', 'EDGE', 'FACE', 'VOLUME', 'EDGE_MIDPOINT', 'EDGE_PERPENDICULAR', 'FACE_PROJECT', 'FACE_NEAREST']] | None
+    :type snap_elements: set[bpy.typing.SnapElementItems] | None
     :param use_snap_project: Project Individual Elements
     :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
-    :type snap_target: typing.Literal['CLOSEST', 'CENTER', 'MEDIAN', 'ACTIVE'] | None
+    :type snap_target: bpy.typing.SnapSourceItems | None
     :param use_snap_self: Target: Include Active
     :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
@@ -1399,61 +1132,28 @@ def transform(
     :type use_automerge_and_split: bool | None
     """
 
-    ...
-
 def translate(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
     value: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0, 0.0),
-    orient_type: typing.Literal[
-        "GLOBAL", "LOCAL", "NORMAL", "GIMBAL", "VIEW", "CURSOR", "PARENT"
-    ]
-    | None = "GLOBAL",
+    orient_type: bpy.typing.TransformOrientationItems | 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: typing.Literal[
-        "GLOBAL", "LOCAL", "NORMAL", "GIMBAL", "VIEW", "CURSOR", "PARENT"
-    ]
-    | None = "GLOBAL",
+    orient_matrix_type: bpy.typing.TransformOrientationItems | None = "GLOBAL",
     constraint_axis: collections.abc.Iterable[bool] | None = (False, False, False),
     mirror: bool | None = False,
     use_proportional_edit: bool | None = False,
-    proportional_edit_falloff: typing.Literal[
-        "SMOOTH",
-        "SPHERE",
-        "ROOT",
-        "INVERSE_SQUARE",
-        "SHARP",
-        "LINEAR",
-        "CONSTANT",
-        "RANDOM",
-    ]
-    | None = "SMOOTH",
+    proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None = "SMOOTH",
     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[
-        typing.Literal[
-            "INCREMENT",
-            "GRID",
-            "VERTEX",
-            "EDGE",
-            "FACE",
-            "VOLUME",
-            "EDGE_MIDPOINT",
-            "EDGE_PERPENDICULAR",
-            "FACE_PROJECT",
-            "FACE_NEAREST",
-        ]
-    ]
-    | None = {"INCREMENT"},
+    snap_elements: set[bpy.typing.SnapElementItems] | None = {"INCREMENT"},
     use_snap_project: bool | None = False,
-    snap_target: typing.Literal["CLOSEST", "CENTER", "MEDIAN", "ACTIVE"]
-    | None = "CLOSEST",
+    snap_target: bpy.typing.SnapSourceItems | None = "CLOSEST",
     use_snap_self: bool | None = True,
     use_snap_edit: bool | None = True,
     use_snap_nonedit: bool | None = True,
@@ -1487,11 +1187,11 @@ def translate(
     :param value: Move
     :type value: collections.abc.Sequence[float] | mathutils.Vector | None
     :param orient_type: Orientation, Transformation orientation
-    :type orient_type: typing.Literal['GLOBAL', 'LOCAL', 'NORMAL', 'GIMBAL', 'VIEW', 'CURSOR', 'PARENT'] | None
+    :type orient_type: bpy.typing.TransformOrientationItems | None
     :param orient_matrix: Matrix
     :type orient_matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix | None
     :param orient_matrix_type: Matrix Orientation
-    :type orient_matrix_type: typing.Literal['GLOBAL', 'LOCAL', 'NORMAL', 'GIMBAL', 'VIEW', 'CURSOR', 'PARENT'] | None
+    :type orient_matrix_type: bpy.typing.TransformOrientationItems | None
     :param constraint_axis: Constraint Axis
     :type constraint_axis: collections.abc.Iterable[bool] | None
     :param mirror: Mirror Editing
@@ -1499,7 +1199,7 @@ def translate(
     :param use_proportional_edit: Proportional Editing
     :type use_proportional_edit: bool | None
     :param proportional_edit_falloff: Proportional Falloff, Falloff type for proportional editing mode
-    :type proportional_edit_falloff: typing.Literal['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'] | None
+    :type proportional_edit_falloff: bpy.typing.ProportionalFalloffItems | None
     :param proportional_size: Proportional Size
     :type proportional_size: float | None
     :param use_proportional_connected: Connected
@@ -1509,11 +1209,11 @@ def translate(
     :param snap: Use Snapping Options
     :type snap: bool | None
     :param snap_elements: Snap to Elements
-    :type snap_elements: set[typing.Literal['INCREMENT', 'GRID', 'VERTEX', 'EDGE', 'FACE', 'VOLUME', 'EDGE_MIDPOINT', 'EDGE_PERPENDICULAR', 'FACE_PROJECT', 'FACE_NEAREST']] | None
+    :type snap_elements: set[bpy.typing.SnapElementItems] | None
     :param use_snap_project: Project Individual Elements
     :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
-    :type snap_target: typing.Literal['CLOSEST', 'CENTER', 'MEDIAN', 'ACTIVE'] | None
+    :type snap_target: bpy.typing.SnapSourceItems | None
     :param use_snap_self: Target: Include Active
     :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
@@ -1548,8 +1248,6 @@ def translate(
     :type use_automerge_and_split: bool | None
     """
 
-    ...
-
 def vert_crease(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -1575,8 +1273,6 @@ def vert_crease(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def vert_slide(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -1588,24 +1284,9 @@ def vert_slide(
     use_clamp: bool | None = True,
     mirror: bool | None = False,
     snap: bool | None = False,
-    snap_elements: set[
-        typing.Literal[
-            "INCREMENT",
-            "GRID",
-            "VERTEX",
-            "EDGE",
-            "FACE",
-            "VOLUME",
-            "EDGE_MIDPOINT",
-            "EDGE_PERPENDICULAR",
-            "FACE_PROJECT",
-            "FACE_NEAREST",
-        ]
-    ]
-    | None = {"INCREMENT"},
+    snap_elements: set[bpy.typing.SnapElementItems] | None = {"INCREMENT"},
     use_snap_project: bool | None = False,
-    snap_target: typing.Literal["CLOSEST", "CENTER", "MEDIAN", "ACTIVE"]
-    | None = "CLOSEST",
+    snap_target: bpy.typing.SnapSourceItems | None = "CLOSEST",
     use_snap_self: bool | None = True,
     use_snap_edit: bool | None = True,
     use_snap_nonedit: bool | None = True,
@@ -1637,11 +1318,11 @@ def vert_slide(
     :param snap: Use Snapping Options
     :type snap: bool | None
     :param snap_elements: Snap to Elements
-    :type snap_elements: set[typing.Literal['INCREMENT', 'GRID', 'VERTEX', 'EDGE', 'FACE', 'VOLUME', 'EDGE_MIDPOINT', 'EDGE_PERPENDICULAR', 'FACE_PROJECT', 'FACE_NEAREST']] | None
+    :type snap_elements: set[bpy.typing.SnapElementItems] | None
     :param use_snap_project: Project Individual Elements
     :type use_snap_project: bool | None
     :param snap_target: Snap Base, Point on source that will snap to target
-    :type snap_target: typing.Literal['CLOSEST', 'CENTER', 'MEDIAN', 'ACTIVE'] | None
+    :type snap_target: bpy.typing.SnapSourceItems | None
     :param use_snap_self: Target: Include Active
     :type use_snap_self: bool | None
     :param use_snap_edit: Target: Include Edit
@@ -1660,8 +1341,6 @@ def vert_slide(
     :type use_accurate: bool | None
     """
 
-    ...
-
 def vertex_random(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -1690,8 +1369,6 @@ def vertex_random(
     :type wait_for_input: bool | None
     """
 
-    ...
-
 def vertex_warp(
     override_context: bpy.types.Context | dict[str, typing.Any] = None,
     execution_context: int | str | None = None,
@@ -1729,5 +1406,3 @@ def vertex_warp(
     :param center: Center
     :type center: collections.abc.Sequence[float] | mathutils.Vector | None
     """
-
-    ...