fake-bge-module 20250317__py3-none-any.whl → 20260201__py3-none-any.whl

bpy/ops/graph/__init__.pyi

@@ -1,16 +1,17 @@
 import typing
 import collections.abc
 import typing_extensions
-import bpy._typing.rna_enums
+import numpy.typing as npt
 import bpy.ops.transform
+import bpy.stub_internal.rna_enums
 import bpy.types
 
-def bake_keys(execution_context: int | str | None = None, undo: bool | None = None):
-    """Add keyframes on every frame between the selected keyframes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def bake_keys(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Add keyframes on every frame between the selected keyframes"""
 
 def blend_offset(
     execution_context: int | str | None = None,
@@ -18,13 +19,10 @@ def blend_offset(
     /,
     *,
     factor: float | None = 0.0,
-):
+) -> None:
     """Shift selected keys to the value of the neighboring keys as a block
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Offset Factor, Control which key to offset towards and how far
-    :type factor: float | None
     """
 
 def blend_to_default(
@@ -33,13 +31,10 @@ def blend_to_default(
     /,
     *,
     factor: float | None = 0.0,
-):
+) -> None:
     """Blend selected keys to their default value from their current position
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Factor, How much to blend to the default value
-    :type factor: float | None
     """
 
 def blend_to_ease(
@@ -48,13 +43,10 @@ def blend_to_ease(
     /,
     *,
     factor: float | None = 0.0,
-):
+) -> None:
     """Blends keyframes from current state to an ease-in or ease-out curve
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Blend, Favor either original data or ease curve
-    :type factor: float | None
     """
 
 def blend_to_neighbor(
@@ -63,13 +55,10 @@ def blend_to_neighbor(
     /,
     *,
     factor: float | None = 0.0,
-):
+) -> None:
     """Blend selected keyframes to their left or right neighbor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Blend, The blend factor with 0 being the current frame
-    :type factor: float | None
     """
 
 def breakdown(
@@ -78,13 +67,10 @@ def breakdown(
     /,
     *,
     factor: float | None = 0.0,
-):
+) -> None:
     """Move selected keyframes to an inbetween position relative to adjacent keys
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Factor, Favor either the left or the right key
-    :type factor: float | None
     """
 
 def butterworth_smooth(
@@ -97,21 +83,14 @@ def butterworth_smooth(
     samples_per_frame: int | None = 1,
     blend: float | None = 1.0,
     blend_in_out: int | None = 1,
-):
+) -> None:
     """Smooth an F-Curve while maintaining the general shape of the curve
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param cutoff_frequency: Frequency Cutoff (Hz), Lower values give a smoother curve
-    :type cutoff_frequency: float | None
     :param filter_order: Filter Order, Higher values produce a harder frequency cutoff
-    :type filter_order: int | None
     :param samples_per_frame: Samples per Frame, How many samples to calculate per frame, helps with subframe data
-    :type samples_per_frame: int | None
     :param blend: Blend, How much to blend to the smoothed curve
-    :type blend: float | None
     :param blend_in_out: Blend In/Out, Linearly blend the smooth data to the border frames of the selection
-    :type blend_in_out: int | None
     """
 
 def clean(
@@ -121,15 +100,11 @@ def clean(
     *,
     threshold: float | None = 0.001,
     channels: bool | None = False,
-):
+) -> None:
     """Simplify F-Curves by removing closely spaced keyframes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param threshold: Threshold
-    :type threshold: float | None
     :param channels: Channels
-    :type channels: bool | None
     """
 
 def click_insert(
@@ -140,17 +115,12 @@ def click_insert(
     frame: float | None = 1.0,
     value: float | None = 1.0,
     extend: bool | None = False,
-):
+) -> None:
     """Insert new keyframe at the cursor position for the active F-Curve
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param frame: Frame Number, Frame to insert keyframe on
-    :type frame: float | None
     :param value: Value, Value for keyframe on
-    :type value: float | None
     :param extend: Extend, Extend selection instead of deselecting everything first
-    :type extend: bool | None
     """
 
 def clickselect(
@@ -159,39 +129,32 @@ def clickselect(
     /,
     *,
     wait_to_deselect_others: bool | None = False,
+    use_select_on_click: bool | None = False,
     mouse_x: int | None = 0,
     mouse_y: int | None = 0,
     extend: bool | None = False,
     deselect_all: bool | None = False,
     column: bool | None = False,
     curves: bool | None = False,
-):
+) -> None:
     """Select keyframes by clicking on them
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param wait_to_deselect_others: Wait to Deselect Others
-    :type wait_to_deselect_others: bool | None
+    :param use_select_on_click: Act on Click, Instead of selecting on mouse press, wait to see if theres drag event. Otherwise select on mouse release
     :param mouse_x: Mouse X
-    :type mouse_x: int | None
     :param mouse_y: Mouse Y
-    :type mouse_y: int | None
     :param extend: Extend Select, Toggle keyframe selection instead of leaving newly selected keyframes only
-    :type extend: bool | None
     :param deselect_all: Deselect On Nothing, Deselect all when nothing under the cursor
-    :type deselect_all: bool | None
     :param column: Column Select, Select all keyframes that occur on the same frame as the one under the mouse
-    :type column: bool | None
     :param curves: Only Curves, Select all the keyframes in the curve
-    :type curves: bool | None
     """
 
