fake-bpy-module-latest 20260113__py3-none-any.whl → 20260114__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -47,10 +47,8 @@ class BMDeformVert:
         when not found (matches Pythons dictionary function of the same name).
 
                 :param key: The key associated with deform weight.
-                :type key: int
                 :param default: Optional argument for the value to return if
         key is not found.
-                :type default: typing.Any | None
         """
 
     def items(self) -> list[tuple[int, float]]:
@@ -58,7 +56,6 @@ class BMDeformVert:
         (matching Pythons dict.items() functionality).
 
                 :return: (key, value) pairs for each deform weight of this vertex.
-                :rtype: list[tuple[int, float]]
         """
 
     def keys(self) -> list[int]:
@@ -66,7 +63,6 @@ class BMDeformVert:
         (matching Pythons dict.keys() functionality).
 
                 :return: the deform group this vertex uses
-                :rtype: list[int]
         """
 
     def values(self) -> list[float]:
@@ -74,59 +70,34 @@ class BMDeformVert:
         (matching Pythons dict.values() functionality).
 
                 :return: The weights that influence this vertex
-                :rtype: list[float]
         """
 
 class BMEdge:
     """The BMesh edge connecting 2 verts"""
 
     hide: bool
-    """ Hidden state of this element.
-
-    :type: bool
-    """
+    """ Hidden state of this element."""
 
     index: int
-    """ Index of this element.
-
-    :type: int
-    """
+    """ Index of this element."""
 
     is_boundary: bool
-    """ True when this edge is at the boundary of a face (read-only).
-
-    :type: bool
-    """
+    """ True when this edge is at the boundary of a face (read-only)."""
 
     is_contiguous: bool
-    """ True when this edge is manifold, between two faces with the same winding (read-only).
-
-    :type: bool
-    """
+    """ True when this edge is manifold, between two faces with the same winding (read-only)."""
 
     is_convex: bool
-    """ True when this edge joins two convex faces, depends on a valid face normal (read-only).
-
-    :type: bool
-    """
+    """ True when this edge joins two convex faces, depends on a valid face normal (read-only)."""
 
     is_manifold: bool
-    """ True when this edge is manifold (read-only).
-
-    :type: bool
-    """
+    """ True when this edge is manifold (read-only)."""
 
     is_valid: bool
-    """ True when this element is valid (hasn't been removed).
-
-    :type: bool
-    """
+    """ True when this element is valid (hasn't been removed)."""
 
     is_wire: bool
-    """ True when this edge is not connected to any faces (read-only).
-
-    :type: bool
-    """
+    """ True when this edge is not connected to any faces (read-only)."""
 
     link_faces: typing.Any
     """ Faces connected to this edge, (read-only)."""
@@ -135,28 +106,16 @@ class BMEdge:
     """ Loops connected to this edge, (read-only)."""
 
     seam: bool
-    """ Seam for UV unwrapping.
-
-    :type: bool
-    """
+    """ Seam for UV unwrapping."""
 
     select: bool
-    """ Selected state of this element.
-
-    :type: bool
-    """
+    """ Selected state of this element."""
 
     smooth: bool
-    """ Smooth state of this element.
-
-    :type: bool
-    """
+    """ Smooth state of this element."""
 
     tag: bool
-    """ Generic attribute scripts can use for own logic
-
-    :type: bool
-    """
+    """ Generic attribute scripts can use for own logic"""
 
     verts: typing.Any
     """ Verts this edge uses (always 2), (read-only)."""
@@ -166,9 +125,7 @@ class BMEdge:
 
                 :param fallback: return this when the edge doesnt have 2 faces
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: The angle between 2 connected faces in radians.
-                :rtype: float
         """
 
     def calc_face_angle_signed(self, fallback: typing.Any | None = None) -> float:
@@ -176,16 +133,13 @@ class BMEdge:
 
                 :param fallback: return this when the edge doesnt have 2 faces
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: The angle between 2 connected faces in radians (negative for concave join).
-                :rtype: float
         """
 
     def calc_length(self) -> float:
         """
 
         :return: The length between both verts.
-        :rtype: float
         """
 
     def calc_tangent(self, loop: BMLoop) -> mathutils.Vector:
@@ -193,16 +147,13 @@ class BMEdge:
         This uses the face normal for calculation.
 
                 :param loop: The loop used for tangent calculation.
-                :type loop: BMLoop
                 :return: a normalized vector.
-                :rtype: mathutils.Vector
         """
 
     def copy_from(self, other: typing_extensions.Self) -> None:
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: typing_extensions.Self
         """
 
     def hide_set(self, hide: bool) -> None:
@@ -210,7 +161,6 @@ class BMEdge:
         This is different from the hide attribute because it updates the selection and hide state of associated geometry.
 
                 :param hide: Hidden or visible.
-                :type hide: bool
         """
 
     def normal_update(self) -> None:
@@ -220,9 +170,7 @@ class BMEdge:
         """Return the other vertex on this edge or None if the vertex is not used by this edge.
 
         :param vert: a vert in this edge.
