fake-bpy-module 20241207__py3-none-any.whl → 20241209__py3-none-any.whl

bpy/ops/graph/__init__.pyi

@@ -5,28 +5,22 @@ import bpy.ops.transform
 import bpy.types
 import bpy.typing
 
-def bake_keys(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def bake_keys(execution_context: int | str | None = None, undo: bool | None = None):
     """Add keyframes on every frame between the selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def blend_offset(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
 ):
     """Shift selected keys to the value of the neighboring keys as a block
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Offset Factor, Control which key to offset towards and how far
@@ -34,15 +28,14 @@ def blend_offset(
     """
 
 def blend_to_default(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
 ):
     """Blend selected keys to their default value from their current position
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Factor, How much to blend to the default value
@@ -50,15 +43,14 @@ def blend_to_default(
     """
 
 def blend_to_ease(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
 ):
     """Blends keyframes from current state to an ease-in or ease-out curve
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Blend, Favor either original data or ease curve
@@ -66,15 +58,14 @@ def blend_to_ease(
     """
 
 def blend_to_neighbor(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
 ):
     """Blend selected keyframes to their left or right neighbor
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Blend, The blend factor with 0 being the current frame
@@ -82,15 +73,14 @@ def blend_to_neighbor(
     """
 
 def breakdown(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
 ):
     """Move selected keyframes to an inbetween position relative to adjacent keys
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Factor, Favor either the left or the right key
@@ -98,9 +88,9 @@ def breakdown(
     """
 
 def butterworth_smooth(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     cutoff_frequency: float | None = 3.0,
     filter_order: int | None = 4,
@@ -110,7 +100,6 @@ def butterworth_smooth(
 ):
     """Smooth an F-Curve while maintaining the general shape of the curve
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param cutoff_frequency: Frequency Cutoff (Hz), Lower values give a smoother curve
@@ -126,16 +115,15 @@ def butterworth_smooth(
     """
 
 def clean(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     threshold: float | None = 0.001,
     channels: bool | None = False,
 ):
     """Simplify F-Curves by removing closely spaced keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param threshold: Threshold
@@ -145,9 +133,9 @@ def clean(
     """
 
 def click_insert(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     frame: float | None = 1.0,
     value: float | None = 1.0,
@@ -155,7 +143,6 @@ def click_insert(
 ):
     """Insert new keyframe at the cursor position for the active F-Curve
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param frame: Frame Number, Frame to insert keyframe on
@@ -167,9 +154,9 @@ def click_insert(
     """
 
 def clickselect(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     wait_to_deselect_others: bool | None = False,
     mouse_x: int | None = 0,
@@ -181,7 +168,6 @@ def clickselect(
 ):
     """Select keyframes by clicking on them
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param wait_to_deselect_others: Wait to Deselect Others
@@ -200,29 +186,23 @@ def clickselect(
     :type curves: bool | None
     """
 
-def copy(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def copy(execution_context: int | str | None = None, undo: bool | None = None):
     """Copy selected keyframes to the internal clipboard
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def cursor_set(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     frame: float | None = 0.0,
     value: float | None = 0.0,
 ):
     """Interactively set the current frame and value cursor
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param frame: Frame
@@ -232,9 +212,9 @@ def cursor_set(
     """
 
 def decimate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["RATIO", "ERROR"] | None = "RATIO",
     factor: float | None = 0.333333,
@@ -242,7 +222,6 @@ def decimate(
 ):
     """Decimate F-Curves by removing keyframes that influence the curve shape the least
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param mode: Mode, Which mode to use for decimation
@@ -260,15 +239,14 @@ def decimate(
     """
 
 def delete(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     confirm: bool | None = True,
 ):
     """Remove all selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param confirm: Confirm, Prompt for confirmation
@@ -276,39 +254,32 @@ def delete(
     """
 
 def driver_delete_invalid(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Delete all visible drivers considered invalid
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def driver_variables_copy(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Copy the driver variables of the active driver
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def driver_variables_paste(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     replace: bool | None = False,
 ):
     """Add copied driver variables to the active driver
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param replace: Replace Existing, Replace existing driver variables, instead of just appending to the end of the existing list
@@ -316,15 +287,14 @@ def driver_variables_paste(
     """
 
 def duplicate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: bpy.typing.TransformModeTypeItems | None = "TRANSLATION",
 ):
     """Make a copy of all selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -332,16 +302,15 @@ def duplicate(
     """
 
 def duplicate_move(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     GRAPH_OT_duplicate: duplicate | None = None,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
 ):
     """Make a copy of all selected keyframes and move them
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param GRAPH_OT_duplicate: Duplicate Keyframes, Make a copy of all selected keyframes
@@ -351,16 +320,15 @@ def duplicate_move(
     """
 
 def ease(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
     sharpness: float | None = 2.0,
 ):
     """Align keyframes on a ease-in or ease-out curve
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Curve Bend, Defines if the keys should be aligned on an ease-in or ease-out curve
@@ -370,15 +338,14 @@ def ease(
     """
 
 def easing_type(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: bpy.typing.BeztripleInterpolationEasingItems | None = "AUTO",
 ):
     """Set easing type for the F-Curve segments starting from the selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param type: Type
@@ -386,9 +353,9 @@ def easing_type(
     """
 
 def equalize_handles(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     side: typing.Literal["LEFT", "RIGHT", "BOTH"] | None = "LEFT",
     handle_length: float | None = 5.0,
@@ -396,7 +363,6 @@ def equalize_handles(
 ):
     """Ensure selected keyframes' handles have equal length, optionally making them horizontal. Automatic, Automatic Clamped, or Vector handle types will be converted to Aligned
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param side: Side, Side of the keyframes' Bézier handles to affect
@@ -416,29 +382,23 @@ def equalize_handles(
         :type flatten: bool | None
     """
 
-def euler_filter(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def euler_filter(execution_context: int | str | None = None, undo: bool | None = None):
     """Fix large jumps and flips in the selected Euler Rotation F-Curves arising from rotation values being clipped when baking physics
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def extrapolation_type(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["CONSTANT", "LINEAR", "MAKE_CYCLIC", "CLEAR_CYCLIC"]
     | None = "CONSTANT",
 ):
     """Set extrapolation mode for selected F-Curves
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type
@@ -458,16 +418,15 @@ def extrapolation_type(
     """
 
 def fmodifier_add(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: bpy.typing.FmodifierTypeItems | None = "NULL",
     only_active: bool | None = False,
 ):
     """Add F-Modifier to the active/selected F-Curves
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param type: Type
@@ -477,28 +436,24 @@ def fmodifier_add(
     """
 
 def fmodifier_copy(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Copy the F-Modifier(s) of the active F-Curve
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def fmodifier_paste(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     only_active: bool | None = False,
     replace: bool | None = False,
 ):
     """Add copied F-Modifiers to the selected F-Curves
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param only_active: Only Active, Only paste F-Modifiers on active F-Curve
@@ -507,22 +462,17 @@ def fmodifier_paste(
     :type replace: bool | None
     """
 
-def frame_jump(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def frame_jump(execution_context: int | str | None = None, undo: bool | None = None):
     """Place the cursor on the midpoint of selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def gaussian_smooth(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 1.0,
     sigma: float | None = 0.33,
@@ -530,7 +480,6 @@ def gaussian_smooth(
 ):
     """Smooth the curve using a Gaussian filter
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Factor, How much to blend to the default value
@@ -542,39 +491,32 @@ def gaussian_smooth(
     """
 
 def ghost_curves_clear(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Clear F-Curve snapshots (Ghosts) for active Graph Editor
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def ghost_curves_create(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def handle_type(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: bpy.typing.KeyframeHandleTypeItems | None = "FREE",
 ):
     """Set type of handle for selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param type: Type
@@ -582,15 +524,14 @@ def handle_type(
     """
 
 def hide(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     unselected: bool | None = False,
 ):
     """Hide selected curves from Graph Editor view
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param unselected: Unselected, Hide unselected rather than selected curves
@@ -598,15 +539,14 @@ def hide(
     """
 
 def interpolation_type(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: bpy.typing.BeztripleInterpolationModeItems | None = "CONSTANT",
 ):
     """Set interpolation mode for the F-Curve segments starting from the selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param type: Type
@@ -614,16 +554,15 @@ def interpolation_type(
     """
 
 def keyframe_insert(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["ALL", "SEL", "ACTIVE", "CURSOR_ACTIVE", "CURSOR_SEL"]
     | None = "ALL",
 ):
     """Insert keyframes for the specified channels
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type
@@ -646,15 +585,14 @@ def keyframe_insert(
     """
 
 def keyframe_jump(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     next: bool | None = True,
 ):
     """Jump to previous/next keyframe
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param next: Next Keyframe
@@ -662,27 +600,23 @@ def keyframe_jump(
     """
 
 def keys_to_samples(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Convert selected channels to an uneditable set of samples to save storage space
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def match_slope(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
 ):
     """Blend selected keys to the slope of neighboring ones
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Factor, Defines which keys to use as slope and how much to blend towards them
@@ -690,15 +624,14 @@ def match_slope(
     """
 
 def mirror(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["CFRA", "VALUE", "YAXIS", "XAXIS", "MARKER"] | None = "CFRA",
 ):
     """Flip selected keyframes over the selected mirror line
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type
@@ -721,9 +654,9 @@ def mirror(
     """
 
 def paste(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     offset: bpy.typing.KeyframePasteOffsetItems | None = "START",
     value_offset: bpy.typing.KeyframePasteOffsetValueItems | None = "NONE",
@@ -732,7 +665,6 @@ def paste(
 ):
     """Paste keyframes from the internal clipboard for the selected channels, starting on the current frame
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param offset: Frame Offset, Paste time offset of keys
@@ -746,27 +678,23 @@ def paste(
     """
 
 def previewrange_set(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Set Preview Range based on range of selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def push_pull(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 1.0,
 ):
     """Exaggerate or minimize the value of the selected keys
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Factor, Control how far to push or pull the keys
@@ -774,15 +702,14 @@ def push_pull(
     """
 
 def reveal(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     select: bool | None = True,
 ):
     """Make previously hidden curves visible again in Graph Editor view
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param select: Select
@@ -790,27 +717,23 @@ def reveal(
     """
 
 def samples_to_keys(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Convert selected channels from samples to keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def scale_average(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 1.0,
 ):
     """Scale selected key values by their combined average
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Scale Factor, The scale factor applied to the curve segments
@@ -818,16 +741,15 @@ def scale_average(
     """
 
 def scale_from_neighbor(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
     anchor: typing.Literal["LEFT", "RIGHT"] | None = "LEFT",
 ):
     """Increase or decrease the value of selected keys in relationship to the neighboring one
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Factor, The factor to scale keys with
@@ -837,15 +759,14 @@ def scale_from_neighbor(
     """
 
 def select_all(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"] | None = "TOGGLE",
 ):
     """Toggle selection of all keyframes
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param action: Action, Selection action to execute
@@ -865,9 +786,9 @@ def select_all(
     """
 
 def select_box(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     axis_range: bool | None = False,
     include_handles: bool | None = True,
@@ -882,7 +803,6 @@ def select_box(
 ):
     """Select all keyframes within the specified region
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param axis_range: Axis Range
@@ -917,9 +837,9 @@ def select_box(
     """
 
 def select_circle(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     x: int | None = 0,
     y: int | None = 0,
@@ -930,7 +850,6 @@ def select_circle(
 ):
     """Select keyframe points using circle selection
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param x: X
@@ -957,16 +876,15 @@ def select_circle(
     """
 
 def select_column(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["KEYS", "CFRA", "MARKERS_COLUMN", "MARKERS_BETWEEN"]
     | None = "KEYS",
 ):
     """Select all keyframes on the specified frame(s)
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -974,9 +892,9 @@ def select_column(
     """
 
 def select_key_handles(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     left_handle_action: typing.Literal["SELECT", "DESELECT", "KEEP"] | None = "SELECT",
     right_handle_action: typing.Literal["SELECT", "DESELECT", "KEEP"] | None = "SELECT",
@@ -984,7 +902,6 @@ def select_key_handles(
 ):
     """For selected keyframes, select/deselect any combination of the key itself and its handles
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param left_handle_action: Left Handle, Effect on the left handle
@@ -1023,9 +940,9 @@ def select_key_handles(
     """
 
 def select_lasso(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None = None,
     use_smooth_stroke: bool | None = False,
@@ -1036,7 +953,6 @@ def select_lasso(
 ):
     """Select keyframe points using lasso selection
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param path: Path
@@ -1063,16 +979,15 @@ def select_lasso(
     """
 
 def select_leftright(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["CHECK", "LEFT", "RIGHT"] | None = "CHECK",
     extend: bool | None = False,
 ):
     """Select keyframes to the left or the right of the current frame
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -1081,53 +996,37 @@ def select_leftright(
     :type extend: bool | None
     """
 
-def select_less(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def select_less(execution_context: int | str | None = None, undo: bool | None = None):
     """Deselect keyframes on ends of selection islands
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
-def select_linked(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def select_linked(execution_context: int | str | None = None, undo: bool | None = None):
     """Select keyframes occurring in the same F-Curves as selected ones
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
-def select_more(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def select_more(execution_context: int | str | None = None, undo: bool | None = None):
     """Select keyframes beside already selected ones
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def shear(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     factor: float | None = 0.0,
     direction: typing.Literal["FROM_LEFT", "FROM_RIGHT"] | None = "FROM_LEFT",
 ):
     """Affect the value of the keys linearly, keeping the same relationship between them using either the left or the right key as reference
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param factor: Shear Factor, The amount of shear to apply
@@ -1142,22 +1041,17 @@ def shear(
         :type direction: typing.Literal['FROM_LEFT','FROM_RIGHT'] | None
     """
 
-def smooth(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def smooth(execution_context: int | str | None = None, undo: bool | None = None):
     """Apply weighted moving means to make selected F-Curves less bumpy
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def snap(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal[
         "CFRA",
@@ -1171,7 +1065,6 @@ def snap(
 ):
     """Snap selected keyframes to the chosen times/values
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type
@@ -1197,21 +1090,18 @@ def snap(
     """
 
 def snap_cursor_value(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
+    execution_context: int | str | None = None, undo: bool | None = None
 ):
     """Place the cursor value on the average value of selected keyframes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def sound_to_samples(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     filepath: str = "",
     check_existing: bool | None = False,
@@ -1252,7 +1142,6 @@ def sound_to_samples(
 ):
     """Bakes a sound wave to samples on selected channels
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param filepath: File Path, Path to file
@@ -1336,15 +1225,14 @@ def sound_to_samples(
     """
 
 def time_offset(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     frame_offset: float | None = 0.0,
 ):
     """Shifts the value of selected keys in time
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param frame_offset: Frame Offset, How far in frames to offset the animation
@@ -1352,43 +1240,36 @@ def time_offset(
     """
 
 def view_all(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     include_handles: bool | None = True,
 ):
     """Reset viewable area to show full keyframe range
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param include_handles: Include Handles, Include handles of keyframes when calculating extents
     :type include_handles: bool | None
     """
 
-def view_frame(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def view_frame(execution_context: int | str | None = None, undo: bool | None = None):
     """Move the view to the current frame
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def view_selected(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     include_handles: bool | None = True,
 ):
     """Reset viewable area to show selected keyframe range
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param include_handles: Include Handles, Include handles of keyframes when calculating extents