fake-bge-module 20250103__py3-none-any.whl → 20250201__py3-none-any.whl

bpy/ops/grease_pencil/__init__.pyi

@@ -1,20 +1,19 @@
 import typing
 import collections.abc
 import typing_extensions
+import bpy._typing.rna_enums
 import bpy.ops.transform
 import bpy.types
-import bpy.typing
 
 def active_frame_delete(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     all: bool | None = False,
 ):
     """Delete the active Grease Pencil frame(s)
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param all: Delete all, Delete active keyframes of all layers
@@ -22,9 +21,9 @@ def active_frame_delete(
     """
 
 def bake_grease_pencil_animation(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     frame_start: int | None = 1,
     frame_end: int | None = 250,
@@ -36,7 +35,6 @@ def bake_grease_pencil_animation(
 ):
     """Bake Grease Pencil object transform to Grease Pencil keyframes
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param frame_start: Start Frame, The start frame
@@ -72,9 +70,9 @@ def bake_grease_pencil_animation(
     """
 
 def brush_stroke(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
     | None = None,
@@ -83,7 +81,6 @@ def brush_stroke(
 ):
     """Draw a new stroke in the active Grease Pencil object
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param stroke: Stroke
@@ -107,15 +104,14 @@ def brush_stroke(
     """
 
 def caps_set(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["ROUND", "FLAT", "START", "END"] | None = "ROUND",
 ):
     """Change curve caps mode (rounded or flat)
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type
@@ -135,71 +131,61 @@ def caps_set(
     """
 
 def clean_loose(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     limit: int | None = 1,
 ):
     """Remove loose points
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param limit: Limit, Number of points to consider stroke as loose
     :type limit: int | 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 the selected Grease Pencil points or strokes 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 cyclical_set(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["CLOSE", "OPEN", "TOGGLE"] | None = "TOGGLE",
+    subdivide_cyclic_segment: bool | None = True,
 ):
     """Close or open the selected stroke adding a segment from last to first point
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param type: Type
     :type type: typing.Literal['CLOSE','OPEN','TOGGLE'] | None
+    :param subdivide_cyclic_segment: Match Point Density, Add point in the new segment to keep the same density
+    :type subdivide_cyclic_segment: bool | None
     """
 
-def delete(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def delete(execution_context: int | str | None = None, undo: bool | None = None):
     """Delete selected strokes or points
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def delete_frame(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["ACTIVE_FRAME", "ALL_FRAMES"] | None = "ACTIVE_FRAME",
 ):
     """Delete Grease Pencil Frame(s)
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type, Method used for deleting Grease Pencil frames
@@ -213,15 +199,14 @@ def delete_frame(
     """
 
 def dissolve(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["POINTS", "BETWEEN", "UNSELECT"] | None = "POINTS",
 ):
     """Delete selected points without splitting strokes
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type, Method used for dissolving stroke points
@@ -237,29 +222,23 @@ def dissolve(
         :type type: typing.Literal['POINTS','BETWEEN','UNSELECT'] | None
     """
 
-def duplicate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def duplicate(execution_context: int | str | None = None, undo: bool | None = None):
     """Duplicate the selected points
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def duplicate_move(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     GREASE_PENCIL_OT_duplicate: typing.Any | None = None,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
 ):
     """Make copies of the selected Grease Pencil strokes 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 GREASE_PENCIL_OT_duplicate: Duplicate, Duplicate the selected points
@@ -269,9 +248,9 @@ def duplicate_move(
     """
 
 def erase_box(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     xmin: int | None = 0,
     xmax: int | None = 0,
@@ -281,7 +260,6 @@ def erase_box(
 ):
     """Erase points in the box region
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param xmin: X Min
@@ -297,9 +275,9 @@ def erase_box(
     """
 
 def erase_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,
@@ -308,7 +286,6 @@ def erase_lasso(
 ):
     """Erase points in the lasso region
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param path: Path
@@ -321,29 +298,23 @@ def erase_lasso(
     :type smooth_stroke_radius: int | None
     """
 
-def extrude(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def extrude(execution_context: int | str | None = None, undo: bool | None = None):
     """Extrude the selected points
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def extrude_move(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     GREASE_PENCIL_OT_extrude: typing.Any | None = None,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
 ):
     """Extrude selected points 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 GREASE_PENCIL_OT_extrude: Extrude Stroke Points, Extrude the selected points
@@ -353,16 +324,15 @@ def extrude_move(
     """
 
 def fill(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     invert: bool | None = False,
     precision: bool | None = False,
 ):
     """Fill with color the shape formed by strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param invert: Invert, Find boundary of unfilled instead of filled regions
@@ -372,15 +342,14 @@ def fill(
     """
 
 def frame_clean_duplicate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     selected: bool | None = False,
 ):
     """Remove any keyframe that is a duplicate of the previous one
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param selected: Selected, Only delete selected keyframes
@@ -388,15 +357,14 @@ def frame_clean_duplicate(
     """
 
 def frame_duplicate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     all: bool | None = False,
 ):
     """Make a copy of the active Grease Pencil frame(s)
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param all: Duplicate all, Duplicate active keyframes of all layer
@@ -404,16 +372,15 @@ def frame_duplicate(
     """
 
 def insert_blank_frame(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     all_layers: bool | None = False,
     duration: int | None = 0,
 ):
     """Insert a blank frame on the current scene frame
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param all_layers: All Layers, Insert a blank frame in all editable layers
@@ -423,9 +390,9 @@ def insert_blank_frame(
     """
 
 def interpolate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     shift: float | None = 0.0,
     layers: typing.Literal["ACTIVE", "ALL"] | None = "ACTIVE",
@@ -437,7 +404,6 @@ def interpolate(
 ):
     """Interpolate Grease Pencil strokes between frames
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param shift: Shift, Bias factor for which frame has more influence on the interpolated strokes
@@ -457,13 +423,14 @@ def interpolate(
     """
 
 def interpolate_sequence(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     step: int | None = 1,
     layers: typing.Literal["ACTIVE", "ALL"] | None = "ACTIVE",
     exclude_breakdowns: bool | None = False,
+    use_selection: bool | None = False,
     flip: typing.Literal["NONE", "FLIP", "AUTO"] | None = "AUTO",
     smooth_steps: int | None = 1,
     smooth_factor: float | None = 0.0,
@@ -482,14 +449,13 @@ def interpolate_sequence(
         "ELASTIC",
     ]
     | None = "LINEAR",
-    easing: bpy.typing.BeztripleInterpolationEasingItems | None = "EASE_IN",
+    easing: bpy._typing.rna_enums.BeztripleInterpolationEasingItems | None = "EASE_IN",
     back: float | None = 1.702,
     amplitude: float | None = 0.15,
     period: float | None = 0.15,
 ):
     """Generate 'in-betweens' to smoothly interpolate between Grease Pencil frames
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param step: Step, Number of frames between generated interpolated frames
@@ -498,6 +464,8 @@ def interpolate_sequence(
         :type layers: typing.Literal['ACTIVE','ALL'] | None
         :param exclude_breakdowns: Exclude Breakdowns, Exclude existing Breakdowns keyframes as interpolation extremes
         :type exclude_breakdowns: bool | None
+        :param use_selection: Use Selection, Use only selected strokes for interpolating
+        :type use_selection: bool | None
         :param flip: Flip Mode, Invert destination stroke to match start and end with source stroke
         :type flip: typing.Literal['NONE','FLIP','AUTO'] | None
         :param smooth_steps: Iterations, Number of times to smooth newly created strokes
@@ -543,7 +511,7 @@ def interpolate_sequence(
     Elastic -- Exponentially decaying sine wave, like an elastic band.
         :type type: typing.Literal['LINEAR','CUSTOM','SINE','QUAD','CUBIC','QUART','QUINT','EXPO','CIRC','BACK','BOUNCE','ELASTIC'] | None
         :param easing: Easing, Which ends of the segment between the preceding and following Grease Pencil frames easing interpolation is applied to
-        :type easing: bpy.typing.BeztripleInterpolationEasingItems | None
+        :type easing: bpy._typing.rna_enums.BeztripleInterpolationEasingItems | None
         :param back: Back, Amount of overshoot for 'back' easing
         :type back: float | None
         :param amplitude: Amplitude, Amount to boost elastic bounces for 'elastic' easing
@@ -553,15 +521,14 @@ def interpolate_sequence(
     """
 
 def join_selection(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["JOINCOPY", "JOIN"] | None = "JOIN",
 ):
     """New stroke from selected points/strokes
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Type, Defines how the operator will behave on the selection in the active layer
@@ -575,15 +542,14 @@ def join_selection(
     """
 
 def layer_active(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     layer: int | None = 0,
 ):
     """Set the active Grease Pencil layer
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param layer: Grease Pencil Layer
@@ -591,15 +557,14 @@ def layer_active(
     """
 
 def layer_add(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     new_layer_name: str = "Layer",
 ):
     """Add a new Grease Pencil layer in the active object
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param new_layer_name: Name, Name of the new layer
@@ -607,15 +572,14 @@ def layer_add(
     """
 
 def layer_duplicate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     empty_keyframes: bool | None = False,
 ):
     """Make a copy of the active Grease Pencil layer
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param empty_keyframes: Empty Keyframes, Add Empty Keyframes
@@ -623,16 +587,15 @@ def layer_duplicate(
     """
 
 def layer_duplicate_object(
-    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 = True,
     mode: typing.Literal["ALL", "ACTIVE"] | None = "ALL",
 ):
     """Make a copy of the active Grease Pencil layer to selected object
 
-    :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, Copy only active Layer, uncheck to append all layers
@@ -642,15 +605,14 @@ def layer_duplicate_object(
     """
 
 def layer_group_add(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     new_layer_group_name: str = "",
 ):
     """Add a new Grease Pencil layer group in the active object
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param new_layer_group_name: Name, Name of the new layer group
@@ -658,9 +620,9 @@ def layer_group_add(
     """
 
 def layer_group_color_tag(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     color_tag: typing.Literal[
         "NONE",
@@ -677,7 +639,6 @@ def layer_group_color_tag(
 ):
     """Change layer group icon
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param color_tag: Color Tag
@@ -685,15 +646,14 @@ def layer_group_color_tag(
     """
 
 def layer_group_remove(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     keep_children: bool | None = False,
 ):
     """Remove Grease Pencil layer group in the active object
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param keep_children: Keep children nodes, Keep the children nodes of the group and only delete the group itself
@@ -701,15 +661,14 @@ def layer_group_remove(
     """
 
 def layer_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/unselected Grease Pencil layers
 
-    :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 layers
@@ -717,15 +676,14 @@ def layer_hide(
     """
 
 def layer_isolate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     affect_visibility: bool | None = False,
 ):
     """Make only active layer visible/editable
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param affect_visibility: Affect Visibility, Also affect the visibility
@@ -733,15 +691,14 @@ def layer_isolate(
     """
 
 def layer_lock_all(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     lock: bool | None = True,
 ):
     """Lock all Grease Pencil layers to prevent them from being accidentally modified
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param lock: Lock Value, Lock/Unlock all layers
@@ -749,15 +706,14 @@ def layer_lock_all(
     """
 
 def layer_mask_add(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     name: str = "",
 ):
     """Add new layer as masking
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param name: Layer, Name of the layer
@@ -765,27 +721,23 @@ def layer_mask_add(
     """
 
 def layer_mask_remove(
-    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
 ):
     """Remove Layer Mask
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def layer_mask_reorder(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
 ):
     """Reorder the active Grease Pencil mask layer up/down in the list
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param direction: Direction
@@ -793,15 +745,14 @@ def layer_mask_reorder(
     """
 
 def layer_merge(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["ACTIVE", "GROUP", "ALL"] | None = "ACTIVE",
 ):
     """Combine layers based on the mode into one layer
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param mode: Mode
@@ -818,74 +769,43 @@ def layer_merge(
     """
 
 def layer_move(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
 ):
     """Move the active Grease Pencil layer or Group
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param direction: Direction
     :type direction: typing.Literal['UP','DOWN'] | None
     """
 
-def layer_remove(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def layer_remove(execution_context: int | str | None = None, undo: bool | None = None):
     """Remove the active Grease Pencil layer
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
-def layer_reorder(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-    *,
-    target_layer_name: str = "Layer",
-    location: typing.Literal["ABOVE", "BELOW"] | None = "ABOVE",
-):
-    """Reorder the active Grease Pencil layer
-
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param target_layer_name: Target Name, Name of the target layer
-    :type target_layer_name: str
-    :param location: Location
-    :type location: typing.Literal['ABOVE','BELOW'] | None
-    """
-
-def layer_reveal(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def layer_reveal(execution_context: int | str | None = None, undo: bool | None = None):
     """Show all Grease Pencil layers
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def material_copy_to_object(
-    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 = True,
 ):
     """Append Materials of the active Grease Pencil to other object
 
-    :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, Append only active material, uncheck to append all materials
@@ -893,15 +813,14 @@ def material_copy_to_object(
     """
 
 def material_hide(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     invert: bool | None = False,
 ):
     """Hide active/inactive Grease Pencil material(s)
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param invert: Invert, Hide inactive materials instead of the active one
@@ -909,15 +828,14 @@ def material_hide(
     """
 
 def material_isolate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     affect_visibility: bool | None = False,
 ):
     """Toggle whether the active material is the only one that is editable and/or visible
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param affect_visibility: Affect Visibility, In addition to toggling the editability, also affect the visibility
@@ -925,63 +843,50 @@ def material_isolate(
     """
 
 def material_lock_all(
-    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
 ):
     """Lock all Grease Pencil materials to prevent them from being accidentally modified
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def material_lock_unselected(
-    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
 ):
     """Lock any material not used in any selected stroke
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def material_lock_unused(
-    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
 ):
     """Lock and hide any material not used
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def material_reveal(
-    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
 ):
     """Unhide all hidden Grease Pencil materials
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def material_select(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     deselect: bool | None = False,
 ):
     """Select/Deselect all Grease Pencil strokes using current material
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param deselect: Deselect, Unselect strokes
@@ -989,28 +894,24 @@ def material_select(
     """
 
 def material_unlock_all(
-    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
 ):
     """Unlock all Grease Pencil materials so that they can be edited
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def move_to_layer(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     target_layer_name: str = "",
     add_new_layer: bool | None = False,
 ):
     """Move selected strokes to another layer
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param target_layer_name: Name, Target Grease Pencil Layer
@@ -1020,15 +921,14 @@ def move_to_layer(
     """
 
 def paintmode_toggle(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     back: bool | None = False,
 ):
     """Enter/Exit paint mode for Grease Pencil strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param back: Return to Previous Mode, Return to previous mode
@@ -1036,16 +936,15 @@ def paintmode_toggle(
     """
 
 def paste(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     paste_back: bool | None = False,
     keep_world_transform: bool | None = False,
 ):
     """Paste Grease Pencil points or strokes from the internal clipboard to the active layer
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param paste_back: Paste on Back, Add pasted strokes behind all strokes
@@ -1055,9 +954,9 @@ def paste(
     """
 
 def primitive_arc(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     subdivision: int | None = 62,
     type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
@@ -1065,7 +964,6 @@ def primitive_arc(
 ):
     """Create predefined Grease Pencil stroke arcs
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param subdivision: Subdivisions, Number of subdivisions per segment
@@ -1075,9 +973,9 @@ def primitive_arc(
     """
 
 def primitive_box(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     subdivision: int | None = 3,
     type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
@@ -1085,7 +983,6 @@ def primitive_box(
 ):
     """Create predefined Grease Pencil stroke boxes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param subdivision: Subdivisions, Number of subdivisions per segment
@@ -1095,9 +992,9 @@ def primitive_box(
     """
 
 def primitive_circle(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     subdivision: int | None = 94,
     type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
@@ -1105,7 +1002,6 @@ def primitive_circle(
 ):
     """Create predefined Grease Pencil stroke circles
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param subdivision: Subdivisions, Number of subdivisions per segment
@@ -1115,9 +1011,9 @@ def primitive_circle(
     """
 
 def primitive_curve(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     subdivision: int | None = 62,
     type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
@@ -1125,7 +1021,6 @@ def primitive_curve(
 ):
     """Create predefined Grease Pencil stroke curve shapes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param subdivision: Subdivisions, Number of subdivisions per segment
@@ -1135,9 +1030,9 @@ def primitive_curve(
     """
 
 def primitive_line(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     subdivision: int | None = 6,
     type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
@@ -1145,7 +1040,6 @@ def primitive_line(
 ):
     """Create predefined Grease Pencil stroke lines
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param subdivision: Subdivisions, Number of subdivisions per segment
@@ -1155,9 +1049,9 @@ def primitive_line(
     """
 
 def primitive_polyline(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     subdivision: int | None = 6,
     type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
@@ -1165,7 +1059,6 @@ def primitive_polyline(
 ):
     """Create predefined Grease Pencil stroke polylines
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param subdivision: Subdivisions, Number of subdivisions per segment
@@ -1175,15 +1068,14 @@ def primitive_polyline(
     """
 
 def reorder(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     direction: typing.Literal["TOP", "UP", "DOWN", "BOTTOM"] | None = "TOP",
 ):
     """Change the display order of the selected strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param direction: Direction
@@ -1191,9 +1083,9 @@ def reorder(
     """
 
 def reproject(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     type: typing.Literal["FRONT", "SIDE", "TOP", "VIEW", "SURFACE", "CURSOR"]
     | None = "VIEW",
@@ -1202,7 +1094,6 @@ def reproject(
 ):
     """Reproject the selected strokes from the current viewpoint as if they had been newly drawn (e.g. to fix problems from accidental 3D cursor movement or accidental viewport changes, or for matching deforming geometry)
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param type: Projection Type
@@ -1231,22 +1122,17 @@ def reproject(
         :type offset: float | None
     """
 
-def reset_uvs(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def reset_uvs(execution_context: int | str | None = None, undo: bool | None = None):
     """Reset UV transformation to default values
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def sculpt_paint(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
     | None = None,
@@ -1255,7 +1141,6 @@ def sculpt_paint(
 ):
     """Sculpt strokes in the active Grease Pencil object
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param stroke: Stroke
@@ -1279,15 +1164,14 @@ def sculpt_paint(
     """
 
 def sculptmode_toggle(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     back: bool | None = False,
 ):
     """Enter/Exit sculpt mode for Grease Pencil strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param back: Return to Previous Mode, Return to previous mode
@@ -1295,15 +1179,14 @@ def sculptmode_toggle(
     """
 
 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",
 ):
     """(De)select all visible strokes
 
-        :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
@@ -1323,15 +1206,14 @@ def select_all(
     """
 
 def select_alternate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     deselect_ends: bool | None = False,
 ):
     """Select alternated points in strokes with already selected points
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param deselect_ends: Deselect Ends, (De)select the first and last point of each stroke
@@ -1339,16 +1221,15 @@ def select_alternate(
     """
 
 def select_ends(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     amount_start: int | None = 0,
     amount_end: int | None = 1,
 ):
     """Select end points of strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param amount_start: Amount Start, Number of points to select from the start
@@ -1357,46 +1238,31 @@ def select_ends(
     :type amount_end: int | 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):
     """Shrink the selection by one point
 
-    :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 all points in curves with any point selection
 
-    :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):
     """Grow the selection by one point
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def select_random(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     ratio: float | None = 0.5,
     seed: int | None = 0,
@@ -1404,7 +1270,6 @@ def select_random(
 ):
     """Selects random points from the current strokes selection
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param ratio: Ratio, Portion of items to select randomly
@@ -1422,9 +1287,9 @@ def select_random(
     """
 
 def select_similar(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["LAYER", "MATERIAL", "VERTEX_COLOR", "RADIUS", "OPACITY"]
     | None = "LAYER",
@@ -1432,7 +1297,6 @@ def select_similar(
 ):
     """Select all strokes with similar characteristics
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -1442,15 +1306,14 @@ def select_similar(
     """
 
 def separate(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["SELECTED", "MATERIAL", "LAYER"] | None = "SELECTED",
 ):
     """Separate the selected geometry into a new Grease Pencil object
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param mode: Mode
@@ -1467,27 +1330,23 @@ def separate(
     """
 
 def set_active_material(
-    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 the selected stroke material as the active material
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def set_curve_resolution(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     resolution: int | None = 12,
 ):
     """Set resolution of selected curves
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param resolution: Resolution, The resolution to use for each curve segment
@@ -1495,50 +1354,47 @@ def set_curve_resolution(
     """
 
 def set_curve_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.CurvesTypeItems | None = "POLY",
+    type: bpy._typing.rna_enums.CurvesTypeItems | None = "POLY",
     use_handles: bool | None = False,
 ):
     """Set type of selected 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, Curve type
-    :type type: bpy.typing.CurvesTypeItems | None
+    :type type: bpy._typing.rna_enums.CurvesTypeItems | None
     :param use_handles: Handles, Take handle information into account in the conversion
     :type use_handles: bool | None
     """
 
 def set_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.CurvesHandleTypeItems | None = "AUTO",
+    type: bpy._typing.rna_enums.CurvesHandleTypeItems | None = "AUTO",
 ):
     """Set the handle type for bezier 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
-    :type type: bpy.typing.CurvesHandleTypeItems | None
+    :type type: bpy._typing.rna_enums.CurvesHandleTypeItems | None
     """
 
 def set_material(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     slot: str | None = "DEFAULT",
 ):
     """Set active material
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param slot: Material Slot
@@ -1546,43 +1402,38 @@ def set_material(
     """
 
 def set_selection_mode(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
-    mode: bpy.typing.GreasePencilSelectmodeItems | None = "POINT",
+    mode: bpy._typing.rna_enums.GreasePencilSelectmodeItems | None = "POINT",
 ):
     """Change the selection mode for Grease Pencil strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
-    :type mode: bpy.typing.GreasePencilSelectmodeItems | None
+    :type mode: bpy._typing.rna_enums.GreasePencilSelectmodeItems | None
     """
 
 def set_start_point(
-    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
 ):
     """Select which point is the beginning of the curve
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def set_uniform_opacity(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     opacity: float | None = 1.0,
 ):
     """Set all stroke points to same opacity
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param opacity: Opacity
@@ -1590,15 +1441,14 @@ def set_uniform_opacity(
     """
 
 def set_uniform_thickness(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     thickness: float | None = 0.1,
 ):
     """Set all stroke points to same thickness
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param thickness: Thickness, Thickness
@@ -1606,55 +1456,45 @@ def set_uniform_thickness(
     """
 
 def snap_cursor_to_selected(
-    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
 ):
     """Snap cursor to center of selected points
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def snap_to_cursor(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     use_offset: bool | None = True,
 ):
     """Snap selected points/strokes to the cursor
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param use_offset: With Offset, Offset the entire stroke instead of selected points only
     :type use_offset: bool | None
     """
 
-def snap_to_grid(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def snap_to_grid(execution_context: int | str | None = None, undo: bool | None = None):
     """Snap selected points to the nearest grid points
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def stroke_material_set(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     material: str = "",
 ):
     """Assign the active material slot to the selected strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param material: Material, Name of the material
@@ -1662,16 +1502,15 @@ def stroke_material_set(
     """
 
 def stroke_merge_by_distance(
-    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,
     use_unselected: bool | None = False,
 ):
     """Merge points by distance
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param threshold: Threshold
@@ -1681,15 +1520,14 @@ def stroke_merge_by_distance(
     """
 
 def stroke_reset_vertex_color(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
 ):
     """Reset vertex color for all or selected strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -1697,9 +1535,9 @@ def stroke_reset_vertex_color(
     """
 
 def stroke_simplify(
-    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.01,
     length: float | None = 0.05,
@@ -1709,7 +1547,6 @@ def stroke_simplify(
 ):
     """Simplify selected strokes
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param factor: Factor
@@ -1737,9 +1574,9 @@ def stroke_simplify(
     """
 
 def stroke_smooth(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     iterations: int | None = 10,
     factor: float | None = 1.0,
@@ -1751,7 +1588,6 @@ def stroke_smooth(
 ):
     """Smooth selected strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param iterations: Iterations
@@ -1771,16 +1607,15 @@ def stroke_smooth(
     """
 
 def stroke_subdivide(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     number_cuts: int | None = 1,
     only_selected: bool | None = True,
 ):
     """Subdivide between continuous selected points of the stroke adding a point half way between them
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param number_cuts: Number of Cuts
@@ -1790,16 +1625,15 @@ def stroke_subdivide(
     """
 
 def stroke_subdivide_smooth(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     GREASE_PENCIL_OT_stroke_subdivide: typing.Any | None = None,
     GREASE_PENCIL_OT_stroke_smooth: typing.Any | None = None,
 ):
     """Subdivide strokes and smooth them
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param GREASE_PENCIL_OT_stroke_subdivide: Subdivide Stroke, Subdivide between continuous selected points of the stroke adding a point half way between them
@@ -1809,21 +1643,18 @@ def stroke_subdivide_smooth(
     """
 
 def stroke_switch_direction(
-    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
 ):
     """Change direction of the points of the selected strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def stroke_trim(
-    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,
@@ -1832,7 +1663,6 @@ def stroke_trim(
 ):
     """Delete stroke points in between intersecting strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param path: Path
@@ -1846,9 +1676,9 @@ def stroke_trim(
     """
 
 def texture_gradient(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     xstart: int | None = 0,
     xend: int | None = 0,
@@ -1859,7 +1689,6 @@ def texture_gradient(
 ):
     """Draw a line to set the fill material gradient for the selected strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param xstart: X Start
@@ -1877,9 +1706,9 @@ def texture_gradient(
     """
 
 def trace_image(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     target: typing.Literal["NEW", "SELECTED"] | None = "NEW",
     radius: float | None = 0.01,
@@ -1894,7 +1723,6 @@ def trace_image(
 ):
     """Extract Grease Pencil strokes from image
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param target: Target Object, Target Grease Pencil
@@ -1941,9 +1769,9 @@ def trace_image(
     """
 
 def vertex_brush_stroke(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
     | None = None,
@@ -1952,7 +1780,6 @@ def vertex_brush_stroke(
 ):
     """Draw on vertex colors in the active Grease Pencil object
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param stroke: Stroke
@@ -1976,9 +1803,9 @@ def vertex_brush_stroke(
     """
 
 def vertex_color_brightness_contrast(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
     brightness: float | None = 0.0,
@@ -1986,7 +1813,6 @@ def vertex_color_brightness_contrast(
 ):
     """Adjust vertex color brightness/contrast
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -1998,9 +1824,9 @@ def vertex_color_brightness_contrast(
     """
 
 def vertex_color_hsv(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
     h: float | None = 0.5,
@@ -2009,7 +1835,6 @@ def vertex_color_hsv(
 ):
     """Adjust vertex color HSV values
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -2023,15 +1848,14 @@ def vertex_color_hsv(
     """
 
 def vertex_color_invert(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
 ):
     """Invert RGB values
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -2039,9 +1863,9 @@ def vertex_color_invert(
     """
 
 def vertex_color_levels(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
     offset: float | None = 0.0,
@@ -2049,7 +1873,6 @@ def vertex_color_levels(
 ):
     """Adjust levels of vertex colors
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -2061,16 +1884,15 @@ def vertex_color_levels(
     """
 
 def vertex_color_set(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
     factor: float | None = 1.0,
 ):
     """Set active color to all selected vertex
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mode: Mode
@@ -2080,27 +1902,23 @@ def vertex_color_set(
     """
 
 def vertex_group_normalize(
-    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
 ):
     """Normalize weights of the active vertex group
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def vertex_group_normalize_all(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     lock_active: bool | None = True,
 ):
     """Normalize the weights of all vertex groups, so that for each vertex, the sum of all weights is 1.0
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param lock_active: Lock Active, Keep the values of the active group while normalizing others
@@ -2108,16 +1926,15 @@ def vertex_group_normalize_all(
     """
 
 def vertex_group_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 = 0.5,
     repeat: int | None = 1,
 ):
     """Smooth the weights of the active vertex group
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param factor: Factor
@@ -2127,15 +1944,14 @@ def vertex_group_smooth(
     """
 
 def vertexmode_toggle(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     back: bool | None = False,
 ):
     """Enter/Exit vertex paint mode for Grease Pencil strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param back: Return to Previous Mode, Return to previous mode
@@ -2143,9 +1959,9 @@ def vertexmode_toggle(
     """
 
 def weight_brush_stroke(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
     | None = None,
@@ -2154,7 +1970,6 @@ def weight_brush_stroke(
 ):
     """Draw weight on stroke points in the active Grease Pencil object
 
-        :type override_context: bpy.types.Context | dict[str, typing.Any] | None
         :type execution_context: int | str | None
         :type undo: bool | None
         :param stroke: Stroke
@@ -2177,52 +1992,38 @@ def weight_brush_stroke(
         :type pen_flip: bool | None
     """
 
-def weight_invert(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def weight_invert(execution_context: int | str | None = None, undo: bool | None = None):
     """Invert the weight of active vertex group
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
-def weight_sample(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-):
+def weight_sample(execution_context: int | str | None = None, undo: bool | None = None):
     """Set the weight of the Draw tool to the weight of the vertex under the mouse cursor
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def weight_toggle_direction(
-    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
 ):
     """Toggle Add/Subtract for the weight paint draw tool
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     """
 
 def weightmode_toggle(
-    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,
     undo: bool | None = None,
+    /,
     *,
     back: bool | None = False,
 ):
     """Enter/Exit weight paint mode for Grease Pencil strokes
 
-    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
     :type execution_context: int | str | None
     :type undo: bool | None
     :param back: Return to Previous Mode, Return to previous mode