-def copy(execution_context: int | str | None = None, undo: bool | None = None):
-    """Copy selected keyframes to the internal clipboard
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def copy(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Copy selected keyframes to the internal clipboard"""
 
 def cursor_set(
     execution_context: int | str | None = None,
@@ -200,15 +163,11 @@ def cursor_set(
     *,
     frame: float | None = 0.0,
     value: float | None = 0.0,
-):
+) -> None:
     """Interactively set the current frame and value cursor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param frame: Frame
-    :type frame: float | None
     :param value: Value
-    :type value: float | None
     """
 
 def decimate(
@@ -219,11 +178,9 @@ def decimate(
     mode: typing.Literal["RATIO", "ERROR"] | None = "RATIO",
     factor: float | None = 0.333333,
     remove_error_margin: float | None = 0.0,
-):
+) -> None:
     """Decimate F-Curves by removing keyframes that influence the curve shape the least
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param mode: Mode, Which mode to use for decimation
 
     RATIO
@@ -231,11 +188,8 @@ def decimate(
 
     ERROR
     Error Margin -- Use an error margin to specify how much the curve is allowed to deviate from the original path.
-        :type mode: typing.Literal['RATIO','ERROR'] | None
         :param factor: Factor, The ratio of keyframes to remove
-        :type factor: float | None
         :param remove_error_margin: Max Error Margin, How much the new decimated curve is allowed to deviate from the original
-        :type remove_error_margin: float | None
     """
 
 def delete(
@@ -244,32 +198,25 @@ def delete(
     /,
     *,
     confirm: bool | None = True,
-):
+) -> None:
     """Remove all selected keyframes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param confirm: Confirm, Prompt for confirmation
-    :type confirm: bool | None
     """
 
 def driver_delete_invalid(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Delete all visible drivers considered invalid
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Delete all visible drivers considered invalid"""
 
 def driver_variables_copy(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Copy the driver variables of the active driver
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Copy the driver variables of the active driver"""
 
 def driver_variables_paste(
     execution_context: int | str | None = None,
@@ -277,13 +224,10 @@ def driver_variables_paste(
     /,
     *,
     replace: bool | None = False,
-):
+) -> None:
     """Add copied driver variables to the active driver
 
-    :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
-    :type replace: bool | None
     """
 
 def duplicate(
@@ -291,14 +235,11 @@ def duplicate(
     undo: bool | None = None,
     /,
     *,
-    mode: bpy._typing.rna_enums.TransformModeTypeItems | None = "TRANSLATION",
-):
+    mode: bpy.stub_internal.rna_enums.TransformModeTypeItems | None = "TRANSLATION",
+) -> None:
     """Make a copy of all selected keyframes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param mode: Mode
-    :type mode: bpy._typing.rna_enums.TransformModeTypeItems | None
     """
 
 def duplicate_move(
@@ -308,15 +249,11 @@ def duplicate_move(
     *,
     GRAPH_OT_duplicate: duplicate | None = None,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
-):
+) -> None:
     """Make a copy of all selected keyframes and move them
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param GRAPH_OT_duplicate: Duplicate Keyframes, Make a copy of all selected keyframes
-    :type GRAPH_OT_duplicate: duplicate | None
     :param TRANSFORM_OT_translate: Move, Move selected items
-    :type TRANSFORM_OT_translate: bpy.ops.transform.translate | None
     """
 
 def ease(
@@ -326,15 +263,11 @@ def ease(
     *,
     factor: float | None = 0.0,
     sharpness: float | None = 2.0,
-):
+) -> None:
     """Align keyframes on a ease-in or ease-out curve
 
-    :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
-    :type factor: float | None
     :param sharpness: Sharpness, Higher values make the change more abrupt
-    :type sharpness: float | None
     """
 
 def easing_type(
@@ -342,14 +275,11 @@ def easing_type(
     undo: bool | None = None,
     /,
     *,
-    type: bpy._typing.rna_enums.BeztripleInterpolationEasingItems | None = "AUTO",
-):
+    type: bpy.stub_internal.rna_enums.BeztripleInterpolationEasingItems | None = "AUTO",
+) -> None:
     """Set easing type for the F-Curve segments starting from the selected keyframes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Type
-    :type type: bpy._typing.rna_enums.BeztripleInterpolationEasingItems | None
     """
 
 def equalize_handles(
@@ -360,34 +290,29 @@ def equalize_handles(
     side: typing.Literal["LEFT", "RIGHT", "BOTH"] | None = "LEFT",
     handle_length: float | None = 5.0,
     flatten: bool | None = False,
-):
-    """Ensure selected keyframes' handles have equal length, optionally making them horizontal. Automatic, Automatic Clamped, or Vector handle types will be converted to Aligned
+) -> None:
+    """Ensure selected keyframes handles have equal length, optionally making them horizontal. Automatic, Automatic Clamped, or Vector handle types will be converted to Aligned
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
-        :param side: Side, Side of the keyframes' Bézier handles to affect
+        :param side: Side, Side of the keyframes Bézier handles to affect
 
     LEFT
-    Left -- Equalize selected keyframes' left handles.
+    Left -- Equalize selected keyframes left handles.
 
     RIGHT
-    Right -- Equalize selected keyframes' right handles.
+    Right -- Equalize selected keyframes right handles.
 
     BOTH
-    Both -- Equalize both of a keyframe's handles.
-        :type side: typing.Literal['LEFT','RIGHT','BOTH'] | None
-        :param handle_length: Handle Length, Length to make selected keyframes' Bézier handles
-        :type handle_length: float | None
-        :param flatten: Flatten, Make the values of the selected keyframes' handles the same as their respective keyframes
-        :type flatten: bool | None
+    Both -- Equalize both of a keyframes handles.
+        :param handle_length: Handle Length, Length to make selected keyframes Bézier handles
+        :param flatten: Flatten, Make the values of the selected keyframes handles the same as their respective keyframes
     """
 
-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 execution_context: int | str | None
-    :type undo: bool | None
-    """
+def euler_filter(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Fix large jumps and flips in the selected Euler Rotation F-Curves arising from rotation values being clipped when baking physics"""
 
 def extrapolation_type(
     execution_context: int | str | None = None,
@@ -396,11 +321,9 @@ def extrapolation_type(
     *,
     type: typing.Literal["CONSTANT", "LINEAR", "MAKE_CYCLIC", "CLEAR_CYCLIC"]
     | None = "CONSTANT",
-):
+) -> None:
     """Set extrapolation mode for selected F-Curves
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param type: Type
 
     CONSTANT
@@ -410,11 +333,10 @@ def extrapolation_type(
     Linear Extrapolation -- Straight-line slope of end segments are extended past the endpoint keyframes.
 
     MAKE_CYCLIC
-    Make Cyclic (F-Modifier) -- Add Cycles F-Modifier if one doesn't exist already.
+    Make Cyclic (F-Modifier) -- Add Cycles F-Modifier if one does not exist already.
 
     CLEAR_CYCLIC
     Clear Cyclic (F-Modifier) -- Remove Cycles F-Modifier if not needed anymore.
-        :type type: typing.Literal['CONSTANT','LINEAR','MAKE_CYCLIC','CLEAR_CYCLIC'] | None
     """
 
 def fmodifier_add(
@@ -422,27 +344,21 @@ def fmodifier_add(
     undo: bool | None = None,
     /,
     *,
-    type: bpy._typing.rna_enums.FmodifierTypeItems | None = "NULL",
+    type: bpy.stub_internal.rna_enums.FmodifierTypeItems | None = "NULL",
     only_active: bool | None = False,
-):
+) -> None:
     """Add F-Modifier to the active/selected F-Curves
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Type
-    :type type: bpy._typing.rna_enums.FmodifierTypeItems | None
     :param only_active: Only Active, Only add F-Modifier to active F-Curve
-    :type only_active: bool | None
     """
 
 def fmodifier_copy(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Copy the F-Modifier(s) of the active F-Curve
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Copy the F-Modifier(s) of the active F-Curve"""
 
 def fmodifier_paste(
     execution_context: int | str | None = None,
@@ -451,23 +367,19 @@ def fmodifier_paste(
     *,
     only_active: bool | None = False,
     replace: bool | None = False,
-):
+) -> None:
     """Add copied F-Modifiers to the selected F-Curves
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param only_active: Only Active, Only paste F-Modifiers on active F-Curve
-    :type only_active: bool | None
     :param replace: Replace Existing, Replace existing F-Modifiers, instead of just appending to the end of the existing list
-    :type replace: bool | None
     """
 
-def frame_jump(execution_context: int | str | None = None, undo: bool | None = None):
-    """Place the cursor on the midpoint of selected keyframes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def frame_jump(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Place the cursor on the midpoint of selected keyframes"""
 
 def gaussian_smooth(
     execution_context: int | str | None = None,
@@ -477,50 +389,38 @@ def gaussian_smooth(
     factor: float | None = 1.0,
     sigma: float | None = 0.33,
     filter_width: int | None = 6,
-):
+) -> None:
     """Smooth the curve using a Gaussian filter
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Factor, How much to blend to the default value
-    :type factor: float | None
     :param sigma: Sigma, The shape of the gaussian distribution, lower values make it sharper
-    :type sigma: float | None
     :param filter_width: Filter Width, How far to each side the operator will average the key values
-    :type filter_width: int | None
     """
 
 def ghost_curves_clear(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Clear F-Curve snapshots (Ghosts) for active Graph Editor
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Clear F-Curve snapshots (Ghosts) for active Graph Editor"""
 
 def ghost_curves_create(
-    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 execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor"""
 
 def handle_type(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
-    type: bpy._typing.rna_enums.KeyframeHandleTypeItems | None = "FREE",
-):
+    type: bpy.stub_internal.rna_enums.KeyframeHandleTypeItems | None = "FREE",
+) -> None:
     """Set type of handle for selected keyframes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Type
-    :type type: bpy._typing.rna_enums.KeyframeHandleTypeItems | None
     """
 
 def hide(
@@ -529,13 +429,10 @@ def hide(
     /,
     *,
     unselected: bool | None = False,
-):
+) -> None:
     """Hide selected curves from Graph Editor view
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param unselected: Unselected, Hide unselected rather than selected curves
-    :type unselected: bool | None
     """
 
 def interpolation_type(
@@ -543,14 +440,12 @@ def interpolation_type(
     undo: bool | None = None,
     /,
     *,
-    type: bpy._typing.rna_enums.BeztripleInterpolationModeItems | None = "CONSTANT",
-):
+    type: bpy.stub_internal.rna_enums.BeztripleInterpolationModeItems
+    | None = "CONSTANT",
+) -> None:
     """Set interpolation mode for the F-Curve segments starting from the selected keyframes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Type
-    :type type: bpy._typing.rna_enums.BeztripleInterpolationModeItems | None
     """
 
 def keyframe_insert(
@@ -560,28 +455,25 @@ def keyframe_insert(
     *,
     type: typing.Literal["ALL", "SEL", "ACTIVE", "CURSOR_ACTIVE", "CURSOR_SEL"]
     | None = "ALL",
-):
+) -> None:
     """Insert keyframes for the specified channels
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param type: Type
 
     ALL
-    All Channels -- Insert a keyframe on all visible and editable F-Curves using each curve's current value.
+    All Channels -- Insert a keyframe on all visible and editable F-Curves using each curves current value.
 
     SEL
-    Only Selected Channels -- Insert a keyframe on selected F-Curves using each curve's current value.
+    Only Selected Channels -- Insert a keyframe on selected F-Curves using each curves current value.
 
     ACTIVE
-    Only Active F-Curve -- Insert a keyframe on the active F-Curve using the curve's current value.
+    Only Active F-Curve -- Insert a keyframe on the active F-Curve using the curves current value.
 
     CURSOR_ACTIVE
     Active Channels at Cursor -- Insert a keyframe for the active F-Curve at the cursor point.
 
     CURSOR_SEL
     Selected Channels at Cursor -- Insert a keyframe for selected F-Curves at the cursor point.
-        :type type: typing.Literal['ALL','SEL','ACTIVE','CURSOR_ACTIVE','CURSOR_SEL'] | None
     """
 
 def keyframe_jump(
@@ -590,23 +482,18 @@ def keyframe_jump(
     /,
     *,
     next: bool | None = True,
-):
+) -> None:
     """Jump to previous/next keyframe
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param next: Next Keyframe
-    :type next: bool | None
     """
 
 def keys_to_samples(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Convert selected channels to an uneditable set of samples to save storage space
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Convert selected channels to an uneditable set of samples to save storage space"""
 
 def match_slope(
     execution_context: int | str | None = None,
@@ -614,13 +501,10 @@ def match_slope(
     /,
     *,
     factor: float | None = 0.0,
-):
+) -> None:
     """Blend selected keys to the slope of neighboring ones
 
-    :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
-    :type factor: float | None
     """
 
 def mirror(
@@ -629,11 +513,9 @@ def mirror(
     /,
     *,
     type: typing.Literal["CFRA", "VALUE", "YAXIS", "XAXIS", "MARKER"] | None = "CFRA",
-):
+) -> None:
     """Flip selected keyframes over the selected mirror line
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param type: Type
 
     CFRA
@@ -650,7 +532,6 @@ def mirror(
 
     MARKER
     By Times Over First Selected Marker -- Flip times of selected keyframes using the first selected marker as the reference point.
-        :type type: typing.Literal['CFRA','VALUE','YAXIS','XAXIS','MARKER'] | None
     """
 
 def paste(
@@ -658,33 +539,26 @@ def paste(
     undo: bool | None = None,
     /,
     *,
-    offset: bpy._typing.rna_enums.KeyframePasteOffsetItems | None = "START",
-    value_offset: bpy._typing.rna_enums.KeyframePasteOffsetValueItems | None = "NONE",
-    merge: bpy._typing.rna_enums.KeyframePasteMergeItems | None = "MIX",
+    offset: bpy.stub_internal.rna_enums.KeyframePasteOffsetItems | None = "START",
+    value_offset: bpy.stub_internal.rna_enums.KeyframePasteOffsetValueItems
+    | None = "NONE",
+    merge: bpy.stub_internal.rna_enums.KeyframePasteMergeItems | None = "MIX",
     flipped: bool | None = False,
-):
+) -> None:
     """Paste keyframes from the internal clipboard for the selected channels, starting on the current frame
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param offset: Frame Offset, Paste time offset of keys
-    :type offset: bpy._typing.rna_enums.KeyframePasteOffsetItems | None
     :param value_offset: Value Offset, Paste keys with a value offset
-    :type value_offset: bpy._typing.rna_enums.KeyframePasteOffsetValueItems | None
     :param merge: Type, Method of merging pasted keys and existing
-    :type merge: bpy._typing.rna_enums.KeyframePasteMergeItems | None
     :param flipped: Flipped, Paste keyframes from mirrored bones if they exist
-    :type flipped: bool | None
     """
 
 def previewrange_set(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Set Preview Range based on range of selected keyframes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Set Preview Range based on range of selected keyframes"""
 
 def push_pull(
     execution_context: int | str | None = None,
@@ -692,13 +566,10 @@ def push_pull(
     /,
     *,
     factor: float | None = 1.0,
-):
+) -> None:
     """Exaggerate or minimize the value of the selected keys
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Factor, Control how far to push or pull the keys
-    :type factor: float | None
     """
 
 def reveal(
@@ -707,23 +578,18 @@ def reveal(
     /,
     *,
     select: bool | None = True,
-):
+) -> None:
     """Make previously hidden curves visible again in Graph Editor view
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param select: Select
-    :type select: bool | None
     """
 
 def samples_to_keys(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Convert selected channels from samples to keyframes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Convert selected channels from samples to keyframes"""
 
 def scale_average(
     execution_context: int | str | None = None,
@@ -731,13 +597,10 @@ def scale_average(
     /,
     *,
     factor: float | None = 1.0,
-):
+) -> None:
     """Scale selected key values by their combined average
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Scale Factor, The scale factor applied to the curve segments
-    :type factor: float | None
     """
 
 def scale_from_neighbor(
@@ -747,15 +610,11 @@ def scale_from_neighbor(
     *,
     factor: float | None = 0.0,
     anchor: typing.Literal["LEFT", "RIGHT"] | None = "LEFT",
-):
+) -> None:
     """Increase or decrease the value of selected keys in relationship to the neighboring one
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Factor, The factor to scale keys with
-    :type factor: float | None
     :param anchor: Reference Key, Which end of the segment to use as a reference to scale from
-    :type anchor: typing.Literal['LEFT','RIGHT'] | None
     """
 
 def select_all(
@@ -764,11 +623,9 @@ def select_all(
     /,
     *,
     action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"] | None = "TOGGLE",
-):
+) -> None:
     """Toggle selection of all keyframes
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Action, Selection action to execute
 
     TOGGLE
@@ -782,7 +639,6 @@ def select_all(
 
     INVERT
     Invert -- Invert selection of all elements.
-        :type action: typing.Literal['TOGGLE','SELECT','DESELECT','INVERT'] | None
     """
 
 def select_box(
@@ -800,29 +656,18 @@ def select_box(
     ymax: int | None = 0,
     wait_for_input: bool | None = True,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
-):
+) -> None:
     """Select all keyframes within the specified region
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param axis_range: Axis Range
-        :type axis_range: bool | None
-        :param include_handles: Include Handles, Are handles tested individually against the selection criteria
-        :type include_handles: bool | None
+        :param include_handles: Include Handles, Are handles tested individually against the selection criteria, independently from their keys. When unchecked, handles are (de)selected in unison with their keys
         :param tweak: Tweak, Operator has been activated using a click-drag event
-        :type tweak: bool | None
         :param use_curve_selection: Select Curves, Allow selecting all the keyframes of a curve by selecting the calculated F-curve
-        :type use_curve_selection: bool | None
         :param xmin: X Min
-        :type xmin: int | None
         :param xmax: X Max
-        :type xmax: int | None
         :param ymin: Y Min
-        :type ymin: int | None
         :param ymax: Y Max
-        :type ymax: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -833,7 +678,6 @@ def select_box(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
     """
 
 def select_circle(
@@ -846,20 +690,15 @@ def select_circle(
     radius: int | None = 25,
     wait_for_input: bool | None = True,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
+    include_handles: bool | None = True,
     use_curve_selection: bool | None = True,
-):
+) -> None:
     """Select keyframe points using circle selection
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param x: X
-        :type x: int | None
         :param y: Y
-        :type y: int | None
         :param radius: Radius
-        :type radius: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -870,9 +709,8 @@ def select_circle(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
+        :param include_handles: Include Handles, Are handles tested individually against the selection criteria, independently from their keys. When unchecked, handles are (de)selected in unison with their keys
         :param use_curve_selection: Select Curves, Allow selecting all the keyframes of a curve by selecting the curve itself
-        :type use_curve_selection: bool | None
     """
 
 def select_column(
@@ -882,13 +720,10 @@ def select_column(
     *,
     mode: typing.Literal["KEYS", "CFRA", "MARKERS_COLUMN", "MARKERS_BETWEEN"]
     | None = "KEYS",
-):
+) -> None:
     """Select all keyframes on the specified frame(s)
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param mode: Mode
-    :type mode: typing.Literal['KEYS','CFRA','MARKERS_COLUMN','MARKERS_BETWEEN'] | None
     """
 
 def select_key_handles(
@@ -899,11 +734,9 @@ def select_key_handles(
     left_handle_action: typing.Literal["SELECT", "DESELECT", "KEEP"] | None = "SELECT",
     right_handle_action: typing.Literal["SELECT", "DESELECT", "KEEP"] | None = "SELECT",
     key_action: typing.Literal["SELECT", "DESELECT", "KEEP"] | None = "KEEP",
-):
+) -> None:
     """For selected keyframes, select/deselect any combination of the key itself and its handles
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param left_handle_action: Left Handle, Effect on the left handle
 
     SELECT
@@ -914,7 +747,6 @@ def select_key_handles(
 
     KEEP
     Keep -- Leave as is.
-        :type left_handle_action: typing.Literal['SELECT','DESELECT','KEEP'] | None
         :param right_handle_action: Right Handle, Effect on the right handle
 
     SELECT
@@ -925,7 +757,6 @@ def select_key_handles(
 
     KEEP
     Keep -- Leave as is.
-        :type right_handle_action: typing.Literal['SELECT','DESELECT','KEEP'] | None
         :param key_action: Key, Effect on the key itself
 
     SELECT
@@ -936,7 +767,6 @@ def select_key_handles(
 
     KEEP
     Keep -- Leave as is.
-        :type key_action: typing.Literal['SELECT','DESELECT','KEEP'] | None
     """
 
 def select_lasso(
@@ -949,20 +779,15 @@ def select_lasso(
     smooth_stroke_factor: float | None = 0.75,
     smooth_stroke_radius: int | None = 35,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
+    include_handles: bool | None = True,
     use_curve_selection: bool | None = True,
-):
+) -> None:
     """Select keyframe points using lasso selection
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param path: Path
-        :type path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None
         :param use_smooth_stroke: Stabilize Stroke, Selection lags behind mouse and follows a smoother path
-        :type use_smooth_stroke: bool | None
         :param smooth_stroke_factor: Smooth Stroke Factor, Higher values gives a smoother stroke
-        :type smooth_stroke_factor: float | None
         :param smooth_stroke_radius: Smooth Stroke Radius, Minimum distance from last point before selection continues
-        :type smooth_stroke_radius: int | None
         :param mode: Mode
 
     SET
@@ -973,9 +798,8 @@ def select_lasso(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
+        :param include_handles: Include Handles, Are handles tested individually against the selection criteria, independently from their keys. When unchecked, handles are (de)selected in unison with their keys
         :param use_curve_selection: Select Curves, Allow selecting all the keyframes of a curve by selecting the curve itself
-        :type use_curve_selection: bool | None
     """
 
 def select_leftright(
@@ -985,37 +809,33 @@ def select_leftright(
     *,
     mode: typing.Literal["CHECK", "LEFT", "RIGHT"] | None = "CHECK",
     extend: bool | None = False,
-):
+) -> None:
     """Select keyframes to the left or the right of the current frame
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param mode: Mode
-    :type mode: typing.Literal['CHECK','LEFT','RIGHT'] | None
     :param extend: Extend Select
-    :type extend: bool | None
     """
 
-def select_less(execution_context: int | str | None = None, undo: bool | None = None):
-    """Deselect keyframes on ends of selection islands
-
-    :type execution_context: int | str | None
-    :type undo: bool | 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 execution_context: int | str | None
-    :type undo: bool | None
-    """
+def select_less(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Deselect keyframes on ends of selection islands"""
 
-def select_more(execution_context: int | str | None = None, undo: bool | None = None):
-    """Select keyframes beside already selected ones
+def select_linked(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select keyframes occurring in the same F-Curves as selected ones"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def select_more(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select keyframes beside already selected ones"""
 
 def shear(
     execution_context: int | str | None = None,
@@ -1024,13 +844,10 @@ def shear(
     *,
     factor: float | None = 0.0,
     direction: typing.Literal["FROM_LEFT", "FROM_RIGHT"] | None = "FROM_LEFT",
-):
+) -> None:
     """Affect the value of the keys linearly, keeping the same relationship between them using either the left or the right key as reference
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param factor: Shear Factor, The amount of shear to apply
-        :type factor: float | None
         :param direction: Direction, Which end of the segment to use as a reference to shear from
 
     FROM_LEFT
@@ -1038,15 +855,14 @@ def shear(
 
     FROM_RIGHT
     From Right -- Shear the keys using the right key as reference.
-        :type direction: typing.Literal['FROM_LEFT','FROM_RIGHT'] | 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 execution_context: int | str | None
-    :type undo: bool | None
-    """
+def smooth(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Apply weighted moving means to make selected F-Curves less bumpy"""
 
 def snap(
     execution_context: int | str | None = None,
@@ -1062,11 +878,9 @@ def snap(
         "HORIZONTAL",
     ]
     | None = "CFRA",
-):
+) -> None:
     """Snap selected keyframes to the chosen times/values
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param type: Type
 
     CFRA
@@ -1086,17 +900,14 @@ def snap(
 
     HORIZONTAL
     Flatten Handles -- Flatten handles for a smoother transition.
-        :type type: typing.Literal['CFRA','VALUE','NEAREST_FRAME','NEAREST_SECOND','NEAREST_MARKER','HORIZONTAL'] | None
     """
 
 def snap_cursor_value(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Place the cursor value on the average value of selected keyframes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Place the cursor value on the average value of selected keyframes"""
 
 def sound_to_samples(
     execution_context: int | str | None = None,
@@ -1115,7 +926,6 @@ def sound_to_samples(
     filter_text: bool | None = False,
     filter_archive: bool | None = False,
     filter_btx: bool | None = False,
-    filter_collada: bool | None = False,
     filter_alembic: bool | None = False,
     filter_usd: bool | None = False,
     filter_obj: bool | None = False,
@@ -1139,55 +949,30 @@ def sound_to_samples(
     use_additive: bool | None = False,
     use_square: bool | None = False,
     sthreshold: float | None = 0.1,
-):
+) -> None:
     """Bakes a sound wave to samples on selected channels
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param filepath: File Path, Path to file
-        :type filepath: str
         :param check_existing: Check Existing, Check and warn on overwriting existing files
-        :type check_existing: bool | None
         :param filter_blender: Filter .blend files
-        :type filter_blender: bool | None
         :param filter_backup: Filter .blend files
-        :type filter_backup: bool | None
         :param filter_image: Filter image files
-        :type filter_image: bool | None
         :param filter_movie: Filter movie files
-        :type filter_movie: bool | None
         :param filter_python: Filter Python files
-        :type filter_python: bool | None
         :param filter_font: Filter font files
-        :type filter_font: bool | None
         :param filter_sound: Filter sound files
-        :type filter_sound: bool | None
         :param filter_text: Filter text files
-        :type filter_text: bool | None
         :param filter_archive: Filter archive files
-        :type filter_archive: bool | None
         :param filter_btx: Filter btx files
-        :type filter_btx: bool | None
-        :param filter_collada: Filter COLLADA files
-        :type filter_collada: bool | None
         :param filter_alembic: Filter Alembic files
-        :type filter_alembic: bool | None
         :param filter_usd: Filter USD files
-        :type filter_usd: bool | None
         :param filter_obj: Filter OBJ files
-        :type filter_obj: bool | None
         :param filter_volume: Filter OpenVDB volume files
-        :type filter_volume: bool | None
         :param filter_folder: Filter folders
-        :type filter_folder: bool | None
         :param filter_blenlib: Filter Blender IDs
-        :type filter_blenlib: bool | None
         :param filemode: File Browser Mode, The setting for the file browser mode to load a .blend file, a library or a special file
-        :type filemode: int | None
         :param show_multiview: Enable Multi-View
-        :type show_multiview: bool | None
         :param use_multiview: Use Multi-View
-        :type use_multiview: bool | None
         :param display_type: Display Type
 
     DEFAULT
@@ -1201,27 +986,16 @@ def sound_to_samples(
 
     THUMBNAIL
     Thumbnails -- Display files as thumbnails.
-        :type display_type: typing.Literal['DEFAULT','LIST_VERTICAL','LIST_HORIZONTAL','THUMBNAIL'] | None
         :param sort_method: File sorting mode
-        :type sort_method: str | None
         :param low: Lowest Frequency, Cutoff frequency of a high-pass filter that is applied to the audio data
-        :type low: float | None
         :param high: Highest Frequency, Cutoff frequency of a low-pass filter that is applied to the audio data
-        :type high: float | None
         :param attack: Attack Time, Value for the envelope calculation that tells how fast the envelope can rise (the lower the value the steeper it can rise)
-        :type attack: float | None
         :param release: Release Time, Value for the envelope calculation that tells how fast the envelope can fall (the lower the value the steeper it can fall)
-        :type release: float | None
         :param threshold: Threshold, Minimum amplitude value needed to influence the envelope
-        :type threshold: float | None
         :param use_accumulate: Accumulate, Only the positive differences of the envelope amplitudes are summarized to produce the output
-        :type use_accumulate: bool | None
         :param use_additive: Additive, The amplitudes of the envelope are summarized (or, when Accumulate is enabled, both positive and negative differences are accumulated)
-        :type use_additive: bool | None
         :param use_square: Square, The output is a square curve (negative values always result in -1, and positive ones in 1)
-        :type use_square: bool | None
         :param sthreshold: Square Threshold, Square only: all values with an absolute amplitude lower than that result in 0
-        :type sthreshold: float | None
     """
 
 def time_offset(
@@ -1230,13 +1004,10 @@ def time_offset(
     /,
     *,
     frame_offset: float | None = 0.0,
-):
+) -> None:
     """Shifts the value of selected keys in time
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param frame_offset: Frame Offset, How far in frames to offset the animation
-    :type frame_offset: float | None
     """
 
 def view_all(
@@ -1245,21 +1016,18 @@ def view_all(
     /,
     *,
     include_handles: bool | None = True,
-):
+) -> None:
     """Reset viewable area to show full keyframe range
 
-    :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(execution_context: int | str | None = None, undo: bool | None = None):
-    """Move the view to the current frame
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def view_frame(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Move the view to the current frame"""
 
 def view_selected(
     execution_context: int | str | None = None,
@@ -1267,11 +1035,8 @@ def view_selected(
     /,
     *,
     include_handles: bool | None = True,
-):
+) -> None:
     """Reset viewable area to show selected keyframe range
 
-    :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
     """