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

bpy/ops/uv/__init__.pyi

@@ -1,8 +1,9 @@
 import typing
 import collections.abc
 import typing_extensions
-import bpy._typing.rna_enums
+import numpy.typing as npt
 import bpy.ops.transform
+import bpy.stub_internal.rna_enums
 import bpy.types
 import mathutils
 
@@ -15,11 +16,10 @@ def align(
         "ALIGN_S", "ALIGN_T", "ALIGN_U", "ALIGN_AUTO", "ALIGN_X", "ALIGN_Y"
     ]
     | None = "ALIGN_AUTO",
-):
+    position_mode: typing.Literal["MEAN", "MIN", "MAX"] | None = "MEAN",
+) -> None:
     """Aligns selected UV vertices on a line
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param axis: Axis, Axis to align UV locations on
 
     ALIGN_S
@@ -39,7 +39,16 @@ def align(
 
     ALIGN_Y
     Align Horizontally -- Align UV vertices on a horizontal line.
-        :type axis: typing.Literal['ALIGN_S','ALIGN_T','ALIGN_U','ALIGN_AUTO','ALIGN_X','ALIGN_Y'] | None
+        :param position_mode: Position Mode, Method of calculating the alignment position
+
+    MEAN
+    Mean -- Align UVs along the mean position.
+
+    MIN
+    Minimum -- Align UVs along the minimum position.
+
+    MAX
+    Maximum -- Align UVs along the maximum position.
     """
 
 def align_rotation(
@@ -50,11 +59,9 @@ def align_rotation(
     method: typing.Literal["AUTO", "EDGE", "GEOMETRY"] | None = "AUTO",
     axis: typing.Literal["X", "Y", "Z"] | None = "X",
     correct_aspect: bool | None = False,
-):
-    """Align the UV island's rotation
+) -> None:
+    """Align the UV islands rotation
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param method: Method, Method to calculate rotation angle
 
     AUTO
@@ -65,7 +72,6 @@ def align_rotation(
 
     GEOMETRY
     Geometry -- Align to Geometry axis.
-        :type method: typing.Literal['AUTO','EDGE','GEOMETRY'] | None
         :param axis: Axis, Axis to align to
 
     X
@@ -76,9 +82,68 @@ def align_rotation(
 
     Z
     Z -- Z axis.
-        :type axis: typing.Literal['X','Y','Z'] | None
         :param correct_aspect: Correct Aspect, Take image aspect ratio into account
-        :type correct_aspect: bool | None
+    """
+
+def arrange_islands(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    initial_position: typing.Literal["BOUNDING_BOX", "UV_GRID", "ACTIVE_UDIM", "CURSOR"]
+    | None = "BOUNDING_BOX",
+    axis: typing.Literal["X", "Y"] | None = "Y",
+    align: typing.Literal["MIN", "MAX", "CENTER", "NONE"] | None = "MIN",
+    order: typing.Literal["LARGE_TO_SMALL", "SMALL_TO_LARGE", "Fixed"]
+    | None = "LARGE_TO_SMALL",
+    margin: float | None = 0.05,
+) -> None:
+    """Arrange selected UV islands on a line
+
+        :param initial_position: Initial Position, Initial position to arrange islands from
+
+    BOUNDING_BOX
+    Bounding Box -- Initial alignment based on the islands bounding box.
+
+    UV_GRID
+    UV Grid -- Initial alignment based on UV Tile Grid.
+
+    ACTIVE_UDIM
+    Active UDIM -- Initial alignment based on Active UDIM.
+
+    CURSOR
+    2D Cursor -- Initial alignment based on 2D cursor.
+        :param axis: Axis, Axis to arrange UV islands on
+
+    X
+    X -- Align UV islands along the X axis.
+
+    Y
+    Y -- Align UV islands along the Y axis.
+        :param align: Align, Location to align islands on
+
+    MIN
+    Min -- Align the islands to the min of the island.
+
+    MAX
+    Max -- Align the islands to the left side of the island.
+
+    CENTER
+    Center -- Align the islands to the center of the largest island.
+
+    NONE
+    None -- Preserve island alignment.
+        :param order: Order, Order of islands
+
+    LARGE_TO_SMALL
+    Largest to Smallest -- Sort islands from largest to smallest.
+
+    SMALL_TO_LARGE
+    Smallest to Largest -- Sort islands from smallest to largest.
+
+    Fixed
+    Fixed -- Preserve island order.
+        :param margin: Margin, Space between islands
     """
 
 def average_islands_scale(
@@ -88,22 +153,32 @@ def average_islands_scale(
     *,
     scale_uv: bool | None = False,
     shear: bool | None = False,
-):
+) -> None:
     """Average the size of separate UV islands, based on their area in 3D space
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param scale_uv: Non-Uniform, Scale U and V independently
-    :type scale_uv: bool | None
     :param shear: Shear, Reduce shear within islands
-    :type shear: bool | None
     """
 
-def copy(execution_context: int | str | None = None, undo: bool | None = None):
-    """Copy selected UV vertices
+def copy(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Copy selected UV vertices"""
+
+def copy_mirrored_faces(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["POSITIVE", "NEGATIVE"] | None = "POSITIVE",
+    precision: int | None = 3,
+) -> None:
+    """Copy mirror UV coordinates on the X axis based on a mirrored mesh
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param direction: Axis Direction
+    :param precision: Precision, Tolerance for finding vertex duplicates
     """
 
 def cube_project(
@@ -115,19 +190,13 @@ def cube_project(
     correct_aspect: bool | None = True,
     clip_to_bounds: bool | None = False,
     scale_to_bounds: bool | None = False,
-):
+) -> None:
     """Project the UV vertices of the mesh over the six faces of a cube
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param cube_size: Cube Size, Size of the cube to project on
-    :type cube_size: float | None
     :param correct_aspect: Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
-    :type correct_aspect: bool | None
     :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-    :type clip_to_bounds: bool | None
     :param scale_to_bounds: Scale to Bounds, Scale UV coordinates to bounds after unwrapping
-    :type scale_to_bounds: bool | None
     """
 
 def cursor_set(
@@ -136,13 +205,30 @@ def cursor_set(
     /,
     *,
     location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
-):
+) -> None:
     """Set 2D cursor location
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param location: Location, Cursor location in normalized (0.0 to 1.0) coordinates
-    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
+    """
+
+def custom_region_set(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    xmin: int | None = 0,
+    xmax: int | None = 0,
+    ymin: int | None = 0,
+    ymax: int | None = 0,
+    wait_for_input: bool | None = True,
+) -> None:
+    """Set the boundaries of the user region
+
+    :param xmin: X Min
+    :param xmax: X Max
+    :param ymin: Y Min
+    :param ymax: Y Max
+    :param wait_for_input: Wait for Input
     """
 
 def cylinder_project(
@@ -159,11 +245,9 @@ def cylinder_project(
     correct_aspect: bool | None = True,
     clip_to_bounds: bool | None = False,
     scale_to_bounds: bool | None = False,
-):
+) -> None:
     """Project the UV vertices of the mesh over the curved wall of a cylinder
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param direction: Direction, Direction of the sphere or cylinder
 
     VIEW_ON_EQUATOR
@@ -174,7 +258,6 @@ def cylinder_project(
 
     ALIGN_TO_OBJECT
     Align to Object -- Align according to object transform.
-        :type direction: typing.Literal['VIEW_ON_EQUATOR','VIEW_ON_POLES','ALIGN_TO_OBJECT'] | None
         :param align: Align, How to determine rotation around the pole
 
     POLAR_ZX
@@ -182,7 +265,6 @@ def cylinder_project(
 
     POLAR_ZY
     Polar ZY -- Polar 0 is Y.
-        :type align: typing.Literal['POLAR_ZX','POLAR_ZY'] | None
         :param pole: Pole, How to handle faces at the poles
 
     PINCH
@@ -190,17 +272,11 @@ def cylinder_project(
 
     FAN
     Fan -- UVs are fanned at the poles.
-        :type pole: typing.Literal['PINCH','FAN'] | None
         :param seam: Preserve Seams, Separate projections by islands isolated by seams
-        :type seam: bool | None
         :param radius: Radius, Radius of the sphere or cylinder
-        :type radius: float | None
         :param correct_aspect: Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
-        :type correct_aspect: bool | None
         :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-        :type clip_to_bounds: bool | None
         :param scale_to_bounds: Scale to Bounds, Scale UV coordinates to bounds after unwrapping
-        :type scale_to_bounds: bool | None
     """
 
 def export_layout(
@@ -216,15 +292,11 @@ def export_layout(
     size: collections.abc.Iterable[int] | None = (1024, 1024),
     opacity: float | None = 0.25,
     check_existing: bool | None = True,
-):
+) -> None:
     """Export UV layout to file
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param filepath: filepath
-        :type filepath: str
         :param export_all: All UVs, Export all UVs in this mesh (not just visible ones)
-        :type export_all: bool | None
         :param export_tiles: Export Tiles, Choose whether to export only the [0, 1] range, or all UV tiles
 
     NONE
@@ -235,9 +307,7 @@ def export_layout(
 
     UV
     UVTILE -- Export tiles in the UVTILE numbering scheme: u(u_tile + 1)_v(v_tile + 1).
-        :type export_tiles: typing.Literal['NONE','UDIM','UV'] | None
         :param modified: Modified, Exports UVs from the modified mesh
-        :type modified: bool | None
         :param mode: Format, File format to export the UV layout to
 
     SVG
@@ -248,13 +318,9 @@ def export_layout(
 
     PNG
     PNG Image (.png) -- Export the UV layout to a bitmap image.
-        :type mode: typing.Literal['SVG','EPS','PNG'] | None
         :param size: Size, Dimensions of the exported file
-        :type size: collections.abc.Iterable[int] | None
         :param opacity: Fill Opacity, Set amount of opacity for exported UV layout
-        :type opacity: float | None
         :param check_existing: check_existing
-        :type check_existing: bool | None
     """
 
 def follow_active_quads(
@@ -263,11 +329,9 @@ def follow_active_quads(
     /,
     *,
     mode: typing.Literal["EVEN", "LENGTH", "LENGTH_AVERAGE"] | None = "LENGTH_AVERAGE",
-):
+) -> None:
     """Follow UVs from active quads along continuous face loops
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param mode: Edge Length Mode, Method to space UV edge loops
 
     EVEN
@@ -278,7 +342,6 @@ def follow_active_quads(
 
     LENGTH_AVERAGE
     Length Average -- Average space UVs edge length of each loop.
-        :type mode: typing.Literal['EVEN','LENGTH','LENGTH_AVERAGE'] | None
     """
 
 def hide(
@@ -287,13 +350,10 @@ def hide(
     /,
     *,
     unselected: bool | None = False,
-):
+) -> None:
     """Hide (un)selected UV vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param unselected: Unselected, Hide unselected rather than selected
-    :type unselected: bool | None
     """
 
 def lightmap_pack(
@@ -306,11 +366,9 @@ def lightmap_pack(
     PREF_NEW_UVLAYER: bool | None = False,
     PREF_BOX_DIV: int | None = 12,
     PREF_MARGIN_DIV: float | None = 0.1,
-):
-    """Pack each face's UVs into the UV bounds
+) -> None:
+    """Pack each faces UVs into the UV bounds
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param PREF_CONTEXT: Selection
 
     SEL_FACES
@@ -318,15 +376,10 @@ def lightmap_pack(
 
     ALL_FACES
     All Faces -- Average space UVs edge length of each loop.
-        :type PREF_CONTEXT: typing.Literal['SEL_FACES','ALL_FACES'] | None
         :param PREF_PACK_IN_ONE: Share Texture Space, Objects share texture space, map all objects into a single UV map
-        :type PREF_PACK_IN_ONE: bool | None
         :param PREF_NEW_UVLAYER: New UV Map, Create a new UV map for every mesh packed
-        :type PREF_NEW_UVLAYER: bool | None
         :param PREF_BOX_DIV: Pack Quality, Quality of the packing. Higher values will be slower but waste less space
-        :type PREF_BOX_DIV: int | None
         :param PREF_MARGIN_DIV: Margin, Size of the margin as a division of the UV
-        :type PREF_MARGIN_DIV: float | None
     """
 
 def mark_seam(
@@ -335,13 +388,10 @@ def mark_seam(
     /,
     *,
     clear: bool | None = False,
-):
+) -> None:
     """Mark selected UV edges as seams
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param clear: Clear Seams, Clear instead of marking seams
-    :type clear: bool | None
     """
 
 def minimize_stretch(
@@ -352,17 +402,43 @@ def minimize_stretch(
     fill_holes: bool | None = True,
     blend: float | None = 0.0,
     iterations: int | None = 0,
-):
+) -> None:
     """Reduce UV stretching by relaxing angles
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param fill_holes: Fill Holes, Virtually fill holes in mesh before unwrapping, to better avoid overlaps and preserve symmetry
-    :type fill_holes: bool | None
     :param blend: Blend, Blend factor between stretch minimized and original
-    :type blend: float | None
     :param iterations: Iterations, Number of iterations to run, 0 is unlimited when run interactively
-    :type iterations: int | None
+    """
+
+def move_on_axis(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    type: typing.Literal["DYNAMIC", "PIXEL", "UDIM"] | None = "UDIM",
+    axis: typing.Literal["X", "Y"] | None = "X",
+    distance: int | None = 1,
+) -> None:
+    """Move UVs on an axis
+
+        :param type: Type, Move Type
+
+    DYNAMIC
+    Dynamic -- Move by dynamic grid.
+
+    PIXEL
+    Pixel -- Move by pixel.
+
+    UDIM
+    UDIM -- Move by UDIM.
+        :param axis: Axis, Axis to move UVs on
+
+    X
+    X axis -- Move vertices on the X axis.
+
+    Y
+    Y axis -- Move vertices on the Y axis.
+        :param distance: Distance, Distance to move UVs
     """
 
 def pack_islands(
@@ -370,7 +446,9 @@ def pack_islands(
     undo: bool | None = None,
     /,
     *,
-    udim_source: typing.Literal["CLOSEST_UDIM", "ACTIVE_UDIM", "ORIGINAL_AABB"]
+    udim_source: typing.Literal[
+        "CLOSEST_UDIM", "ACTIVE_UDIM", "ORIGINAL_AABB", "CUSTOM_REGION"
+    ]
     | None = "CLOSEST_UDIM",
     rotate: bool | None = True,
     rotate_method: typing.Literal[
@@ -385,11 +463,9 @@ def pack_islands(
     pin_method: typing.Literal["SCALE", "ROTATION", "ROTATION_SCALE", "LOCKED"]
     | None = "LOCKED",
     shape_method: typing.Literal["CONCAVE", "CONVEX", "AABB"] | None = "CONCAVE",
-):
+) -> None:
     """Transform all islands so that they fill up the UV/UDIM space as much as possible
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param udim_source: Pack to
 
     CLOSEST_UDIM
@@ -400,9 +476,10 @@ def pack_islands(
 
     ORIGINAL_AABB
     Original bounding box -- Pack to starting bounding box of islands.
-        :type udim_source: typing.Literal['CLOSEST_UDIM','ACTIVE_UDIM','ORIGINAL_AABB'] | None
+
+    CUSTOM_REGION
+    Custom Region -- Pack islands to custom region.
         :param rotate: Rotate, Rotate islands to improve layout
-        :type rotate: bool | None
         :param rotate_method: Rotation Method
 
     ANY
@@ -419,11 +496,8 @@ def pack_islands(
 
     AXIS_ALIGNED_Y
     Axis-aligned (Vertical) -- Rotate islands to be aligned vertically.
-        :type rotate_method: typing.Literal['ANY','CARDINAL','AXIS_ALIGNED','AXIS_ALIGNED_X','AXIS_ALIGNED_Y'] | None
         :param scale: Scale, Scale islands to fill unit square
-        :type scale: bool | None
         :param merge_overlap: Merge Overlapping, Overlapping islands stick together
-        :type merge_overlap: bool | None
         :param margin_method: Margin Method
 
     SCALED
@@ -434,25 +508,21 @@ def pack_islands(
 
     FRACTION
     Fraction -- Specify a precise fraction of final UV output.
-        :type margin_method: typing.Literal['SCALED','ADD','FRACTION'] | None
         :param margin: Margin, Space between islands
-        :type margin: float | None
-        :param pin: Lock Pinned Islands, Constrain islands containing any pinned UV's
-        :type pin: bool | None
+        :param pin: Lock Pinned Islands, Constrain islands containing any pinned UVs
         :param pin_method: Pin Method
 
     SCALE
-    Scale -- Pinned islands won't rescale.
+    Scale -- Pinned islands wont rescale.
 
     ROTATION
-    Rotation -- Pinned islands won't rotate.
+    Rotation -- Pinned islands wont rotate.
 
     ROTATION_SCALE
     Rotation and Scale -- Pinned islands will translate only.
 
     LOCKED
     All -- Pinned islands are locked in place.
-        :type pin_method: typing.Literal['SCALE','ROTATION','ROTATION_SCALE','LOCKED'] | None
         :param shape_method: Shape Method
 
     CONCAVE
@@ -463,15 +533,14 @@ def pack_islands(
 
     AABB
     Bounding Box -- Uses bounding boxes.
-        :type shape_method: typing.Literal['CONCAVE','CONVEX','AABB'] | None
     """
 
-def paste(execution_context: int | str | None = None, undo: bool | None = None):
-    """Paste selected UV vertices
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def paste(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Paste selected UV vertices"""
 
 def pin(
     execution_context: int | str | None = None,
@@ -480,15 +549,11 @@ def pin(
     *,
     clear: bool | None = False,
     invert: bool | None = False,
-):
+) -> None:
     """Set/clear selected UV vertices as anchored between multiple unwrap operations
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param clear: Clear, Clear pinning for the selection instead of setting it
-    :type clear: bool | None
     :param invert: Invert, Invert pinning for the selection instead of setting it
-    :type invert: bool | None
     """
 
 def project_from_view(
@@ -501,21 +566,14 @@ def project_from_view(
     correct_aspect: bool | None = True,
     clip_to_bounds: bool | None = False,
     scale_to_bounds: bool | None = False,
-):
+) -> None:
     """Project the UV vertices of the mesh as seen in current 3D view
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param orthographic: Orthographic, Use orthographic projection
-    :type orthographic: bool | None
     :param camera_bounds: Camera Bounds, Map UVs to the camera region taking resolution and aspect into account
-    :type camera_bounds: bool | None
     :param correct_aspect: Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
-    :type correct_aspect: bool | None
     :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-    :type clip_to_bounds: bool | None
     :param scale_to_bounds: Scale to Bounds, Scale UV coordinates to bounds after unwrapping
-    :type scale_to_bounds: bool | None
     """
 
 def randomize_uv_transform(
@@ -531,27 +589,17 @@ def randomize_uv_transform(
     use_scale: bool | None = True,
     scale_even: bool | None = False,
     scale: collections.abc.Iterable[float] | None = (1.0, 1.0),
-):
-    """Randomize the UV island's location, rotation, and scale
+) -> None:
+    """Randomize the UV islands location, rotation, and scale
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param random_seed: Random Seed, Seed value for the random generator
-    :type random_seed: int | None
     :param use_loc: Randomize Location, Randomize the location values
-    :type use_loc: bool | None
     :param loc: Location, Maximum distance the objects can spread over each axis
-    :type loc: collections.abc.Sequence[float] | mathutils.Vector | None
     :param use_rot: Randomize Rotation, Randomize the rotation value
-    :type use_rot: bool | None
     :param rot: Rotation, Maximum rotation
-    :type rot: float | None
     :param use_scale: Randomize Scale, Randomize the scale values
-    :type use_scale: bool | None
     :param scale_even: Scale Even, Use the same scale value for both axes
-    :type scale_even: bool | None
     :param scale: Scale, Maximum scale randomization over each axis
-    :type scale: collections.abc.Iterable[float] | None
     """
 
 def remove_doubles(
@@ -562,25 +610,20 @@ def remove_doubles(
     threshold: float | None = 0.02,
     use_unselected: bool | None = False,
     use_shared_vertex: bool | None = False,
-):
+) -> None:
     """Selected UV vertices that are within a radius of each other are welded together
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param threshold: Merge Distance, Maximum distance between welded vertices
-    :type threshold: float | None
     :param use_unselected: Unselected, Merge selected to other unselected vertices
-    :type use_unselected: bool | None
     :param use_shared_vertex: Shared Vertex, Weld UVs based on shared vertices
-    :type use_shared_vertex: bool | None
     """
 
-def reset(execution_context: int | str | None = None, undo: bool | None = None):
-    """Reset UV projection
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def reset(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Reset UV projection"""
 
 def reveal(
     execution_context: int | str | None = None,
@@ -588,13 +631,10 @@ def reveal(
     /,
     *,
     select: bool | None = True,
-):
+) -> None:
     """Reveal all hidden UV vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param select: Select
-    :type select: bool | None
     """
 
 def rip(
@@ -606,19 +646,13 @@ def rip(
     release_confirm: bool | None = False,
     use_accurate: bool | None = False,
     location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
-):
+) -> None:
     """Rip selected vertices or a selected region
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param mirror: Mirror Editing
-    :type mirror: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
 def rip_move(
@@ -628,15 +662,11 @@ def rip_move(
     *,
     UV_OT_rip: rip | None = None,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
-):
+) -> None:
     """Unstitch UVs and move the result
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param UV_OT_rip: UV Rip, Rip selected vertices or a selected region
-    :type UV_OT_rip: rip | None
     :param TRANSFORM_OT_translate: Move, Move selected items
-    :type TRANSFORM_OT_translate: bpy.ops.transform.translate | None
     """
 
 def seams_from_islands(
@@ -646,15 +676,11 @@ def seams_from_islands(
     *,
     mark_seams: bool | None = True,
     mark_sharp: bool | None = False,
-):
+) -> None:
     """Set mesh seams according to island setup in the UV editor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param mark_seams: Mark Seams, Mark boundary edges as seams
-    :type mark_seams: bool | None
     :param mark_sharp: Mark Sharp, Mark boundary edges as sharp
-    :type mark_sharp: bool | None
     """
 
 def select(
@@ -668,23 +694,15 @@ def select(
     deselect_all: bool | None = False,
     select_passthrough: bool | None = False,
     location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
-):
+) -> None:
     """Select UV vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend selection instead of deselecting everything first
-    :type extend: bool | None
     :param deselect: Deselect, Remove from selection
-    :type deselect: bool | None
     :param toggle: Toggle Selection, Toggle the selection
-    :type toggle: bool | None
     :param deselect_all: Deselect On Nothing, Deselect all when nothing under the cursor
-    :type deselect_all: bool | None
     :param select_passthrough: Only Select Unselected, Ignore the select action when the element is already selected
-    :type select_passthrough: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
 def select_all(
@@ -693,11 +711,9 @@ def select_all(
     /,
     *,
     action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"] | None = "TOGGLE",
-):
+) -> None:
     """Change selection of all UV vertices
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Action, Selection action to execute
 
     TOGGLE
@@ -711,7 +727,6 @@ def select_all(
 
     INVERT
     Invert -- Invert selection of all elements.
-        :type action: typing.Literal['TOGGLE','SELECT','DESELECT','INVERT'] | None
     """
 
 def select_box(
@@ -726,23 +741,15 @@ def select_box(
     ymax: int | None = 0,
     wait_for_input: bool | None = True,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
-):
+) -> None:
     """Select UV vertices using box selection
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param pinned: Pinned, Border select pinned UVs only
-        :type pinned: bool | None
         :param xmin: X Min
-        :type xmin: int | None
         :param xmax: X Max
-        :type xmax: int | None
         :param ymin: Y Min
-        :type ymin: int | None
         :param ymax: Y Max
-        :type ymax: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -753,7 +760,6 @@ def select_box(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
     """
 
 def select_circle(
@@ -766,19 +772,13 @@ def select_circle(
     radius: int | None = 25,
     wait_for_input: bool | None = True,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
-):
+) -> None:
     """Select UV vertices using circle selection
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param x: X
-        :type x: int | None
         :param y: Y
-        :type y: int | None
         :param radius: Radius
-        :type radius: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -789,7 +789,6 @@ def select_circle(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
     """
 
 def select_edge_ring(
@@ -799,15 +798,11 @@ def select_edge_ring(
     *,
     extend: bool | None = False,
     location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
-):
+) -> None:
     """Select an edge ring of connected UV vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
 def select_lasso(
@@ -820,19 +815,13 @@ def select_lasso(
     smooth_stroke_factor: float | None = 0.75,
     smooth_stroke_radius: int | None = 35,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
-):
+) -> None:
     """Select UVs using lasso selection
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param path: Path
-        :type path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None
         :param use_smooth_stroke: Stabilize Stroke, Selection lags behind mouse and follows a smoother path
-        :type use_smooth_stroke: bool | None
         :param smooth_stroke_factor: Smooth Stroke Factor, Higher values gives a smoother stroke
-        :type smooth_stroke_factor: float | None
         :param smooth_stroke_radius: Smooth Stroke Radius, Minimum distance from last point before selection continues
-        :type smooth_stroke_radius: int | None
         :param mode: Mode
 
     SET
@@ -843,22 +832,21 @@ def select_lasso(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
-    """
-
-def select_less(execution_context: int | str | None = None, undo: bool | None = None):
-    """Deselect UV vertices at the boundary of each selection region
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
     """
 
-def select_linked(execution_context: int | str | None = None, undo: bool | None = None):
-    """Select all UV vertices linked to the active UV map
+def select_less(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Deselect UV vertices at the boundary of each selection region"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def select_linked(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select all UV vertices linked to the active UV map"""
 
 def select_linked_pick(
     execution_context: int | str | None = None,
@@ -868,17 +856,12 @@ def select_linked_pick(
     extend: bool | None = False,
     deselect: bool | None = False,
     location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
-):
+) -> None:
     """Select all UV vertices linked under the mouse
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | None
     :param deselect: Deselect, Deselect linked UV vertices rather than selecting them
-    :type deselect: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
 def select_loop(
@@ -888,15 +871,11 @@ def select_loop(
     *,
     extend: bool | None = False,
     location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
-):
+) -> None:
     """Select a loop of connected UV vertices
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
 def select_mode(
@@ -904,22 +883,19 @@ def select_mode(
     undo: bool | None = None,
     /,
     *,
-    type: bpy._typing.rna_enums.MeshSelectModeUvItems | None = "VERTEX",
-):
+    type: bpy.stub_internal.rna_enums.MeshSelectModeUvItems | None = "VERTEX",
+) -> None:
     """Change UV selection mode
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Type
-    :type type: bpy._typing.rna_enums.MeshSelectModeUvItems | None
     """
 
-def select_more(execution_context: int | str | None = None, undo: bool | None = None):
-    """Select more UV vertices connected to initial selection
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def select_more(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select more UV vertices connected to initial selection"""
 
 def select_overlap(
     execution_context: int | str | None = None,
@@ -927,21 +903,18 @@ def select_overlap(
     /,
     *,
     extend: bool | None = False,
-):
+) -> None:
     """Select all UV faces which overlap each other
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | None
     """
 
-def select_pinned(execution_context: int | str | None = None, undo: bool | None = None):
-    """Select all pinned UV vertices
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def select_pinned(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select all pinned UV vertices"""
 
 def select_similar(
     execution_context: int | str | None = None,
@@ -963,24 +936,63 @@ def select_similar(
     | None = "PIN",
     compare: typing.Literal["EQUAL", "GREATER", "LESS"] | None = "EQUAL",
     threshold: float | None = 0.0,
-):
+) -> None:
     """Select similar UVs by property types
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param type: Type
-    :type type: typing.Literal['PIN','LENGTH','LENGTH_3D','AREA','AREA_3D','MATERIAL','OBJECT','SIDES','WINDING','FACE'] | None
-    :param compare: Compare
-    :type compare: typing.Literal['EQUAL','GREATER','LESS'] | None
-    :param threshold: Threshold
-    :type threshold: float | None
+        :param type: Type
+
+    PIN
+    Pinned.
+
+    LENGTH
+    Length -- Edge length in UV space.
+
+    LENGTH_3D
+    Length 3D -- Length of edge in 3D space.
+
+    AREA
+    Area -- Face area in UV space.
+
+    AREA_3D
+    Area 3D -- Area of face in 3D space.
+
+    MATERIAL
+    Material.
+
+    OBJECT
+    Object.
+
+    SIDES
+    Polygon Sides.
+
+    WINDING
+    Winding -- Face direction defined by (clockwise or anti-clockwise winding (facing up or facing down).
+
+    FACE
+    Amount of Faces in Island.
+        :param compare: Compare
+        :param threshold: Threshold
     """
 
-def select_split(execution_context: int | str | None = None, undo: bool | None = None):
-    """Select only entirely selected faces
+def select_split(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select only entirely selected faces"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+def select_tile(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    extend: bool | None = False,
+    tile: collections.abc.Iterable[int] | None = (0, 0),
+) -> None:
+    """Select UVs in specified tile
+
+    :param extend: Extend, Extend the selection
+    :param tile: Tile, Tile location to select UVs
     """
 
 def shortest_path_pick(
@@ -996,25 +1008,15 @@ def shortest_path_pick(
     offset: int | None = 0,
     object_index: int | None = -1,
     index: int | None = -1,
-):
+) -> None:
     """Select shortest path between two selections
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param use_face_step: Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
-    :type use_face_step: bool | None
     :param use_topology_distance: Topology Distance, Find the minimum number of steps, ignoring spatial distance
-    :type use_topology_distance: bool | None
     :param use_fill: Fill Region, Select all paths between the source/destination elements
-    :type use_fill: bool | None
     :param skip: Deselected, Number of deselected elements in the repetitive sequence
-    :type skip: int | None
     :param nth: Selected, Number of selected elements in the repetitive sequence
-    :type nth: int | None
     :param offset: Offset, Offset from the starting point
-    :type offset: int | None
-    :type object_index: int | None
-    :type index: int | None
     """
 
 def shortest_path_select(
@@ -1028,23 +1030,15 @@ def shortest_path_select(
     skip: int | None = 0,
     nth: int | None = 1,
     offset: int | None = 0,
-):
+) -> None:
     """Selected shortest path between two vertices/edges/faces
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param use_face_step: Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
-    :type use_face_step: bool | None
     :param use_topology_distance: Topology Distance, Find the minimum number of steps, ignoring spatial distance
-    :type use_topology_distance: bool | None
     :param use_fill: Fill Region, Select all paths between the source/destination elements
-    :type use_fill: bool | None
     :param skip: Deselected, Number of deselected elements in the repetitive sequence
-    :type skip: int | None
     :param nth: Selected, Number of selected elements in the repetitive sequence
-    :type nth: int | None
     :param offset: Offset, Offset from the starting point
-    :type offset: int | None
     """
 
 def smart_project(
@@ -1060,13 +1054,10 @@ def smart_project(
     area_weight: float | None = 0.0,
     correct_aspect: bool | None = True,
     scale_to_bounds: bool | None = False,
-):
+) -> None:
     """Projection unwraps the selected faces of mesh objects
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param angle_limit: Angle Limit, Lower for more projection groups, higher for less distortion
-        :type angle_limit: float | None
         :param margin_method: Margin Method
 
     SCALED
@@ -1077,7 +1068,6 @@ def smart_project(
 
     FRACTION
     Fraction -- Specify a precise fraction of final UV output.
-        :type margin_method: typing.Literal['SCALED','ADD','FRACTION'] | None
         :param rotate_method: Rotation Method
 
     AXIS_ALIGNED
@@ -1088,15 +1078,10 @@ def smart_project(
 
     AXIS_ALIGNED_Y
     Axis-aligned (Vertical) -- Rotate islands to be aligned vertically.
-        :type rotate_method: typing.Literal['AXIS_ALIGNED','AXIS_ALIGNED_X','AXIS_ALIGNED_Y'] | None
         :param island_margin: Island Margin, Margin to reduce bleed from adjacent islands
-        :type island_margin: float | None
-        :param area_weight: Area Weight, Weight projection's vector by faces with larger areas
-        :type area_weight: float | None
+        :param area_weight: Area Weight, Weight projections vector by faces with larger areas
         :param correct_aspect: Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
-        :type correct_aspect: bool | None
         :param scale_to_bounds: Scale to Bounds, Scale UV coordinates to bounds after unwrapping
-        :type scale_to_bounds: bool | None
     """
 
 def snap_cursor(
@@ -1105,13 +1090,10 @@ def snap_cursor(
     /,
     *,
     target: typing.Literal["PIXELS", "SELECTED", "ORIGIN"] | None = "PIXELS",
-):
+) -> None:
     """Snap cursor to target type
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param target: Target, Target to snap the selected UVs to
-    :type target: typing.Literal['PIXELS','SELECTED','ORIGIN'] | None
     """
 
 def snap_selected(
@@ -1121,13 +1103,10 @@ def snap_selected(
     *,
     target: typing.Literal["PIXELS", "CURSOR", "CURSOR_OFFSET", "ADJACENT_UNSELECTED"]
     | None = "PIXELS",
-):
+) -> None:
     """Snap selected UV vertices to target type
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param target: Target, Target to snap the selected UVs to
-    :type target: typing.Literal['PIXELS','CURSOR','CURSOR_OFFSET','ADJACENT_UNSELECTED'] | None
     """
 
 def sphere_project(
@@ -1143,11 +1122,9 @@ def sphere_project(
     correct_aspect: bool | None = True,
     clip_to_bounds: bool | None = False,
     scale_to_bounds: bool | None = False,
-):
+) -> None:
     """Project the UV vertices of the mesh over the curved surface of a sphere
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param direction: Direction, Direction of the sphere or cylinder
 
     VIEW_ON_EQUATOR
@@ -1158,7 +1135,6 @@ def sphere_project(
 
     ALIGN_TO_OBJECT
     Align to Object -- Align according to object transform.
-        :type direction: typing.Literal['VIEW_ON_EQUATOR','VIEW_ON_POLES','ALIGN_TO_OBJECT'] | None
         :param align: Align, How to determine rotation around the pole
 
     POLAR_ZX
@@ -1166,7 +1142,6 @@ def sphere_project(
 
     POLAR_ZY
     Polar ZY -- Polar 0 is Y.
-        :type align: typing.Literal['POLAR_ZX','POLAR_ZY'] | None
         :param pole: Pole, How to handle faces at the poles
 
     PINCH
@@ -1174,15 +1149,10 @@ def sphere_project(
 
     FAN
     Fan -- UVs are fanned at the poles.
-        :type pole: typing.Literal['PINCH','FAN'] | None
         :param seam: Preserve Seams, Separate projections by islands isolated by seams
-        :type seam: bool | None
         :param correct_aspect: Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
-        :type correct_aspect: bool | None
         :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-        :type clip_to_bounds: bool | None
         :param scale_to_bounds: Scale to Bounds, Scale UV coordinates to bounds after unwrapping
-        :type scale_to_bounds: bool | None
     """
 
 def stitch(
@@ -1201,33 +1171,20 @@ def stitch(
     stored_mode: typing.Literal["VERTEX", "EDGE"] | None = "VERTEX",
     selection: bpy.types.bpy_prop_collection[bpy.types.SelectedUvElement] | None = None,
     objects_selection_count: collections.abc.Iterable[int] | None = (0, 0, 0, 0, 0, 0),
-):
+) -> None:
     """Stitch selected UV vertices by proximity
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param use_limit: Use Limit, Stitch UVs within a specified limit distance
-    :type use_limit: bool | None
     :param snap_islands: Snap Islands, Snap islands together (on edge stitch mode, rotates the islands too)
-    :type snap_islands: bool | None
     :param limit: Limit, Limit distance in normalized coordinates
-    :type limit: float | None
     :param static_island: Static Island, Island that stays in place when stitching islands
-    :type static_island: int | None
     :param active_object_index: Active Object, Index of the active object
-    :type active_object_index: int | None
     :param midpoint_snap: Snap at Midpoint, UVs are stitched at midpoint instead of at static island
-    :type midpoint_snap: bool | None
     :param clear_seams: Clear Seams, Clear seams of stitched edges
-    :type clear_seams: bool | None
     :param mode: Operation Mode, Use vertex or edge stitching
-    :type mode: typing.Literal['VERTEX','EDGE'] | None
     :param stored_mode: Stored Operation Mode, Use vertex or edge stitching
-    :type stored_mode: typing.Literal['VERTEX','EDGE'] | None
     :param selection: Selection
-    :type selection: bpy.types.bpy_prop_collection[bpy.types.SelectedUvElement] | None
     :param objects_selection_count: Objects Selection Count
-    :type objects_selection_count: collections.abc.Iterable[int] | None
     """
 
 def unwrap(
@@ -1247,19 +1204,13 @@ def unwrap(
     use_weights: bool | None = False,
     weight_group: str = "uv_importance",
     weight_factor: float | None = 1.0,
-):
+) -> None:
     """Unwrap the mesh of the object being edited
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param method: Method, Unwrapping method (Angle Based usually gives better results than Conformal, while being somewhat slower)
-        :type method: typing.Literal['ANGLE_BASED','CONFORMAL','MINIMUM_STRETCH'] | None
         :param fill_holes: Fill Holes, Virtually fill holes in mesh before unwrapping, to better avoid overlaps and preserve symmetry
-        :type fill_holes: bool | None
         :param correct_aspect: Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
-        :type correct_aspect: bool | None
         :param use_subsurf_data: Use Subdivision Surface, Map UVs taking vertex position after Subdivision Surface modifier has been applied
-        :type use_subsurf_data: bool | None
         :param margin_method: Margin Method
 
     SCALED
@@ -1270,24 +1221,17 @@ def unwrap(
 
     FRACTION
     Fraction -- Specify a precise fraction of final UV output.
-        :type margin_method: typing.Literal['SCALED','ADD','FRACTION'] | None
         :param margin: Margin, Space between islands
-        :type margin: float | None
-        :param no_flip: No Flip, Prevent flipping UV's, flipping may lower distortion depending on the position of pins
-        :type no_flip: bool | None
+        :param no_flip: No Flip, Prevent flipping UVs, flipping may lower distortion depending on the position of pins
         :param iterations: Iterations, Number of iterations when "Minimum Stretch" method is used
-        :type iterations: int | None
         :param use_weights: Importance Weights, Whether to take into account per-vertex importance weights
-        :type use_weights: bool | None
         :param weight_group: Weight Group, Vertex group name for importance weights (modulating the deform)
-        :type weight_group: str
         :param weight_factor: Weight Factor, How much influence the weightmap has for weighted parameterization, 0 being no influence
-        :type weight_factor: float | None
     """
 
-def weld(execution_context: int | str | None = None, undo: bool | None = None):
-    """Weld selected UV vertices together
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def weld(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Weld selected UV vertices together"""