-        :type vert: BMVert
         :return: The edges other vert.
-        :rtype: BMVert | None
         """
 
     def select_set(self, select: bool) -> None:
@@ -230,7 +178,6 @@ class BMEdge:
         This is different from the select attribute because it updates the selection state of associated geometry.
 
                 :param select: Select or de-select.
-                :type select: bool
         """
 
     def __getitem__[_GenericType1](
@@ -239,9 +186,7 @@ class BMEdge:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :return:
-        :rtype: _GenericType1
         """
 
     def __setitem__[_GenericType1](
@@ -250,24 +195,18 @@ class BMEdge:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :param value:
-        :type value: _GenericType1
         """
 
     def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]) -> None:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         """
 
 class BMEdgeSeq:
     layers: BMLayerAccessEdge
-    """ custom-data layers (read-only).
-
-    :type: BMLayerAccessEdge
-    """
+    """ custom-data layers (read-only)."""
 
     def ensure_lookup_table(self) -> None:
         """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
@@ -280,11 +219,8 @@ class BMEdgeSeq:
         """Return an edge which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: collections.abc.Sequence[BMVert]
         :param fallback: Return this value if nothing is found.
-        :type fallback: typing.Any | None
         :return: The edge found or None
-        :rtype: BMEdge
         """
 
     def index_update(self) -> None:
@@ -296,18 +232,14 @@ class BMEdgeSeq:
         """Create a new edge from a given pair of verts.
 
         :param verts: Vertex pair.
-        :type verts: collections.abc.Sequence[BMVert]
         :param example: Existing edge to initialize settings (optional argument).
-        :type example: BMEdge | None
         :return: The newly created edge.
-        :rtype: BMEdge
         """
 
     def remove(self, edge: BMEdge) -> None:
         """Remove an edge.
 
         :param edge: The edge to remove.
-        :type edge: BMEdge
         """
 
     def sort(
@@ -322,9 +254,7 @@ class BMEdgeSeq:
         Indices of elements are not changed, `bmesh.types.BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
-                :type key: None | collections.abc.Callable[[BMVert | BMEdge | BMFace], int] | None
                 :param reverse: Reverse the order of the elements
-                :type reverse: bool
         """
 
     @typing.overload
@@ -332,9 +262,7 @@ class BMEdgeSeq:
         """
 
         :param key:
-        :type key: int
         :return:
-        :rtype: BMEdge
         """
 
     @typing.overload
@@ -342,33 +270,26 @@ class BMEdgeSeq:
         """
 
         :param key:
-        :type key: slice
         :return:
-        :rtype: list[BMEdge]
         """
 
     def __iter__(self) -> BMIter[BMEdge]:
         """
 
         :return:
-        :rtype: BMIter[BMEdge]
         """
 
     def __len__(self) -> int:
         """
 
         :return:
-        :rtype: int
         """
 
 class BMEditSelIter: ...
 
 class BMEditSelSeq:
     active: BMEdge | BMFace | BMVert
-    """ The last selected element or None (read-only).
-
-    :type: BMEdge | BMFace | BMVert
-    """
+    """ The last selected element or None (read-only)."""
 
     def add(self, element) -> None:
         """Add an element to the selection history (no action taken if its already added).
@@ -408,9 +329,7 @@ class BMElemSeq[_GenericType1]:
         """
 
         :param key:
-        :type key: int
         :return:
-        :rtype: _GenericType1
         """
 
     @typing.overload
@@ -418,23 +337,19 @@ class BMElemSeq[_GenericType1]:
         """
 
         :param key:
-        :type key: slice
         :return:
-        :rtype: list[_GenericType1]
         """
 
     def __iter__(self) -> BMIter[_GenericType1]:
         """
 
         :return:
-        :rtype: BMIter[_GenericType1]
         """
 
     def __len__(self) -> int:
         """
 
         :return:
-        :rtype: int
         """
 
 class BMFace:
@@ -444,61 +359,34 @@ class BMFace:
     """ Edges of this face, (read-only)."""
 
     hide: bool
-    """ Hidden state of this element.
-
-    :type: bool
-    """
+    """ Hidden state of this element."""
 
     index: int
-    """ Index of this element.
-
-    :type: int
-    """
+    """ Index of this element."""
 
     is_valid: bool
-    """ True when this element is valid (hasn't been removed).
-
-    :type: bool
-    """
+    """ True when this element is valid (hasn't been removed)."""
 
     loops: typing.Any
     """ Loops of this face, (read-only)."""
 
     material_index: int
-    """ The face's material index.
-
-    :type: int
-    """
+    """ The face's material index."""
 
     normal: mathutils.Vector
-    """ The normal for this face as a 3D, wrapped vector.
-
-    :type: mathutils.Vector
-    """
+    """ The normal for this face as a 3D, wrapped vector."""
 
     select: bool
-    """ Selected state of this element.
-
-    :type: bool
-    """
+    """ Selected state of this element."""
 
     smooth: bool
-    """ Smooth state of this element.
-
-    :type: bool
-    """
+    """ Smooth state of this element."""
 
     tag: bool
-    """ Generic attribute scripts can use for own logic
-
-    :type: bool
-    """
+    """ Generic attribute scripts can use for own logic"""
 
     uv_select: bool
-    """ UV selected state of this element.
-
-    :type: bool
-    """
+    """ UV selected state of this element."""
 
     verts: typing.Any
     """ Verts of this face, (read-only)."""
@@ -507,81 +395,68 @@ class BMFace:
         """Return the area of the face.
 
         :return: Return the area of the face.
-        :rtype: float
         """
 
     def calc_center_bounds(self) -> mathutils.Vector:
         """Return bounds center of the face.
 
         :return: a 3D vector.
-        :rtype: mathutils.Vector
         """
 
     def calc_center_median(self) -> mathutils.Vector:
         """Return median center of the face.
 
         :return: a 3D vector.
-        :rtype: mathutils.Vector
         """
 
     def calc_center_median_weighted(self) -> mathutils.Vector:
         """Return median center of the face weighted by edge lengths.
 
         :return: a 3D vector.
-        :rtype: mathutils.Vector
         """
 
     def calc_perimeter(self) -> float:
         """Return the perimeter of the face.
 
         :return: Return the perimeter of the face.
-        :rtype: float
         """
 
     def calc_tangent_edge(self) -> mathutils.Vector:
         """Return face tangent based on longest edge.
 
         :return: a normalized vector.
-        :rtype: mathutils.Vector
         """
 
     def calc_tangent_edge_diagonal(self) -> mathutils.Vector:
         """Return face tangent based on the edge farthest from any vertex.
 
         :return: a normalized vector.
-        :rtype: mathutils.Vector
         """
 
     def calc_tangent_edge_pair(self) -> mathutils.Vector:
         """Return face tangent based on the two longest disconnected edges.
 
         :return: a normalized vector.
-        :rtype: mathutils.Vector
         """
 
     def calc_tangent_vert_diagonal(self) -> mathutils.Vector:
         """Return face tangent based on the two most distant vertices.
 
         :return: a normalized vector.
-        :rtype: mathutils.Vector
         """
 
     def copy(self, *, verts: bool = True, edges: bool = True) -> typing_extensions.Self:
         """Make a copy of this face.
 
         :param verts: When set, the faces verts will be duplicated too.
-        :type verts: bool
         :param edges: When set, the faces edges will be duplicated too.
-        :type edges: bool
         :return: The newly created face.
-        :rtype: typing_extensions.Self
         """
 
     def copy_from(self, other: typing_extensions.Self) -> None:
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: typing_extensions.Self
         """
 
     def copy_from_face_interp(
@@ -590,9 +465,7 @@ class BMFace:
         """Interpolate the customdata from another face onto this one (faces should overlap).
 
         :param face: The face to interpolate data from.
-        :type face: typing_extensions.Self
         :param vert: When True, also copy vertex data.
-        :type vert: bool
         """
 
     def hide_set(self, hide: bool) -> None:
@@ -600,7 +473,6 @@ class BMFace:
         This is different from the hide attribute because it updates the selection and hide state of associated geometry.
 
                 :param hide: Hidden or visible.
-                :type hide: bool
         """
 
     def normal_flip(self) -> None:
@@ -617,14 +489,12 @@ class BMFace:
         This is different from the select attribute because it updates the selection state of associated geometry.
 
                 :param select: Select or de-select.
-                :type select: bool
         """
 
     def uv_select_set(self, select: bool) -> None:
         """Select the face.
 
         :param select: Select or de-select.
-        :type select: bool
         """
 
     def __getitem__[_GenericType1](
@@ -633,9 +503,7 @@ class BMFace:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :return:
-        :rtype: _GenericType1
         """
 
     def __setitem__[_GenericType1](
@@ -644,30 +512,21 @@ class BMFace:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :param value:
-        :type value: _GenericType1
         """
 
     def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]) -> None:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         """
 
 class BMFaceSeq:
     active: BMFace | None
-    """ active face.
-
-    :type: BMFace | None
-    """
+    """ active face."""
 
     layers: BMLayerAccessFace
-    """ custom-data layers (read-only).
-
-    :type: BMLayerAccessFace
-    """
+    """ custom-data layers (read-only)."""
 
     def ensure_lookup_table(self) -> None:
         """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
@@ -680,11 +539,8 @@ class BMFaceSeq:
         """Return a face which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: collections.abc.Sequence[BMVert]
         :param fallback: Return this value if nothing is found.
-        :type fallback: typing.Any | None
         :return: The face found or None
-        :rtype: BMFace
         """
 
     def index_update(self) -> None:
@@ -696,18 +552,14 @@ class BMFaceSeq:
         """Create a new face from a given set of verts.
 
         :param verts: Sequence of 3 or more verts.
-        :type verts: collections.abc.Sequence[BMVert]
         :param example: Existing face to initialize settings (optional argument).
-        :type example: BMFace | None
         :return: The newly created face.
-        :rtype: BMFace
         """
 
     def remove(self, face: BMFace) -> None:
         """Remove a face.
 
         :param face: The face to remove.
-        :type face: BMFace
         """
 
     def sort(
@@ -722,9 +574,7 @@ class BMFaceSeq:
         Indices of elements are not changed, `bmesh.types.BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
-                :type key: None | collections.abc.Callable[[BMVert | BMEdge | BMFace], int] | None
                 :param reverse: Reverse the order of the elements
-                :type reverse: bool
         """
 
     @typing.overload
@@ -732,9 +582,7 @@ class BMFaceSeq:
         """
 
         :param key:
-        :type key: int
         :return:
-        :rtype: BMFace
         """
 
     @typing.overload
@@ -742,23 +590,19 @@ class BMFaceSeq:
         """
 
         :param key:
-        :type key: slice
         :return:
-        :rtype: list[BMFace]
         """
 
     def __iter__(self) -> BMIter[BMFace]:
         """
 
         :return:
-        :rtype: BMIter[BMFace]
         """
 
     def __len__(self) -> int:
         """
 
         :return:
-        :rtype: int
         """
 
 class BMIter[_GenericType1]:
@@ -770,14 +614,12 @@ class BMIter[_GenericType1]:
         """
 
         :return:
-        :rtype: BMIter[_GenericType1]
         """
 
     def __next__(self) -> _GenericType1:
         """
 
         :return:
-        :rtype: _GenericType1
         """
 
 class BMLayerAccessEdge:
@@ -892,16 +734,8 @@ class BMLayerCollection[_GenericType1]:
     """Gives access to a collection of custom-data layers of the same type and behaves like Python dictionaries, except for the ability to do list like index access."""
 
     active: BMLayerItem[_GenericType1]
-    """ 
-
-    :type: BMLayerItem[_GenericType1]
-    """
-
     is_singleton: bool
-    """ True if there can exists only one layer of this type (read-only).
-
-    :type: bool
-    """
+    """ True if there can exists only one layer of this type (read-only)."""
 
     def get[_GenericType2](
         self, key: str, default: _GenericType2 = None
@@ -910,12 +744,9 @@ class BMLayerCollection[_GenericType1]:
         when not found (matches Pythons dictionary function of the same name).
 
                 :param key: The key associated with the layer.
-                :type key: str
                 :param default: Optional argument for the value to return if
         key is not found.
-                :type default: _GenericType2
                 :return:
-                :rtype: BMLayerItem[_GenericType1] | _GenericType2
         """
 
     def items(self) -> list[str, BMLayerItem[_GenericType1]]:
@@ -923,7 +754,6 @@ class BMLayerCollection[_GenericType1]:
         (matching Pythons dict.items() functionality).
 
                 :return: (key, value) pairs for each member of this collection.
-                :rtype: list[str, BMLayerItem[_GenericType1]]
         """
 
     def keys(self) -> list[str]:
@@ -931,23 +761,19 @@ class BMLayerCollection[_GenericType1]:
         (matching Pythons dict.keys() functionality).
 
                 :return: the identifiers for each member of this collection.
-                :rtype: list[str]
         """
 
     def new(self, name: str | None = "") -> BMLayerItem[_GenericType1]:
         """Create a new layer
 
         :param name: Optional name argument (will be made unique).
-        :type name: str | None
         :return: The newly created layer.
-        :rtype: BMLayerItem[_GenericType1]
         """
 
     def remove(self, layer: BMLayerItem[_GenericType1]) -> None:
         """Remove a layer
 
         :param layer: The layer to remove.
-        :type layer: BMLayerItem[_GenericType1]
         """
 
     def values(self) -> list[BMLayerItem[_GenericType1]]:
@@ -955,122 +781,76 @@ class BMLayerCollection[_GenericType1]:
         (matching Pythons dict.values() functionality).
 
                 :return: the members of this collection.
-                :rtype: list[BMLayerItem[_GenericType1]]
         """
 
     def verify(self) -> BMLayerItem[_GenericType1]:
         """Create a new layer or return an existing active layer
 
         :return: The newly verified layer.
-        :rtype: BMLayerItem[_GenericType1]
         """
 
 class BMLayerItem[_GenericType1]:
     """Exposes a single custom data layer, their main purpose is for use as item accessors to custom-data when used with vert/edge/face/loop data."""
 
     name: str
-    """ The layers unique name (read-only).
-
-    :type: str
-    """
+    """ The layers unique name (read-only)."""
 
     def copy_from(self, other: typing_extensions.Self) -> None:
         """Copy data from another layer.
 
         :param other: Another layer to copy from.
-        :type other: typing_extensions.Self
         """
 
 class BMLoop:
     """This is normally accessed from `bmesh.types.BMFace.loops` where each face loop represents a corner of the face."""
 
     edge: BMEdge
-    """ The loop's edge (between this loop and the next), (read-only).
-
-    :type: BMEdge
-    """
+    """ The loop's edge (between this loop and the next), (read-only)."""
 
     face: BMFace
-    """ The face this loop makes (read-only).
-
-    :type: BMFace
-    """
+    """ The face this loop makes (read-only)."""
 
     index: int
-    """ Index of this element.
-
-    :type: int
-    """
+    """ Index of this element."""
 
     is_convex: bool
-    """ True when this loop is at the convex corner of a face, depends on a valid face normal (read-only).
-
-    :type: bool
-    """
+    """ True when this loop is at the convex corner of a face, depends on a valid face normal (read-only)."""
 
     is_valid: bool
-    """ True when this element is valid (hasn't been removed).
-
-    :type: bool
-    """
+    """ True when this element is valid (hasn't been removed)."""
 
     link_loop_next: typing_extensions.Self
-    """ The next face corner (read-only).
-
-    :type: typing_extensions.Self
-    """
+    """ The next face corner (read-only)."""
 
     link_loop_prev: typing_extensions.Self
-    """ The previous face corner (read-only).
-
-    :type: typing_extensions.Self
-    """
+    """ The previous face corner (read-only)."""
 
     link_loop_radial_next: typing_extensions.Self
-    """ The next loop around the edge (read-only).
-
-    :type: typing_extensions.Self
-    """
+    """ The next loop around the edge (read-only)."""
 
     link_loop_radial_prev: typing_extensions.Self
-    """ The previous loop around the edge (read-only).
-
-    :type: typing_extensions.Self
-    """
+    """ The previous loop around the edge (read-only)."""
 
     link_loops: typing.Any
     """ Loops connected to this loop, (read-only)."""
 
     tag: bool
-    """ Generic attribute scripts can use for own logic
-
-    :type: bool
-    """
+    """ Generic attribute scripts can use for own logic"""
 
     uv_select_edge: bool
-    """ UV selected state of this element.
-
-    :type: bool
-    """
+    """ UV selected state of this element."""
 
     uv_select_vert: bool
-    """ UV selected state of this element.
-
-    :type: bool
-    """
+    """ UV selected state of this element."""
 
     vert: BMVert
-    """ The loop's vertex (read-only).
-
-    :type: BMVert
-    """
+    """ The loop's vertex (read-only)."""
 
     def calc_angle(self) -> float:
         """Return the angle at this loops corner of the face.
         This is calculated so sharper corners give lower angles.
 
                 :return: The angle in radians.
-                :rtype: float
         """
 
     def calc_normal(self) -> mathutils.Vector:
@@ -1078,7 +858,6 @@ class BMLoop:
         Falls back to the face normal for straight lines.
 
                 :return: a normalized vector.
-                :rtype: mathutils.Vector
         """
 
     def calc_tangent(self) -> mathutils.Vector:
@@ -1086,14 +865,12 @@ class BMLoop:
         Falls back to the face normal for straight lines.
 
                 :return: a normalized vector.
-                :rtype: mathutils.Vector
         """
 
     def copy_from(self, other: typing_extensions.Self) -> None:
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: typing_extensions.Self
         """
 
     def copy_from_face_interp(
@@ -1102,25 +879,20 @@ class BMLoop:
         """Interpolate the customdata from a face onto this loop (the loops vert should overlap the face).
 
         :param face: The face to interpolate data from.
-        :type face: BMFace
         :param vert: When enabled, interpolate the loops vertex data (optional).
-        :type vert: bool
         :param multires: When enabled, interpolate the loops multires data (optional).
-        :type multires: bool
         """
 
     def uv_select_edge_set(self, select: bool) -> None:
         """Set the UV edge selection state.
 
         :param select: Select or de-select.
-        :type select: bool
         """
 
     def uv_select_vert_set(self, select: bool) -> None:
         """Select the UV vertex.
 
         :param select: Select or de-select.
-        :type select: bool
         """
 
     def __getitem__[_GenericType1](
@@ -1129,9 +901,7 @@ class BMLoop:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :return:
-        :rtype: _GenericType1
         """
 
     def __setitem__[_GenericType1](
@@ -1140,33 +910,25 @@ class BMLoop:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :param value:
-        :type value: _GenericType1
         """
 
     def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]) -> None:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         """
 
 class BMLoopSeq:
     layers: BMLayerAccessLoop
-    """ custom-data layers (read-only).
-
-    :type: BMLayerAccessLoop
-    """
+    """ custom-data layers (read-only)."""
 
     @typing.overload
     def __getitem__(self, key: int) -> BMLoop:
         """
 
         :param key:
-        :type key: int
         :return:
-        :rtype: BMLoop
         """
 
     @typing.overload
@@ -1174,82 +936,51 @@ class BMLoopSeq:
         """
 
         :param key:
-        :type key: slice
         :return:
-        :rtype: list[BMLoop]
         """
 
     def __iter__(self) -> BMIter[BMLoop]:
         """
 
         :return:
-        :rtype: BMIter[BMLoop]
         """
 
     def __len__(self) -> int:
         """
 
         :return:
-        :rtype: int
         """
 
 class BMLoopUV:
     pin_uv: bool
-    """ UV pin state.
-
-    :type: bool
-    """
+    """ UV pin state."""
 
     uv: mathutils.Vector
-    """ Loops UV (as a 2D Vector).
-
-    :type: mathutils.Vector
-    """
+    """ Loops UV (as a 2D Vector)."""
 
 class BMVert:
     """The BMesh vertex type"""
 
     co: mathutils.Vector
-    """ The coordinates for this vertex as a 3D, wrapped vector.
-
-    :type: mathutils.Vector
-    """
+    """ The coordinates for this vertex as a 3D, wrapped vector."""
 
     hide: bool
-    """ Hidden state of this element.
-
-    :type: bool
-    """
+    """ Hidden state of this element."""
 
     index: int
-    """ Index of this element.
-
-    :type: int
-    """
+    """ Index of this element."""
 
     is_boundary: bool
-    """ True when this vertex is connected to boundary edges (read-only).
-
-    :type: bool
-    """
+    """ True when this vertex is connected to boundary edges (read-only)."""
 
     is_manifold: bool
-    """ True when this vertex is manifold (read-only).
-
-    :type: bool
-    """
+    """ True when this vertex is manifold (read-only)."""
 
     is_valid: bool
-    """ True when this element is valid (hasn't been removed).
-
-    :type: bool
-    """
+    """ True when this element is valid (hasn't been removed)."""
 
     is_wire: bool
-    """ True when this vertex is not connected to any faces (read-only).
-
-    :type: bool
-    """
+    """ True when this vertex is not connected to any faces (read-only)."""
 
     link_edges: typing.Any
     """ Edges connected to this vertex (read-only)."""
@@ -1261,31 +992,20 @@ class BMVert:
     """ Loops that use this vertex (read-only)."""
 
     normal: mathutils.Vector
-    """ The normal for this vertex as a 3D, wrapped vector.
-
-    :type: mathutils.Vector
-    """
+    """ The normal for this vertex as a 3D, wrapped vector."""
 
     select: bool
-    """ Selected state of this element.
-
-    :type: bool
-    """
+    """ Selected state of this element."""
 
     tag: bool
-    """ Generic attribute scripts can use for own logic
-
-    :type: bool
-    """
+    """ Generic attribute scripts can use for own logic"""
 
     def calc_edge_angle(self, fallback: typing.Any | None = None) -> float:
         """Return the angle between this verts two connected edges.
 
                 :param fallback: return this when the vert doesnt have 2 edges
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: Angle between edges in radians.
-                :rtype: float
         """
 
     def calc_shell_factor(self) -> float:
@@ -1294,21 +1014,18 @@ class BMVert:
         This is used to maintain shell thickness when offsetting verts along their normals.
 
                 :return: offset multiplier
-                :rtype: float
         """
 
     def copy_from(self, other: typing_extensions.Self) -> None:
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: typing_extensions.Self
         """
 
     def copy_from_face_interp(self, face: BMFace) -> None:
         """Interpolate the customdata from a face onto this loop (the loops vert should overlap the face).
 
         :param face: The face to interpolate data from.
-        :type face: BMFace
         """
 
     def copy_from_vert_interp(
@@ -1317,9 +1034,7 @@ class BMVert:
         """Interpolate the customdata from a vert between 2 other verts.
 
         :param vert_pair: The verts between which to interpolate data from.
-        :type vert_pair: collections.abc.Sequence[BMVert]
         :param fac: The interpolation factor.
-        :type fac: float
         """
 
     def hide_set(self, hide: bool) -> None:
@@ -1327,7 +1042,6 @@ class BMVert:
         This is different from the hide attribute because it updates the selection and hide state of associated geometry.
 
                 :param hide: Hidden or visible.
-                :type hide: bool
         """
 
     def normal_update(self) -> None:
@@ -1341,7 +1055,6 @@ class BMVert:
         This is different from the select attribute because it updates the selection state of associated geometry.
 
                 :param select: Select or de-select.
-                :type select: bool
         """
 
     def __getitem__[_GenericType1](
@@ -1350,9 +1063,7 @@ class BMVert:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :return:
-        :rtype: _GenericType1
         """
 
     def __setitem__[_GenericType1](
@@ -1361,24 +1072,18 @@ class BMVert:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         :param value:
-        :type value: _GenericType1
         """
 
     def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]) -> None:
         """
 
         :param key:
-        :type key: BMLayerItem[_GenericType1]
         """
 
 class BMVertSeq:
     layers: BMLayerAccessVert
-    """ custom-data layers (read-only).
-
-    :type: BMLayerAccessVert
-    """
+    """ custom-data layers (read-only)."""
 
     def ensure_lookup_table(self) -> None:
         """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
@@ -1394,18 +1099,14 @@ class BMVertSeq:
         """Create a new vertex.
 
         :param co: The initial location of the vertex (optional argument).
-        :type co: collections.abc.Sequence[float] | mathutils.Vector
         :param example: Existing vert to initialize settings.
-        :type example: BMVert | None
         :return: The newly created vertex.
-        :rtype: BMVert
         """
 
     def remove(self, vert: BMVert) -> None:
         """Remove a vert.
 
         :param vert: The vert to remove.
-        :type vert: BMVert
         """
 
     def sort(
@@ -1420,9 +1121,7 @@ class BMVertSeq:
         Indices of elements are not changed, `bmesh.types.BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
-                :type key: None | collections.abc.Callable[[BMVert | BMEdge | BMFace], int] | None
                 :param reverse: Reverse the order of the elements
-                :type reverse: bool
         """
 
     @typing.overload
@@ -1430,9 +1129,7 @@ class BMVertSeq:
         """
 
         :param key:
-        :type key: int
         :return:
-        :rtype: BMVert
         """
 
     @typing.overload
@@ -1440,93 +1137,62 @@ class BMVertSeq:
         """
 
         :param key:
-        :type key: slice
         :return:
-        :rtype: list[BMVert]
         """
 
     def __iter__(self) -> BMIter[BMVert]:
         """
 
         :return:
-        :rtype: BMIter[BMVert]
         """
 
     def __len__(self) -> int:
         """
 
         :return:
-        :rtype: int
         """
 
 class BMesh:
     """The BMesh data structure"""
 
     edges: BMEdgeSeq
-    """ This meshes edge sequence (read-only).
-
-    :type: BMEdgeSeq
-    """
+    """ This meshes edge sequence (read-only)."""
 
     faces: BMFaceSeq
-    """ This meshes face sequence (read-only).
-
-    :type: BMFaceSeq
-    """
+    """ This meshes face sequence (read-only)."""
 
     is_valid: bool
-    """ True when this element is valid (hasn't been removed).
-
-    :type: bool
-    """
+    """ True when this element is valid (hasn't been removed)."""
 
     is_wrapped: bool
-    """ True when this mesh is owned by blender (typically the editmode BMesh).
-
-    :type: bool
-    """
+    """ True when this mesh is owned by blender (typically the editmode BMesh)."""
 
     loops: BMLoopSeq
-    """ This meshes loops (read-only).
-
-    :type: BMLoopSeq
-    """
+    """ This meshes loops (read-only)."""
 
     select_history: BMEditSelSeq
-    """ Sequence of selected items (the last is displayed as active).
-
-    :type: BMEditSelSeq
-    """
+    """ Sequence of selected items (the last is displayed as active)."""
 
-    select_mode: typing.Any
+    select_mode: set[typing.Literal["VERT", "EDGE", "FACE"]]
     """ The selection mode, cannot be assigned an empty set."""
 
     uv_select_sync_valid: bool
-    """ When true, the UV selection has been synchronized. Setting to False means the UV selection will be ignored. While setting to true is supported it is up to the script author to ensure a correct selection state before doing so.
-
-    :type: bool
-    """
+    """ When true, the UV selection has been synchronized. Setting to False means the UV selection will be ignored. While setting to true is supported it is up to the script author to ensure a correct selection state before doing so."""
 
     verts: BMVertSeq
-    """ This meshes vert sequence (read-only).
-
-    :type: BMVertSeq
-    """
+    """ This meshes vert sequence (read-only)."""
 
     def calc_loop_triangles(self) -> list[tuple[BMLoop, BMLoop, BMLoop]]:
         """Calculate triangle tessellation from quads/ngons.
 
         :return: The triangulated faces.
-        :rtype: list[tuple[BMLoop, BMLoop, BMLoop]]
         """
 
     def calc_volume(self, *, signed: bool = False) -> float:
         """Calculate mesh volume based on face normals.
 
         :param signed: when signed is true, negative values may be returned.
-        :type signed: bool
         :return: The volume of the mesh.
-        :rtype: float
         """
 
     def clear(self) -> None:
@@ -1536,7 +1202,6 @@ class BMesh:
         """
 
         :return: A copy of this BMesh.
-        :rtype: typing_extensions.Self
         """
 
     def free(self) -> None:
@@ -1554,15 +1219,10 @@ class BMesh:
         """Initialize this bmesh from existing mesh data-block.
 
         :param mesh: The mesh data to load.
-        :type mesh: bpy.types.Mesh
         :param face_normals: Calculate face normals.
-        :type face_normals: bool
         :param vertex_normals: Calculate vertex normals.
-        :type vertex_normals: bool
         :param use_shape_key: Use the locations from a shape key.
-        :type use_shape_key: bool
         :param shape_key_index: The shape key index to use.
-        :type shape_key_index: int
         """
 
     def from_object(
@@ -1577,15 +1237,10 @@ class BMesh:
         """Initialize this bmesh from existing object data-block (only meshes are currently supported).
 
         :param object: The object data to load.
-        :type object: bpy.types.Object
         :param depsgraph: The dependency graph for evaluated data.
-        :type depsgraph: bpy.types.Depsgraph
         :param cage: Get the mesh as a deformed cage.
-        :type cage: bool
         :param face_normals: Calculate face normals.
-        :type face_normals: bool
         :param vertex_normals: Calculate vertex normals.
-        :type vertex_normals: bool
         """
 
     def normal_update(self) -> None:
@@ -1595,21 +1250,18 @@ class BMesh:
         """Flush selection from vertices, independent of the current selection mode.
 
         :param select: flush selection or de-selected elements.
-        :type select: bool
         """
 
     def select_flush_mode(self, *, flush_down: bool = False) -> None:
         """Flush selection based on the current mode current `bmesh.types.BMesh.select_mode`.
 
         :param flush_down: Flush selection down from faces to edges & verts or from edges to verts. This option is ignored when vertex selection mode is enabled.
-        :type flush_down: bool
         """
 
     def to_mesh(self, mesh: bpy.types.Mesh) -> None:
         """Writes this BMesh data into an existing Mesh data-block.
 
         :param mesh: The mesh data to write into.
-        :type mesh: bpy.types.Mesh
         """
 
     def transform(
@@ -1617,12 +1269,12 @@ class BMesh:
         matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
         | mathutils.Matrix,
         *,
-        filter=None,
+        filter: set[typing.Literal["SELECT", "HIDE", "SEAM", "SMOOTH", "TAG"]]
+        | None = None,
     ) -> None:
         """Transform the mesh (optionally filtering flagged data only).
 
         :param matrix: 4x4 transform matrix.
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
         :param filter: Flag to filter vertices.
         """
 
@@ -1630,21 +1282,18 @@ class BMesh:
         """Flush selection from UV vertices to edges & faces independent of the selection mode.
 
         :param select: Flush selection or de-selected elements.
-        :type select: bool
         """
 
     def uv_select_flush_mode(self, *, flush_down: bool = False) -> None:
         """Flush selection based on the current mode current `BMesh.select_mode`.
 
         :param flush_down: Flush selection down from faces to edges & verts or from edges to verts. This option is ignored when vertex selection mode is enabled.
-        :type flush_down: bool
         """
 
     def uv_select_flush_shared(self, select: bool) -> None:
         """Flush selection from UV vertices to contiguous UVs independent of the selection mode.
 
         :param select: Flush selection or de-selected elements.
-        :type select: bool
         """
 
     def uv_select_foreach_set(
@@ -1662,15 +1311,10 @@ class BMesh:
         """Set the UV selection state for loop-vertices, loop-edges & faces.This is a close equivalent to selecting in the UV editor.
 
         :param select: The selection state to set.
-        :type select: bool
         :param loop_verts: Loop verts to operate on.
-        :type loop_verts: collections.abc.Iterable[BMLoop]
         :param loop_edges: Loop edges to operate on.
-        :type loop_edges: collections.abc.Iterable[BMLoop]
         :param faces: Faces to operate on.
-        :type faces: collections.abc.Iterable[BMFace]
         :param sticky_select_mode: See UV_STICKY_SELECT_MODE_REF.
-        :type sticky_select_mode: typing.Literal['SHARED_LOCATION', 'DISABLED', 'SHARED_VERTEX']
         """
 
     def uv_select_foreach_set_from_mesh(
@@ -1688,15 +1332,10 @@ class BMesh:
         """Select or de-select mesh elements, updating the UV selection.An equivalent to selecting from the 3D viewport for selection operations that support maintaining a synchronized UV selection.
 
         :param select: The selection state to set.
-        :type select: bool
         :param verts: Verts to operate on.
-        :type verts: collections.abc.Iterable[BMVert]
         :param edges: Edges to operate on.
-        :type edges: collections.abc.Iterable[BMEdge]
         :param faces: Faces to operate on.
-        :type faces: collections.abc.Iterable[BMFace]
         :param sticky_select_mode: See UV_STICKY_SELECT_MODE_REF.
-        :type sticky_select_mode: typing.Literal['SHARED_LOCATION', 'DISABLED', 'SHARED_VERTEX']
         """
 
     def uv_select_sync_from_mesh(
@@ -1709,7 +1348,6 @@ class BMesh:
         """Sync selection from mesh to UVs.
 
         :param sticky_select_mode: Behavior when flushing from the mesh to UV selection UV_STICKY_SELECT_MODE_REF. This should only be used when preparing to create a UV selection.
-        :type sticky_select_mode: typing.Literal['SHARED_LOCATION', 'DISABLED', 'SHARED_VERTEX']
         """
 
     def uv_select_sync_to_mesh(self) -> None: