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

bpy/ops/paint/__init__.pyi

@@ -1,18 +1,17 @@
 import typing
 import collections.abc
 import typing_extensions
-import bpy._typing.rna_enums
+import numpy.typing as npt
+import bpy.stub_internal.rna_enums
 import bpy.types
 import mathutils
 
 def add_simple_uvs(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Add cube map UVs on mesh
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Add cube map UVs on mesh"""
 
 def add_texture_paint_slot(
     execution_context: int | str | None = None,
@@ -35,47 +34,34 @@ def add_texture_paint_slot(
     width: int | None = 1024,
     height: int | None = 1024,
     alpha: bool | None = True,
-    generated_type: bpy._typing.rna_enums.ImageGeneratedTypeItems | None = "BLANK",
+    generated_type: bpy.stub_internal.rna_enums.ImageGeneratedTypeItems
+    | None = "BLANK",
     float: bool | None = False,
-    domain: bpy._typing.rna_enums.ColorAttributeDomainItems | None = "POINT",
-    data_type: bpy._typing.rna_enums.ColorAttributeTypeItems | None = "FLOAT_COLOR",
-):
+    domain: bpy.stub_internal.rna_enums.ColorAttributeDomainItems | None = "POINT",
+    data_type: bpy.stub_internal.rna_enums.ColorAttributeTypeItems
+    | None = "FLOAT_COLOR",
+) -> None:
     """Add a paint slot
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Material Layer Type, Material layer type of new paint slot
-    :type type: typing.Literal['BASE_COLOR','SPECULAR','ROUGHNESS','METALLIC','NORMAL','BUMP','DISPLACEMENT'] | None
     :param slot_type: Slot Type, Type of new paint slot
-    :type slot_type: typing.Literal['IMAGE','COLOR_ATTRIBUTE'] | None
     :param name: Name, Name for new paint slot source
-    :type name: str
     :param color: Color, Default fill color
-    :type color: collections.abc.Iterable[float] | None
     :param width: Width, Image width
-    :type width: int | None
     :param height: Height, Image height
-    :type height: int | None
     :param alpha: Alpha, Create an image with an alpha channel
-    :type alpha: bool | None
     :param generated_type: Generated Type, Fill the image with a grid for UV map testing
-    :type generated_type: bpy._typing.rna_enums.ImageGeneratedTypeItems | None
     :param float: 32-bit Float, Create image with 32-bit floating-point bit depth
-    :type float: bool | None
     :param domain: Domain, Type of element that attribute is stored on
-    :type domain: bpy._typing.rna_enums.ColorAttributeDomainItems | None
     :param data_type: Data Type, Type of data stored in attribute
-    :type data_type: bpy._typing.rna_enums.ColorAttributeTypeItems | None
     """
 
 def brush_colors_flip(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Swap primary and secondary brush colors
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Swap primary and secondary brush colors"""
 
 def face_select_all(
     execution_context: int | str | None = None,
@@ -83,11 +69,9 @@ def face_select_all(
     /,
     *,
     action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"] | None = "TOGGLE",
-):
+) -> None:
     """Change selection for all faces
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Action, Selection action to execute
 
     TOGGLE
@@ -101,7 +85,6 @@ def face_select_all(
 
     INVERT
     Invert -- Invert selection of all elements.
-        :type action: typing.Literal['TOGGLE','SELECT','DESELECT','INVERT'] | None
     """
 
 def face_select_hide(
@@ -110,13 +93,10 @@ def face_select_hide(
     /,
     *,
     unselected: bool | None = False,
-):
+) -> None:
     """Hide selected faces
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param unselected: Unselected, Hide unselected rather than selected objects
-    :type unselected: bool | None
     """
 
 def face_select_less(
@@ -125,23 +105,18 @@ def face_select_less(
     /,
     *,
     face_step: bool | None = True,
-):
+) -> None:
     """Deselect Faces connected to existing selection
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param face_step: Face Step, Also deselect faces that only touch on a corner
-    :type face_step: bool | None
     """
 
 def face_select_linked(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Select linked faces
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select linked faces"""
 
 def face_select_linked_pick(
     execution_context: int | str | None = None,
@@ -149,13 +124,10 @@ def face_select_linked_pick(
     /,
     *,
     deselect: bool | None = False,
-):
+) -> None:
     """Select linked faces under the cursor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param deselect: Deselect, Deselect rather than select items
-    :type deselect: bool | None
     """
 
 def face_select_loop(
@@ -165,15 +137,11 @@ def face_select_loop(
     *,
     select: bool | None = True,
     extend: bool | None = False,
-):
+) -> None:
     """Select face loop under the cursor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param select: Select, If false, faces will be deselected
-    :type select: bool | None
     :param extend: Extend, Extend the selection
-    :type extend: bool | None
     """
 
 def face_select_more(
@@ -182,13 +150,10 @@ def face_select_more(
     /,
     *,
     face_step: bool | None = True,
-):
+) -> None:
     """Select Faces connected to existing selection
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param face_step: Face Step, Also select faces that only touch on a corner
-    :type face_step: bool | None
     """
 
 def face_vert_reveal(
@@ -197,13 +162,10 @@ def face_vert_reveal(
     /,
     *,
     select: bool | None = True,
-):
+) -> None:
     """Reveal hidden faces and vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param select: Select, Specifies whether the newly revealed geometry should be selected
-    :type select: bool | None
     """
 
 def grab_clone(
@@ -212,13 +174,10 @@ def grab_clone(
     /,
     *,
     delta: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
-):
+) -> None:
     """Move the clone source image
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param delta: Delta, Delta offset of clone image in 0.0 to 1.0 coordinates
-    :type delta: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
 def hide_show(
@@ -234,21 +193,14 @@ def hide_show(
     action: typing.Literal["HIDE", "SHOW"] | None = "HIDE",
     area: typing.Literal["OUTSIDE", "Inside"] | None = "Inside",
     use_front_faces_only: bool | None = False,
-):
+) -> None:
     """Hide/show some vertices
 
-        :type execution_context: int | str | None
-        :type undo: 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 action: Visibility Action, Whether to hide or show vertices
 
     HIDE
@@ -256,7 +208,6 @@ def hide_show(
 
     SHOW
     Show -- Show vertices.
-        :type action: typing.Literal['HIDE','SHOW'] | None
         :param area: Visibility Area, Which vertices to hide or show
 
     OUTSIDE
@@ -264,9 +215,7 @@ def hide_show(
 
     Inside
     Inside -- Hide or show vertices inside the selection.
-        :type area: typing.Literal['OUTSIDE','Inside'] | None
         :param use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
     """
 
 def hide_show_all(
@@ -275,11 +224,9 @@ def hide_show_all(
     /,
     *,
     action: typing.Literal["HIDE", "SHOW"] | None = "HIDE",
-):
+) -> None:
     """Hide/show all vertices
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Visibility Action, Whether to hide or show vertices
 
     HIDE
@@ -287,7 +234,6 @@ def hide_show_all(
 
     SHOW
     Show -- Show vertices.
-        :type action: typing.Literal['HIDE','SHOW'] | None
     """
 
 def hide_show_lasso_gesture(
@@ -302,19 +248,13 @@ def hide_show_lasso_gesture(
     action: typing.Literal["HIDE", "SHOW"] | None = "HIDE",
     area: typing.Literal["OUTSIDE", "Inside"] | None = "Inside",
     use_front_faces_only: bool | None = False,
-):
+) -> None:
     """Hide/show some vertices
 
-        :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 action: Visibility Action, Whether to hide or show vertices
 
     HIDE
@@ -322,7 +262,6 @@ def hide_show_lasso_gesture(
 
     SHOW
     Show -- Show vertices.
-        :type action: typing.Literal['HIDE','SHOW'] | None
         :param area: Visibility Area, Which vertices to hide or show
 
     OUTSIDE
@@ -330,9 +269,7 @@ def hide_show_lasso_gesture(
 
     Inside
     Inside -- Hide or show vertices inside the selection.
-        :type area: typing.Literal['OUTSIDE','Inside'] | None
         :param use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
     """
 
 def hide_show_line_gesture(
@@ -350,23 +287,15 @@ def hide_show_line_gesture(
     area: typing.Literal["OUTSIDE", "Inside"] | None = "Inside",
     use_front_faces_only: bool | None = False,
     use_limit_to_segment: bool | None = False,
-):
+) -> None:
     """Hide/show some vertices
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param xstart: X Start
-        :type xstart: int | None
         :param xend: X End
-        :type xend: int | None
         :param ystart: Y Start
-        :type ystart: int | None
         :param yend: Y End
-        :type yend: int | None
         :param flip: Flip
-        :type flip: bool | None
         :param cursor: Cursor, Mouse cursor style to use during the modal operator
-        :type cursor: int | None
         :param action: Visibility Action, Whether to hide or show vertices
 
     HIDE
@@ -374,7 +303,6 @@ def hide_show_line_gesture(
 
     SHOW
     Show -- Show vertices.
-        :type action: typing.Literal['HIDE','SHOW'] | None
         :param area: Visibility Area, Which vertices to hide or show
 
     OUTSIDE
@@ -382,11 +310,8 @@ def hide_show_line_gesture(
 
     Inside
     Inside -- Hide or show vertices inside the selection.
-        :type area: typing.Literal['OUTSIDE','Inside'] | None
         :param use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
         :param use_limit_to_segment: Limit to Segment, Apply the gesture action only to the area that is contained within the segment without extending its effect to the entire line
-        :type use_limit_to_segment: bool | None
     """
 
 def hide_show_masked(
@@ -395,11 +320,9 @@ def hide_show_masked(
     /,
     *,
     action: typing.Literal["HIDE", "SHOW"] | None = "HIDE",
-):
+) -> None:
     """Hide/show all masked vertices above a threshold
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Visibility Action, Whether to hide or show vertices
 
     HIDE
@@ -407,7 +330,6 @@ def hide_show_masked(
 
     SHOW
     Show -- Show vertices.
-        :type action: typing.Literal['HIDE','SHOW'] | None
     """
 
 def hide_show_polyline_gesture(
@@ -419,13 +341,10 @@ def hide_show_polyline_gesture(
     action: typing.Literal["HIDE", "SHOW"] | None = "HIDE",
     area: typing.Literal["OUTSIDE", "Inside"] | None = "Inside",
     use_front_faces_only: bool | None = False,
-):
+) -> None:
     """Hide/show some vertices
 
-        :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 action: Visibility Action, Whether to hide or show vertices
 
     HIDE
@@ -433,7 +352,6 @@ def hide_show_polyline_gesture(
 
     SHOW
     Show -- Show vertices.
-        :type action: typing.Literal['HIDE','SHOW'] | None
         :param area: Visibility Area, Which vertices to hide or show
 
     OUTSIDE
@@ -441,9 +359,7 @@ def hide_show_polyline_gesture(
 
     Inside
     Inside -- Hide or show vertices inside the selection.
-        :type area: typing.Literal['OUTSIDE','Inside'] | None
         :param use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
     """
 
 def image_from_view(
@@ -452,13 +368,10 @@ def image_from_view(
     /,
     *,
     filepath: str = "",
-):
+) -> None:
     """Make an image from biggest 3D view for reprojection
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param filepath: File Path, Name of the file
-    :type filepath: str
     """
 
 def image_paint(
@@ -468,15 +381,13 @@ def image_paint(
     *,
     stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
     | None = None,
-    mode: typing.Literal["NORMAL", "INVERT", "SMOOTH", "ERASE"] | None = "NORMAL",
+    mode: typing.Literal["NORMAL", "INVERT"] | None = "NORMAL",
+    brush_toggle: typing.Literal["None", "SMOOTH", "ERASE", "MASK"] | None = "None",
     pen_flip: bool | None = False,
-):
+) -> None:
     """Paint a stroke into the image
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param stroke: Stroke
-        :type stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement] | None
         :param mode: Stroke Mode, Action taken when a paint stroke is made
 
     NORMAL
@@ -484,15 +395,20 @@ def image_paint(
 
     INVERT
     Invert -- Invert action of brush for duration of stroke.
+        :param brush_toggle: Temporary Brush Toggle Type, Brush to use for duration of stroke
+
+    None
+    None -- Apply brush normally.
 
     SMOOTH
-    Smooth -- Switch brush to smooth mode for duration of stroke.
+    Smooth -- Switch to smooth brush for duration of stroke.
 
     ERASE
-    Erase -- Switch brush to erase mode for duration of stroke.
-        :type mode: typing.Literal['NORMAL','INVERT','SMOOTH','ERASE'] | None
-        :param pen_flip: Pen Flip, Whether a tablet's eraser mode is being used
-        :type pen_flip: bool | None
+    Erase -- Switch to erase brush for duration of stroke.
+
+    MASK
+    Mask -- Switch to mask brush for duration of stroke.
+        :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used
     """
 
 def mask_box_gesture(
@@ -508,36 +424,26 @@ def mask_box_gesture(
     use_front_faces_only: bool | None = False,
     mode: typing.Literal["VALUE", "VALUE_INVERSE", "INVERT"] | None = "VALUE",
     value: float | None = 1.0,
-):
+) -> None:
     """Mask within a rectangle defined by the cursor
 
-        :type execution_context: int | str | None
-        :type undo: 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 use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
         :param mode: Mode
 
     VALUE
-    Value -- Set mask to the level specified by the 'value' property.
+    Value -- Set mask to the level specified by the value property.
 
     VALUE_INVERSE
-    Value Inverted -- Set mask to the level specified by the inverted 'value' property.
+    Value Inverted -- Set mask to the level specified by the inverted value property.
 
     INVERT
     Invert -- Invert the mask.
-        :type mode: typing.Literal['VALUE','VALUE_INVERSE','INVERT'] | None
-        :param value: Value, Mask level to use when mode is 'Value'; zero means no masking and one is fully masked
-        :type value: float | None
+        :param value: Value, Mask level to use when mode is Value; zero means no masking and one is fully masked
     """
 
 def mask_flood_fill(
@@ -547,24 +453,20 @@ def mask_flood_fill(
     *,
     mode: typing.Literal["VALUE", "VALUE_INVERSE", "INVERT"] | None = "VALUE",
     value: float | None = 0.0,
-):
+) -> None:
     """Fill the whole mask with a given value, or invert its values
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param mode: Mode
 
     VALUE
-    Value -- Set mask to the level specified by the 'value' property.
+    Value -- Set mask to the level specified by the value property.
 
     VALUE_INVERSE
-    Value Inverted -- Set mask to the level specified by the inverted 'value' property.
+    Value Inverted -- Set mask to the level specified by the inverted value property.
 
     INVERT
     Invert -- Invert the mask.
-        :type mode: typing.Literal['VALUE','VALUE_INVERSE','INVERT'] | None
-        :param value: Value, Mask level to use when mode is 'Value'; zero means no masking and one is fully masked
-        :type value: float | None
+        :param value: Value, Mask level to use when mode is Value; zero means no masking and one is fully masked
     """
 
 def mask_lasso_gesture(
@@ -579,34 +481,25 @@ def mask_lasso_gesture(
     use_front_faces_only: bool | None = False,
     mode: typing.Literal["VALUE", "VALUE_INVERSE", "INVERT"] | None = "VALUE",
     value: float | None = 1.0,
-):
+) -> None:
     """Mask within a shape defined by the cursor
 
-        :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 use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
         :param mode: Mode
 
     VALUE
-    Value -- Set mask to the level specified by the 'value' property.
+    Value -- Set mask to the level specified by the value property.
 
     VALUE_INVERSE
-    Value Inverted -- Set mask to the level specified by the inverted 'value' property.
+    Value Inverted -- Set mask to the level specified by the inverted value property.
 
     INVERT
     Invert -- Invert the mask.
-        :type mode: typing.Literal['VALUE','VALUE_INVERSE','INVERT'] | None
-        :param value: Value, Mask level to use when mode is 'Value'; zero means no masking and one is fully masked
-        :type value: float | None
+        :param value: Value, Mask level to use when mode is Value; zero means no masking and one is fully masked
     """
 
 def mask_line_gesture(
@@ -624,40 +517,28 @@ def mask_line_gesture(
     use_limit_to_segment: bool | None = False,
     mode: typing.Literal["VALUE", "VALUE_INVERSE", "INVERT"] | None = "VALUE",
     value: float | None = 1.0,
-):
+) -> None:
     """Mask to one side of a line defined by the cursor
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param xstart: X Start
-        :type xstart: int | None
         :param xend: X End
-        :type xend: int | None
         :param ystart: Y Start
-        :type ystart: int | None
         :param yend: Y End
-        :type yend: int | None
         :param flip: Flip
-        :type flip: bool | None
         :param cursor: Cursor, Mouse cursor style to use during the modal operator
-        :type cursor: int | None
         :param use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
         :param use_limit_to_segment: Limit to Segment, Apply the gesture action only to the area that is contained within the segment without extending its effect to the entire line
-        :type use_limit_to_segment: bool | None
         :param mode: Mode
 
     VALUE
-    Value -- Set mask to the level specified by the 'value' property.
+    Value -- Set mask to the level specified by the value property.
 
     VALUE_INVERSE
-    Value Inverted -- Set mask to the level specified by the inverted 'value' property.
+    Value Inverted -- Set mask to the level specified by the inverted value property.
 
     INVERT
     Invert -- Invert the mask.
-        :type mode: typing.Literal['VALUE','VALUE_INVERSE','INVERT'] | None
-        :param value: Value, Mask level to use when mode is 'Value'; zero means no masking and one is fully masked
-        :type value: float | None
+        :param value: Value, Mask level to use when mode is Value; zero means no masking and one is fully masked
     """
 
 def mask_polyline_gesture(
@@ -669,28 +550,22 @@ def mask_polyline_gesture(
     use_front_faces_only: bool | None = False,
     mode: typing.Literal["VALUE", "VALUE_INVERSE", "INVERT"] | None = "VALUE",
     value: float | None = 1.0,
-):
+) -> None:
     """Mask within a shape defined by the cursor
 
-        :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_front_faces_only: Front Faces Only, Affect only faces facing towards the view
-        :type use_front_faces_only: bool | None
         :param mode: Mode
 
     VALUE
-    Value -- Set mask to the level specified by the 'value' property.
+    Value -- Set mask to the level specified by the value property.
 
     VALUE_INVERSE
-    Value Inverted -- Set mask to the level specified by the inverted 'value' property.
+    Value Inverted -- Set mask to the level specified by the inverted value property.
 
     INVERT
     Invert -- Invert the mask.
-        :type mode: typing.Literal['VALUE','VALUE_INVERSE','INVERT'] | None
-        :param value: Value, Mask level to use when mode is 'Value'; zero means no masking and one is fully masked
-        :type value: float | None
+        :param value: Value, Mask level to use when mode is Value; zero means no masking and one is fully masked
     """
 
 def project_image(
@@ -699,13 +574,10 @@ def project_image(
     /,
     *,
     image: str | None = "",
-):
+) -> None:
     """Project an edited render from the active camera back onto the object
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param image: Image
-    :type image: str | None
     """
 
 def sample_color(
@@ -716,27 +588,20 @@ def sample_color(
     location: collections.abc.Iterable[int] | None = (0, 0),
     merged: bool | None = False,
     palette: bool | None = False,
-):
+) -> None:
     """Use the mouse to sample a color in the image
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param location: Location
-    :type location: collections.abc.Iterable[int] | None
     :param merged: Sample Merged, Sample the output display color
-    :type merged: bool | None
     :param palette: Add to Palette
-    :type palette: bool | None
     """
 
 def texture_paint_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Toggle texture paint mode in 3D view
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle texture paint mode in 3D view"""
 
 def vert_select_all(
     execution_context: int | str | None = None,
@@ -744,11 +609,9 @@ def vert_select_all(
     /,
     *,
     action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"] | None = "TOGGLE",
-):
+) -> None:
     """Change selection for all vertices
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Action, Selection action to execute
 
     TOGGLE
@@ -762,7 +625,6 @@ def vert_select_all(
 
     INVERT
     Invert -- Invert selection of all elements.
-        :type action: typing.Literal['TOGGLE','SELECT','DESELECT','INVERT'] | None
     """
 
 def vert_select_hide(
@@ -771,13 +633,10 @@ def vert_select_hide(
     /,
     *,
     unselected: bool | None = False,
-):
+) -> None:
     """Hide selected vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param unselected: Unselected, Hide unselected rather than selected vertices
-    :type unselected: bool | None
     """
 
 def vert_select_less(
@@ -786,23 +645,18 @@ def vert_select_less(
     /,
     *,
     face_step: bool | None = True,
-):
+) -> None:
     """Deselect Vertices connected to existing selection
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param face_step: Face Step, Also deselect faces that only touch on a corner
-    :type face_step: bool | None
     """
 
 def vert_select_linked(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Select linked vertices
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select linked vertices"""
 
 def vert_select_linked_pick(
     execution_context: int | str | None = None,
@@ -810,13 +664,24 @@ def vert_select_linked_pick(
     /,
     *,
     select: bool | None = True,
-):
+) -> None:
     """Select linked vertices under the cursor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param select: Select, Whether to select or deselect linked vertices under the cursor
-    :type select: bool | None
+    """
+
+def vert_select_loop(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    select: bool | None = True,
+    extend: bool | None = False,
+) -> None:
+    """Select vertex loop under the cursor
+
+    :param select: Select, If false, vertices will be deselected
+    :param extend: Extend, Extend the selection
     """
 
 def vert_select_more(
@@ -825,13 +690,10 @@ def vert_select_more(
     /,
     *,
     face_step: bool | None = True,
-):
+) -> None:
     """Select Vertices connected to existing selection
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param face_step: Face Step, Also select faces that only touch on a corner
-    :type face_step: bool | None
     """
 
 def vert_select_ungrouped(
@@ -840,13 +702,10 @@ def vert_select_ungrouped(
     /,
     *,
     extend: bool | None = False,
-):
+) -> None:
     """Select vertices without a group
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend the selection
-    :type extend: bool | None
     """
 
 def vertex_color_brightness_contrast(
@@ -856,15 +715,11 @@ def vertex_color_brightness_contrast(
     *,
     brightness: float | None = 0.0,
     contrast: float | None = 0.0,
-):
+) -> None:
     """Adjust vertex color brightness/contrast
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param brightness: Brightness
-    :type brightness: float | None
     :param contrast: Contrast
-    :type contrast: float | None
     """
 
 def vertex_color_dirt(
@@ -878,33 +733,23 @@ def vertex_color_dirt(
     dirt_angle: float | None = 0.0,
     dirt_only: bool | None = False,
     normalize: bool | None = True,
-):
+) -> None:
     """Generate a dirt map gradient based on cavity
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param blur_strength: Blur Strength, Blur strength per iteration
-    :type blur_strength: float | None
     :param blur_iterations: Blur Iterations, Number of times to blur the colors (higher blurs more)
-    :type blur_iterations: int | None
     :param clean_angle: Highlight Angle, Less than 90 limits the angle used in the tonal range
-    :type clean_angle: float | None
     :param dirt_angle: Dirt Angle, Less than 90 limits the angle used in the tonal range
-    :type dirt_angle: float | None
-    :param dirt_only: Dirt Only, Don't calculate cleans for convex areas
-    :type dirt_only: bool | None
+    :param dirt_only: Dirt Only, Dont calculate cleans for convex areas
     :param normalize: Normalize, Normalize the colors, increasing the contrast
-    :type normalize: bool | None
     """
 
 def vertex_color_from_weight(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Convert active weight into gray scale vertex colors
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Convert active weight into gray scale vertex colors"""
 
 def vertex_color_hsv(
     execution_context: int | str | None = None,
@@ -914,27 +759,20 @@ def vertex_color_hsv(
     h: float | None = 0.5,
     s: float | None = 1.0,
     v: float | None = 1.0,
-):
+) -> None:
     """Adjust vertex color Hue/Saturation/Value
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param h: Hue
-    :type h: float | None
     :param s: Saturation
-    :type s: float | None
     :param v: Value
-    :type v: float | None
     """
 
 def vertex_color_invert(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Invert RGB values
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Invert RGB values"""
 
 def vertex_color_levels(
     execution_context: int | str | None = None,
@@ -943,15 +781,11 @@ def vertex_color_levels(
     *,
     offset: float | None = 0.0,
     gain: float | None = 1.0,
-):
+) -> None:
     """Adjust levels of vertex colors
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param offset: Offset, Value to add to colors
-    :type offset: float | None
     :param gain: Gain, Value to multiply colors by
-    :type gain: float | None
     """
 
 def vertex_color_set(
@@ -960,23 +794,18 @@ def vertex_color_set(
     /,
     *,
     use_alpha: bool | None = True,
-):
+) -> None:
     """Fill the active vertex color layer with the current paint color
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param use_alpha: Affect Alpha, Set color completely opaque instead of reusing existing alpha
-    :type use_alpha: bool | None
     """
 
 def vertex_color_smooth(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Smooth colors across vertices
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Smooth colors across vertices"""
 
 def vertex_paint(
     execution_context: int | str | None = None,
@@ -985,16 +814,14 @@ def vertex_paint(
     *,
     stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
     | None = None,
-    mode: typing.Literal["NORMAL", "INVERT", "SMOOTH", "ERASE"] | None = "NORMAL",
+    mode: typing.Literal["NORMAL", "INVERT"] | None = "NORMAL",
+    brush_toggle: typing.Literal["None", "SMOOTH", "ERASE", "MASK"] | None = "None",
     pen_flip: bool | None = False,
     override_location: bool | None = False,
-):
+) -> None:
     """Paint a stroke in the active color attribute layer
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param stroke: Stroke
-        :type stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement] | None
         :param mode: Stroke Mode, Action taken when a paint stroke is made
 
     NORMAL
@@ -1002,27 +829,29 @@ def vertex_paint(
 
     INVERT
     Invert -- Invert action of brush for duration of stroke.
+        :param brush_toggle: Temporary Brush Toggle Type, Brush to use for duration of stroke
+
+    None
+    None -- Apply brush normally.
 
     SMOOTH
-    Smooth -- Switch brush to smooth mode for duration of stroke.
+    Smooth -- Switch to smooth brush for duration of stroke.
 
     ERASE
-    Erase -- Switch brush to erase mode for duration of stroke.
-        :type mode: typing.Literal['NORMAL','INVERT','SMOOTH','ERASE'] | None
-        :param pen_flip: Pen Flip, Whether a tablet's eraser mode is being used
-        :type pen_flip: bool | None
-        :param override_location: Override Location, Override the given location array by recalculating object space positions from the provided mouse_event positions
-        :type override_location: bool | None
+    Erase -- Switch to erase brush for duration of stroke.
+
+    MASK
+    Mask -- Switch to mask brush for duration of stroke.
+        :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used
+        :param override_location: Override Location, Override the given "location" array by recalculating object space positions from the provided "mouse_event" positions
     """
 
 def vertex_paint_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Toggle the vertex paint mode in 3D view
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle the vertex paint mode in 3D view"""
 
 def visibility_filter(
     execution_context: int | str | None = None,
@@ -1032,11 +861,9 @@ def visibility_filter(
     action: typing.Literal["GROW", "SHRINK"] | None = "GROW",
     iterations: int | None = 1,
     auto_iteration_count: bool | None = True,
-):
+) -> None:
     """Edit the visibility of the current mesh
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Action
 
     GROW
@@ -1044,21 +871,16 @@ def visibility_filter(
 
     SHRINK
     Shrink Visibility -- Shrink the visibility by one face based on mesh topology.
-        :type action: typing.Literal['GROW','SHRINK'] | None
         :param iterations: Iterations, Number of times that the filter is going to be applied
-        :type iterations: int | None
         :param auto_iteration_count: Auto Iteration Count, Use an automatic number of iterations based on the number of vertices of the sculpt
-        :type auto_iteration_count: bool | None
     """
 
 def visibility_invert(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Invert the visibility of all vertices
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Invert the visibility of all vertices"""
 
 def weight_from_bones(
     execution_context: int | str | None = None,
@@ -1066,11 +888,9 @@ def weight_from_bones(
     /,
     *,
     type: typing.Literal["AUTOMATIC", "ENVELOPES"] | None = "AUTOMATIC",
-):
-    """Set the weights of the groups matching the attached armature's selected bones, using the distance between the vertices and the bones
+) -> None:
+    """Set the weights of the groups matching the attached armatures selected bones, using the distance between the vertices and the bones
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param type: Type, Method to use for assigning weights
 
     AUTOMATIC
@@ -1078,7 +898,6 @@ def weight_from_bones(
 
     ENVELOPES
     From Envelopes -- Weights from envelopes with user defined radius.
-        :type type: typing.Literal['AUTOMATIC','ENVELOPES'] | None
     """
 
 def weight_gradient(
@@ -1093,25 +912,16 @@ def weight_gradient(
     yend: int | None = 0,
     flip: bool | None = False,
     cursor: int | None = 5,
-):
+) -> None:
     """Draw a line to apply a weight gradient to selected vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Type
-    :type type: typing.Literal['LINEAR','RADIAL'] | None
     :param xstart: X Start
-    :type xstart: int | None
     :param xend: X End
-    :type xend: int | None
     :param ystart: Y Start
-    :type ystart: int | None
     :param yend: Y End
-    :type yend: int | None
     :param flip: Flip
-    :type flip: bool | None
     :param cursor: Cursor, Mouse cursor style to use during the modal operator
-    :type cursor: int | None
     """
 
 def weight_paint(
@@ -1121,16 +931,14 @@ def weight_paint(
     *,
     stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
     | None = None,
-    mode: typing.Literal["NORMAL", "INVERT", "SMOOTH", "ERASE"] | None = "NORMAL",
+    mode: typing.Literal["NORMAL", "INVERT"] | None = "NORMAL",
+    brush_toggle: typing.Literal["None", "SMOOTH", "ERASE", "MASK"] | None = "None",
     pen_flip: bool | None = False,
     override_location: bool | None = False,
-):
-    """Paint a stroke in the current vertex group's weights
+) -> None:
+    """Paint a stroke in the current vertex groups weights
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param stroke: Stroke
-        :type stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement] | None
         :param mode: Stroke Mode, Action taken when a paint stroke is made
 
     NORMAL
@@ -1138,47 +946,47 @@ def weight_paint(
 
     INVERT
     Invert -- Invert action of brush for duration of stroke.
+        :param brush_toggle: Temporary Brush Toggle Type, Brush to use for duration of stroke
+
+    None
+    None -- Apply brush normally.
 
     SMOOTH
-    Smooth -- Switch brush to smooth mode for duration of stroke.
+    Smooth -- Switch to smooth brush for duration of stroke.
 
     ERASE
-    Erase -- Switch brush to erase mode for duration of stroke.
-        :type mode: typing.Literal['NORMAL','INVERT','SMOOTH','ERASE'] | None
-        :param pen_flip: Pen Flip, Whether a tablet's eraser mode is being used
-        :type pen_flip: bool | None
-        :param override_location: Override Location, Override the given location array by recalculating object space positions from the provided mouse_event positions
-        :type override_location: bool | None
-    """
-
-def weight_paint_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Toggle weight paint mode in 3D view
+    Erase -- Switch to erase brush for duration of stroke.
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    MASK
+    Mask -- Switch to mask brush for duration of stroke.
+        :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used
+        :param override_location: Override Location, Override the given "location" array by recalculating object space positions from the provided "mouse_event" positions
     """
 
-def weight_sample(execution_context: int | str | None = None, undo: bool | None = None):
-    """Use the mouse to sample a weight in the 3D view
+def weight_paint_toggle(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle weight paint mode in 3D view"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def weight_sample(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Use the mouse to sample a weight in the 3D view"""
 
 def weight_sample_group(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Select one of the vertex groups available under current mouse position
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def weight_set(execution_context: int | str | None = None, undo: bool | None = None):
-    """Fill the active vertex group with the current paint weight
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select one of the vertex groups available under current mouse position"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def weight_set(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Fill the active vertex group with the current paint weight"""