fake-bpy-module 20240620__py3-none-any.whl → 20240622__py3-none-any.whl

bpy/ops/uv/__init__.pyi

@@ -2,6 +2,7 @@ import typing
 import collections.abc
 import bpy.ops.transform
 import bpy.types
+import mathutils
 
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
@@ -49,7 +50,7 @@ def align_rotation(
     *,
     method: str | None = "AUTO",
     axis: str | None = "X",
-    correct_aspect: bool | typing.Any | None = False,
+    correct_aspect: bool | None = False,
 ):
     """Align the UV island's rotation
 
@@ -79,7 +80,7 @@ def align_rotation(
     Z -- Z axis.
         :type axis: str | None
         :param correct_aspect: Correct Aspect, Take image aspect ratio into account
-        :type correct_aspect: bool | typing.Any | None
+        :type correct_aspect: bool | None
     """
 
     ...
@@ -89,8 +90,8 @@ def average_islands_scale(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    scale_uv: bool | typing.Any | None = False,
-    shear: bool | typing.Any | None = False,
+    scale_uv: bool | None = False,
+    shear: bool | None = False,
 ):
     """Average the size of separate UV islands, based on their area in 3D space
 
@@ -98,9 +99,9 @@ def average_islands_scale(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param scale_uv: Non-Uniform, Scale U and V independently
-    :type scale_uv: bool | typing.Any | None
+    :type scale_uv: bool | None
     :param shear: Shear, Reduce shear within islands
-    :type shear: bool | typing.Any | None
+    :type shear: bool | None
     """
 
     ...
@@ -124,10 +125,10 @@ def cube_project(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    cube_size: typing.Any | None = 1.0,
-    correct_aspect: bool | typing.Any | None = True,
-    clip_to_bounds: bool | typing.Any | None = False,
-    scale_to_bounds: bool | typing.Any | None = False,
+    cube_size: float | None = 1.0,
+    correct_aspect: bool | None = True,
+    clip_to_bounds: bool | None = False,
+    scale_to_bounds: bool | None = False,
 ):
     """Project the UV vertices of the mesh over the six faces of a cube
 
@@ -135,13 +136,13 @@ def cube_project(
     :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: typing.Any | None
+    :type cube_size: float | None
     :param correct_aspect: Correct Aspect, Map UVs taking image aspect ratio into account
-    :type correct_aspect: bool | typing.Any | None
+    :type correct_aspect: bool | None
     :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-    :type clip_to_bounds: bool | typing.Any | None
+    :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 | typing.Any | None
+    :type scale_to_bounds: bool | None
     """
 
     ...
@@ -151,7 +152,7 @@ def cursor_set(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    location: typing.Any | None = (0.0, 0.0),
+    location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
 ):
     """Set 2D cursor location
 
@@ -159,7 +160,7 @@ def cursor_set(
     :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: typing.Any | None
+    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
     ...
@@ -172,11 +173,11 @@ def cylinder_project(
     direction: str | None = "VIEW_ON_EQUATOR",
     align: str | None = "POLAR_ZX",
     pole: str | None = "PINCH",
-    seam: bool | typing.Any | None = False,
-    radius: typing.Any | None = 1.0,
-    correct_aspect: bool | typing.Any | None = True,
-    clip_to_bounds: bool | typing.Any | None = False,
-    scale_to_bounds: bool | typing.Any | None = False,
+    seam: bool | None = False,
+    radius: float | None = 1.0,
+    correct_aspect: bool | None = True,
+    clip_to_bounds: bool | None = False,
+    scale_to_bounds: bool | None = False,
 ):
     """Project the UV vertices of the mesh over the curved wall of a cylinder
 
@@ -211,15 +212,15 @@ def cylinder_project(
     Fan -- UVs are fanned at the poles.
         :type pole: str | None
         :param seam: Preserve Seams, Separate projections by islands isolated by seams
-        :type seam: bool | typing.Any | None
+        :type seam: bool | None
         :param radius: Radius, Radius of the sphere or cylinder
-        :type radius: typing.Any | None
+        :type radius: float | None
         :param correct_aspect: Correct Aspect, Map UVs taking image aspect ratio into account
-        :type correct_aspect: bool | typing.Any | None
+        :type correct_aspect: bool | None
         :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-        :type clip_to_bounds: bool | typing.Any | None
+        :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 | typing.Any | None
+        :type scale_to_bounds: bool | None
     """
 
     ...
@@ -229,14 +230,14 @@ def export_layout(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    filepath: str | typing.Any = "",
-    export_all: bool | typing.Any | None = False,
+    filepath: str = "",
+    export_all: bool | None = False,
     export_tiles: str | None = "NONE",
-    modified: bool | typing.Any | None = False,
+    modified: bool | None = False,
     mode: str | None = "PNG",
-    size: typing.Any | None = (1024, 1024),
-    opacity: typing.Any | None = 0.25,
-    check_existing: bool | typing.Any | None = True,
+    size: collections.abc.Iterable[int] | None = (1024, 1024),
+    opacity: float | None = 0.25,
+    check_existing: bool | None = True,
 ):
     """Export UV layout to file
 
@@ -244,9 +245,9 @@ def export_layout(
         :type execution_context: int | str | None
         :type undo: bool | None
         :param filepath: filepath
-        :type filepath: str | typing.Any
+        :type filepath: str
         :param export_all: All UVs, Export all UVs in this mesh (not just visible ones)
-        :type export_all: bool | typing.Any | None
+        :type export_all: bool | None
         :param export_tiles: Export Tiles, Choose whether to export only the [0, 1] range, or all UV tiles
 
     NONE
@@ -259,7 +260,7 @@ def export_layout(
     UVTILE -- Export tiles in the UVTILE numbering scheme: u(u_tile + 1)_v(v_tile + 1).
         :type export_tiles: str | None
         :param modified: Modified, Exports UVs from the modified mesh
-        :type modified: bool | typing.Any | None
+        :type modified: bool | None
         :param mode: Format, File format to export the UV layout to
 
     SVG
@@ -272,11 +273,11 @@ def export_layout(
     PNG Image (.png) -- Export the UV layout to a bitmap image.
         :type mode: str | None
         :param size: Size, Dimensions of the exported file
-        :type size: typing.Any | None
+        :type size: collections.abc.Iterable[int] | None
         :param opacity: Fill Opacity, Set amount of opacity for exported UV layout
-        :type opacity: typing.Any | None
+        :type opacity: float | None
         :param check_existing: check_existing
-        :type check_existing: bool | typing.Any | None
+        :type check_existing: bool | None
     """
 
     ...
@@ -313,7 +314,7 @@ def hide(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    unselected: bool | typing.Any | None = False,
+    unselected: bool | None = False,
 ):
     """Hide (un)selected UV vertices
 
@@ -321,7 +322,7 @@ def hide(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param unselected: Unselected, Hide unselected rather than selected
-    :type unselected: bool | typing.Any | None
+    :type unselected: bool | None
     """
 
     ...
@@ -332,10 +333,10 @@ def lightmap_pack(
     undo: bool | None = None,
     *,
     PREF_CONTEXT: str | None = "SEL_FACES",
-    PREF_PACK_IN_ONE: bool | typing.Any | None = True,
-    PREF_NEW_UVLAYER: bool | typing.Any | None = False,
-    PREF_BOX_DIV: typing.Any | None = 12,
-    PREF_MARGIN_DIV: typing.Any | None = 0.1,
+    PREF_PACK_IN_ONE: bool | None = True,
+    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
 
@@ -351,13 +352,13 @@ def lightmap_pack(
     All Faces -- Average space UVs edge length of each loop.
         :type PREF_CONTEXT: str | 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 | typing.Any | None
+        :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 | typing.Any | None
+        :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: typing.Any | None
+        :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: typing.Any | None
+        :type PREF_MARGIN_DIV: float | None
     """
 
     ...
@@ -367,7 +368,7 @@ def mark_seam(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    clear: bool | typing.Any | None = False,
+    clear: bool | None = False,
 ):
     """Mark selected UV edges as seams
 
@@ -375,7 +376,7 @@ def mark_seam(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param clear: Clear Seams, Clear instead of marking seams
-    :type clear: bool | typing.Any | None
+    :type clear: bool | None
     """
 
     ...
@@ -385,9 +386,9 @@ def minimize_stretch(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    fill_holes: bool | typing.Any | None = True,
-    blend: typing.Any | None = 0.0,
-    iterations: typing.Any | None = 0,
+    fill_holes: bool | None = True,
+    blend: float | None = 0.0,
+    iterations: int | None = 0,
 ):
     """Reduce UV stretching by relaxing angles
 
@@ -395,11 +396,11 @@ def minimize_stretch(
     :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 | typing.Any | None
+    :type fill_holes: bool | None
     :param blend: Blend, Blend factor between stretch minimized and original
-    :type blend: typing.Any | None
+    :type blend: float | None
     :param iterations: Iterations, Number of iterations to run, 0 is unlimited when run interactively
-    :type iterations: typing.Any | None
+    :type iterations: int | None
     """
 
     ...
@@ -410,13 +411,13 @@ def pack_islands(
     undo: bool | None = None,
     *,
     udim_source: str | None = "CLOSEST_UDIM",
-    rotate: bool | typing.Any | None = True,
+    rotate: bool | None = True,
     rotate_method: str | None = "ANY",
-    scale: bool | typing.Any | None = True,
-    merge_overlap: bool | typing.Any | None = False,
+    scale: bool | None = True,
+    merge_overlap: bool | None = False,
     margin_method: str | None = "SCALED",
-    margin: typing.Any | None = 0.001,
-    pin: bool | typing.Any | None = False,
+    margin: float | None = 0.001,
+    pin: bool | None = False,
     pin_method: str | None = "LOCKED",
     shape_method: str | None = "CONCAVE",
 ):
@@ -437,7 +438,7 @@ def pack_islands(
     Original bounding box -- Pack to starting bounding box of islands.
         :type udim_source: str | None
         :param rotate: Rotate, Rotate islands to improve layout
-        :type rotate: bool | typing.Any | None
+        :type rotate: bool | None
         :param rotate_method: Rotation Method
 
     ANY
@@ -456,9 +457,9 @@ def pack_islands(
     Axis-aligned (Vertical) -- Rotate islands to be aligned vertically.
         :type rotate_method: str | None
         :param scale: Scale, Scale islands to fill unit square
-        :type scale: bool | typing.Any | None
+        :type scale: bool | None
         :param merge_overlap: Merge Overlapping, Overlapping islands stick together
-        :type merge_overlap: bool | typing.Any | None
+        :type merge_overlap: bool | None
         :param margin_method: Margin Method
 
     SCALED
@@ -471,9 +472,9 @@ def pack_islands(
     Fraction -- Specify a precise fraction of final UV output.
         :type margin_method: str | None
         :param margin: Margin, Space between islands
-        :type margin: typing.Any | None
+        :type margin: float | None
         :param pin: Lock Pinned Islands, Constrain islands containing any pinned UV's
-        :type pin: bool | typing.Any | None
+        :type pin: bool | None
         :param pin_method: Pin Method
 
     SCALE
@@ -522,8 +523,8 @@ def pin(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    clear: bool | typing.Any | None = False,
-    invert: bool | typing.Any | None = False,
+    clear: bool | None = False,
+    invert: bool | None = False,
 ):
     """Set/clear selected UV vertices as anchored between multiple unwrap operations
 
@@ -531,9 +532,9 @@ def pin(
     :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 | typing.Any | None
+    :type clear: bool | None
     :param invert: Invert, Invert pinning for the selection instead of setting it
-    :type invert: bool | typing.Any | None
+    :type invert: bool | None
     """
 
     ...
@@ -543,11 +544,11 @@ def project_from_view(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    orthographic: bool | typing.Any | None = False,
-    camera_bounds: bool | typing.Any | None = True,
-    correct_aspect: bool | typing.Any | None = True,
-    clip_to_bounds: bool | typing.Any | None = False,
-    scale_to_bounds: bool | typing.Any | None = False,
+    orthographic: bool | None = False,
+    camera_bounds: bool | None = True,
+    correct_aspect: bool | None = True,
+    clip_to_bounds: bool | None = False,
+    scale_to_bounds: bool | None = False,
 ):
     """Project the UV vertices of the mesh as seen in current 3D view
 
@@ -555,15 +556,15 @@ def project_from_view(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param orthographic: Orthographic, Use orthographic projection
-    :type orthographic: bool | typing.Any | None
+    :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 | typing.Any | None
+    :type camera_bounds: bool | None
     :param correct_aspect: Correct Aspect, Map UVs taking image aspect ratio into account
-    :type correct_aspect: bool | typing.Any | None
+    :type correct_aspect: bool | None
     :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-    :type clip_to_bounds: bool | typing.Any | None
+    :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 | typing.Any | None
+    :type scale_to_bounds: bool | None
     """
 
     ...
@@ -573,14 +574,14 @@ def randomize_uv_transform(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    random_seed: typing.Any | None = 0,
-    use_loc: bool | typing.Any | None = True,
-    loc: typing.Any | None = (0.0, 0.0),
-    use_rot: bool | typing.Any | None = True,
-    rot: typing.Any | None = 0.0,
-    use_scale: bool | typing.Any | None = True,
-    scale_even: bool | typing.Any | None = False,
-    scale: typing.Any | None = (1.0, 1.0),
+    random_seed: int | None = 0,
+    use_loc: bool | None = True,
+    loc: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
+    use_rot: bool | None = True,
+    rot: float | None = 0.0,
+    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
 
@@ -588,21 +589,21 @@ def randomize_uv_transform(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param random_seed: Random Seed, Seed value for the random generator
-    :type random_seed: typing.Any | None
+    :type random_seed: int | None
     :param use_loc: Randomize Location, Randomize the location values
-    :type use_loc: bool | typing.Any | None
+    :type use_loc: bool | None
     :param loc: Location, Maximum distance the objects can spread over each axis
-    :type loc: typing.Any | None
+    :type loc: collections.abc.Sequence[float] | mathutils.Vector | None
     :param use_rot: Randomize Rotation, Randomize the rotation value
-    :type use_rot: bool | typing.Any | None
+    :type use_rot: bool | None
     :param rot: Rotation, Maximum rotation
-    :type rot: typing.Any | None
+    :type rot: float | None
     :param use_scale: Randomize Scale, Randomize the scale values
-    :type use_scale: bool | typing.Any | None
+    :type use_scale: bool | None
     :param scale_even: Scale Even, Use the same scale value for both axes
-    :type scale_even: bool | typing.Any | None
+    :type scale_even: bool | None
     :param scale: Scale, Maximum scale randomization over each axis
-    :type scale: typing.Any | None
+    :type scale: collections.abc.Iterable[float] | None
     """
 
     ...
@@ -612,8 +613,8 @@ def remove_doubles(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    threshold: typing.Any | None = 0.02,
-    use_unselected: bool | typing.Any | None = False,
+    threshold: float | None = 0.02,
+    use_unselected: bool | None = False,
 ):
     """Selected UV vertices that are within a radius of each other are welded together
 
@@ -621,9 +622,9 @@ def remove_doubles(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param threshold: Merge Distance, Maximum distance between welded vertices
-    :type threshold: typing.Any | None
+    :type threshold: float | None
     :param use_unselected: Unselected, Merge selected to other unselected vertices
-    :type use_unselected: bool | typing.Any | None
+    :type use_unselected: bool | None
     """
 
     ...
@@ -647,7 +648,7 @@ def reveal(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    select: bool | typing.Any | None = True,
+    select: bool | None = True,
 ):
     """Reveal all hidden UV vertices
 
@@ -655,7 +656,7 @@ def reveal(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param select: Select
-    :type select: bool | typing.Any | None
+    :type select: bool | None
     """
 
     ...
@@ -665,10 +666,10 @@ def rip(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    mirror: bool | typing.Any | None = False,
-    release_confirm: bool | typing.Any | None = False,
-    use_accurate: bool | typing.Any | None = False,
-    location: typing.Any | None = (0.0, 0.0),
+    mirror: bool | None = False,
+    release_confirm: bool | None = False,
+    use_accurate: bool | None = False,
+    location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
 ):
     """Rip selected vertices or a selected region
 
@@ -676,13 +677,13 @@ def rip(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mirror: Mirror Editing
-    :type mirror: bool | typing.Any | None
+    :type mirror: bool | None
     :param release_confirm: Confirm on Release, Always confirm operation when releasing button
-    :type release_confirm: bool | typing.Any | None
+    :type release_confirm: bool | None
     :param use_accurate: Accurate, Use accurate transformation
-    :type use_accurate: bool | typing.Any | None
+    :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: typing.Any | None
+    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
     ...
@@ -713,8 +714,8 @@ def seams_from_islands(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    mark_seams: bool | typing.Any | None = True,
-    mark_sharp: bool | typing.Any | None = False,
+    mark_seams: bool | None = True,
+    mark_sharp: bool | None = False,
 ):
     """Set mesh seams according to island setup in the UV editor
 
@@ -722,9 +723,9 @@ def seams_from_islands(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param mark_seams: Mark Seams, Mark boundary edges as seams
-    :type mark_seams: bool | typing.Any | None
+    :type mark_seams: bool | None
     :param mark_sharp: Mark Sharp, Mark boundary edges as sharp
-    :type mark_sharp: bool | typing.Any | None
+    :type mark_sharp: bool | None
     """
 
     ...
@@ -734,12 +735,12 @@ def select(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    extend: bool | typing.Any | None = False,
-    deselect: bool | typing.Any | None = False,
-    toggle: bool | typing.Any | None = False,
-    deselect_all: bool | typing.Any | None = False,
-    select_passthrough: bool | typing.Any | None = False,
-    location: typing.Any | None = (0.0, 0.0),
+    extend: bool | None = False,
+    deselect: bool | None = False,
+    toggle: bool | None = False,
+    deselect_all: bool | None = False,
+    select_passthrough: bool | None = False,
+    location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
 ):
     """Select UV vertices
 
@@ -747,17 +748,17 @@ def select(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param extend: Extend, Extend selection instead of deselecting everything first
-    :type extend: bool | typing.Any | None
+    :type extend: bool | None
     :param deselect: Deselect, Remove from selection
-    :type deselect: bool | typing.Any | None
+    :type deselect: bool | None
     :param toggle: Toggle Selection, Toggle the selection
-    :type toggle: bool | typing.Any | None
+    :type toggle: bool | None
     :param deselect_all: Deselect On Nothing, Deselect all when nothing under the cursor
-    :type deselect_all: bool | typing.Any | None
+    :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 | typing.Any | None
+    :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: typing.Any | None
+    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
     ...
@@ -797,12 +798,12 @@ def select_box(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    pinned: bool | typing.Any | None = False,
-    xmin: typing.Any | None = 0,
-    xmax: typing.Any | None = 0,
-    ymin: typing.Any | None = 0,
-    ymax: typing.Any | None = 0,
-    wait_for_input: bool | typing.Any | None = True,
+    pinned: bool | None = False,
+    xmin: int | None = 0,
+    xmax: int | None = 0,
+    ymin: int | None = 0,
+    ymax: int | None = 0,
+    wait_for_input: bool | None = True,
     mode: str | None = "SET",
 ):
     """Select UV vertices using box selection
@@ -811,17 +812,17 @@ def select_box(
         :type execution_context: int | str | None
         :type undo: bool | None
         :param pinned: Pinned, Border select pinned UVs only
-        :type pinned: bool | typing.Any | None
+        :type pinned: bool | None
         :param xmin: X Min
-        :type xmin: typing.Any | None
+        :type xmin: int | None
         :param xmax: X Max
-        :type xmax: typing.Any | None
+        :type xmax: int | None
         :param ymin: Y Min
-        :type ymin: typing.Any | None
+        :type ymin: int | None
         :param ymax: Y Max
-        :type ymax: typing.Any | None
+        :type ymax: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | typing.Any | None
+        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -842,10 +843,10 @@ def select_circle(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    x: typing.Any | None = 0,
-    y: typing.Any | None = 0,
-    radius: typing.Any | None = 25,
-    wait_for_input: bool | typing.Any | None = True,
+    x: int | None = 0,
+    y: int | None = 0,
+    radius: int | None = 25,
+    wait_for_input: bool | None = True,
     mode: str | None = "SET",
 ):
     """Select UV vertices using circle selection
@@ -854,13 +855,13 @@ def select_circle(
         :type execution_context: int | str | None
         :type undo: bool | None
         :param x: X
-        :type x: typing.Any | None
+        :type x: int | None
         :param y: Y
-        :type y: typing.Any | None
+        :type y: int | None
         :param radius: Radius
-        :type radius: typing.Any | None
+        :type radius: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | typing.Any | None
+        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -881,8 +882,8 @@ def select_edge_ring(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    extend: bool | typing.Any | None = False,
-    location: typing.Any | None = (0.0, 0.0),
+    extend: bool | None = False,
+    location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
 ):
     """Select an edge ring of connected UV vertices
 
@@ -890,9 +891,9 @@ def select_edge_ring(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | typing.Any | None
+    :type extend: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: typing.Any | None
+    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
     ...
@@ -960,9 +961,9 @@ def select_linked_pick(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    extend: bool | typing.Any | None = False,
-    deselect: bool | typing.Any | None = False,
-    location: typing.Any | None = (0.0, 0.0),
+    extend: bool | None = False,
+    deselect: bool | None = False,
+    location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
 ):
     """Select all UV vertices linked under the mouse
 
@@ -970,11 +971,11 @@ def select_linked_pick(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | typing.Any | None
+    :type extend: bool | None
     :param deselect: Deselect, Deselect linked UV vertices rather than selecting them
-    :type deselect: bool | typing.Any | None
+    :type deselect: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: typing.Any | None
+    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
     ...
@@ -984,8 +985,8 @@ def select_loop(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    extend: bool | typing.Any | None = False,
-    location: typing.Any | None = (0.0, 0.0),
+    extend: bool | None = False,
+    location: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0),
 ):
     """Select a loop of connected UV vertices
 
@@ -993,9 +994,9 @@ def select_loop(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | typing.Any | None
+    :type extend: bool | None
     :param location: Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds
-    :type location: typing.Any | None
+    :type location: collections.abc.Sequence[float] | mathutils.Vector | None
     """
 
     ...
@@ -1037,7 +1038,7 @@ def select_overlap(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    extend: bool | typing.Any | None = False,
+    extend: bool | None = False,
 ):
     """Select all UV faces which overlap each other
 
@@ -1045,7 +1046,7 @@ def select_overlap(
     :type execution_context: int | str | None
     :type undo: bool | None
     :param extend: Extend, Extend selection rather than clearing the existing selection
-    :type extend: bool | typing.Any | None
+    :type extend: bool | None
     """
 
     ...
@@ -1071,7 +1072,7 @@ def select_similar(
     *,
     type: str | None = "PIN",
     compare: str | None = "EQUAL",
-    threshold: typing.Any | None = 0.0,
+    threshold: float | None = 0.0,
 ):
     """Select similar UVs by property types
 
@@ -1083,7 +1084,7 @@ def select_similar(
     :param compare: Compare
     :type compare: str | None
     :param threshold: Threshold
-    :type threshold: typing.Any | None
+    :type threshold: float | None
     """
 
     ...
@@ -1107,14 +1108,14 @@ def shortest_path_pick(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    use_face_step: bool | typing.Any | None = False,
-    use_topology_distance: bool | typing.Any | None = False,
-    use_fill: bool | typing.Any | None = False,
-    skip: typing.Any | None = 0,
-    nth: typing.Any | None = 1,
-    offset: typing.Any | None = 0,
-    object_index: typing.Any | None = -1,
-    index: typing.Any | None = -1,
+    use_face_step: bool | None = False,
+    use_topology_distance: bool | None = False,
+    use_fill: bool | None = False,
+    skip: int | None = 0,
+    nth: int | None = 1,
+    offset: int | None = 0,
+    object_index: int | None = -1,
+    index: int | None = -1,
 ):
     """Select shortest path between two selections
 
@@ -1122,19 +1123,19 @@ def shortest_path_pick(
     :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 | typing.Any | None
+    :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 | typing.Any | None
+    :type use_topology_distance: bool | None
     :param use_fill: Fill Region, Select all paths between the source/destination elements
-    :type use_fill: bool | typing.Any | None
+    :type use_fill: bool | None
     :param skip: Deselected, Number of deselected elements in the repetitive sequence
-    :type skip: typing.Any | None
+    :type skip: int | None
     :param nth: Selected, Number of selected elements in the repetitive sequence
-    :type nth: typing.Any | None
+    :type nth: int | None
     :param offset: Offset, Offset from the starting point
-    :type offset: typing.Any | None
-    :type object_index: typing.Any | None
-    :type index: typing.Any | None
+    :type offset: int | None
+    :type object_index: int | None
+    :type index: int | None
     """
 
     ...
@@ -1144,12 +1145,12 @@ def shortest_path_select(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    use_face_step: bool | typing.Any | None = False,
-    use_topology_distance: bool | typing.Any | None = False,
-    use_fill: bool | typing.Any | None = False,
-    skip: typing.Any | None = 0,
-    nth: typing.Any | None = 1,
-    offset: typing.Any | None = 0,
+    use_face_step: bool | None = False,
+    use_topology_distance: bool | None = False,
+    use_fill: bool | None = False,
+    skip: int | None = 0,
+    nth: int | None = 1,
+    offset: int | None = 0,
 ):
     """Selected shortest path between two vertices/edges/faces
 
@@ -1157,17 +1158,17 @@ def shortest_path_select(
     :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 | typing.Any | None
+    :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 | typing.Any | None
+    :type use_topology_distance: bool | None
     :param use_fill: Fill Region, Select all paths between the source/destination elements
-    :type use_fill: bool | typing.Any | None
+    :type use_fill: bool | None
     :param skip: Deselected, Number of deselected elements in the repetitive sequence
-    :type skip: typing.Any | None
+    :type skip: int | None
     :param nth: Selected, Number of selected elements in the repetitive sequence
-    :type nth: typing.Any | None
+    :type nth: int | None
     :param offset: Offset, Offset from the starting point
-    :type offset: typing.Any | None
+    :type offset: int | None
     """
 
     ...
@@ -1177,13 +1178,13 @@ def smart_project(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    angle_limit: typing.Any | None = 1.15192,
+    angle_limit: float | None = 1.15192,
     margin_method: str | None = "SCALED",
     rotate_method: str | None = "AXIS_ALIGNED_Y",
-    island_margin: typing.Any | None = 0.0,
-    area_weight: typing.Any | None = 0.0,
-    correct_aspect: bool | typing.Any | None = True,
-    scale_to_bounds: bool | typing.Any | None = False,
+    island_margin: float | None = 0.0,
+    area_weight: float | None = 0.0,
+    correct_aspect: bool | None = True,
+    scale_to_bounds: bool | None = False,
 ):
     """Projection unwraps the selected faces of mesh objects
 
@@ -1191,7 +1192,7 @@ def smart_project(
         :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: typing.Any | None
+        :type angle_limit: float | None
         :param margin_method: Margin Method
 
     SCALED
@@ -1215,13 +1216,13 @@ def smart_project(
     Axis-aligned (Vertical) -- Rotate islands to be aligned vertically.
         :type rotate_method: str | None
         :param island_margin: Island Margin, Margin to reduce bleed from adjacent islands
-        :type island_margin: typing.Any | None
+        :type island_margin: float | None
         :param area_weight: Area Weight, Weight projection's vector by faces with larger areas
-        :type area_weight: typing.Any | None
+        :type area_weight: float | None
         :param correct_aspect: Correct Aspect, Map UVs taking image aspect ratio into account
-        :type correct_aspect: bool | typing.Any | None
+        :type correct_aspect: bool | None
         :param scale_to_bounds: Scale to Bounds, Scale UV coordinates to bounds after unwrapping
-        :type scale_to_bounds: bool | typing.Any | None
+        :type scale_to_bounds: bool | None
     """
 
     ...
@@ -1270,10 +1271,10 @@ def sphere_project(
     direction: str | None = "VIEW_ON_EQUATOR",
     align: str | None = "POLAR_ZX",
     pole: str | None = "PINCH",
-    seam: bool | typing.Any | None = False,
-    correct_aspect: bool | typing.Any | None = True,
-    clip_to_bounds: bool | typing.Any | None = False,
-    scale_to_bounds: bool | typing.Any | None = False,
+    seam: bool | None = False,
+    correct_aspect: bool | None = True,
+    clip_to_bounds: bool | None = False,
+    scale_to_bounds: bool | None = False,
 ):
     """Project the UV vertices of the mesh over the curved surface of a sphere
 
@@ -1308,13 +1309,13 @@ def sphere_project(
     Fan -- UVs are fanned at the poles.
         :type pole: str | None
         :param seam: Preserve Seams, Separate projections by islands isolated by seams
-        :type seam: bool | typing.Any | None
+        :type seam: bool | None
         :param correct_aspect: Correct Aspect, Map UVs taking image aspect ratio into account
-        :type correct_aspect: bool | typing.Any | None
+        :type correct_aspect: bool | None
         :param clip_to_bounds: Clip to Bounds, Clip UV coordinates to bounds after unwrapping
-        :type clip_to_bounds: bool | typing.Any | None
+        :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 | typing.Any | None
+        :type scale_to_bounds: bool | None
     """
 
     ...
@@ -1324,17 +1325,17 @@ def stitch(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     *,
-    use_limit: bool | typing.Any | None = False,
-    snap_islands: bool | typing.Any | None = True,
-    limit: typing.Any | None = 0.01,
-    static_island: typing.Any | None = 0,
-    active_object_index: typing.Any | None = 0,
-    midpoint_snap: bool | typing.Any | None = False,
-    clear_seams: bool | typing.Any | None = True,
+    use_limit: bool | None = False,
+    snap_islands: bool | None = True,
+    limit: float | None = 0.01,
+    static_island: int | None = 0,
+    active_object_index: int | None = 0,
+    midpoint_snap: bool | None = False,
+    clear_seams: bool | None = True,
     mode: str | None = "VERTEX",
     stored_mode: str | None = "VERTEX",
     selection: bpy.types.bpy_prop_collection[bpy.types.SelectedUvElement] | None = None,
-    objects_selection_count: typing.Any | None = (0, 0, 0, 0, 0, 0),
+    objects_selection_count: collections.abc.Iterable[int] | None = (0, 0, 0, 0, 0, 0),
 ):
     """Stitch selected UV vertices by proximity
 
@@ -1342,19 +1343,19 @@ def stitch(
     :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 | typing.Any | None
+    :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 | typing.Any | None
+    :type snap_islands: bool | None
     :param limit: Limit, Limit distance in normalized coordinates
-    :type limit: typing.Any | None
+    :type limit: float | None
     :param static_island: Static Island, Island that stays in place when stitching islands
-    :type static_island: typing.Any | None
+    :type static_island: int | None
     :param active_object_index: Active Object, Index of the active object
-    :type active_object_index: typing.Any | None
+    :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 | typing.Any | None
+    :type midpoint_snap: bool | None
     :param clear_seams: Clear Seams, Clear seams of stitched edges
-    :type clear_seams: bool | typing.Any | None
+    :type clear_seams: bool | None
     :param mode: Operation Mode, Use vertex or edge stitching
     :type mode: str | None
     :param stored_mode: Stored Operation Mode, Use vertex or edge stitching
@@ -1362,7 +1363,7 @@ def stitch(
     :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: typing.Any | None
+    :type objects_selection_count: collections.abc.Iterable[int] | None
     """
 
     ...
@@ -1373,11 +1374,11 @@ def unwrap(
     undo: bool | None = None,
     *,
     method: str | None = "ANGLE_BASED",
-    fill_holes: bool | typing.Any | None = True,
-    correct_aspect: bool | typing.Any | None = True,
-    use_subsurf_data: bool | typing.Any | None = False,
+    fill_holes: bool | None = True,
+    correct_aspect: bool | None = True,
+    use_subsurf_data: bool | None = False,
     margin_method: str | None = "SCALED",
-    margin: typing.Any | None = 0.001,
+    margin: float | None = 0.001,
 ):
     """Unwrap the mesh of the object being edited
 
@@ -1387,11 +1388,11 @@ def unwrap(
         :param method: Method, Unwrapping method (Angle Based usually gives better results than Conformal, while being somewhat slower)
         :type method: str | None
         :param fill_holes: Fill Holes, Virtually fill holes in mesh before unwrapping, to better avoid overlaps and preserve symmetry
-        :type fill_holes: bool | typing.Any | None
+        :type fill_holes: bool | None
         :param correct_aspect: Correct Aspect, Map UVs taking image aspect ratio into account
-        :type correct_aspect: bool | typing.Any | None
+        :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 | typing.Any | None
+        :type use_subsurf_data: bool | None
         :param margin_method: Margin Method
 
     SCALED
@@ -1404,7 +1405,7 @@ def unwrap(
     Fraction -- Specify a precise fraction of final UV output.
         :type margin_method: str | None
         :param margin: Margin, Space between islands
-        :type margin: typing.Any | None
+        :type margin: float | None
     """
 
     ...