fake-bge-module 20250312__py3-none-any.whl → 20260203__py3-none-any.whl

bmesh/ops/__init__.pyi

@@ -16,19 +16,20 @@ This script shows how operators can be used to model a link of a chain.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bmesh.types
 import bpy.types
 import mathutils
 
-def average_vert_facedata(bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = []):
+def average_vert_facedata(
+    bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = []
+) -> None:
     """Average Vertices Face-vert Data.Merge uv/vcols associated with the input vertices at
-    the bounding box center. (I know, it's not averaging but
+    the bounding box center. (I know, its not averaging but
     the vert_snap_to_bb_center is just too long).
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
+        :param verts: Input vertices.
     """
 
 def beautify_fill(
@@ -41,19 +42,14 @@ def beautify_fill(
     """Beautify Fill.Rotate edges to create more evenly spaced triangles.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param edges: edges that can be flipped
-        :type edges: list[bmesh.types.BMEdge]
-        :param use_restrict_tag: restrict edge rotation to mixed tagged vertices
-        :type use_restrict_tag: bool
-        :param method: method to define what is beautiful
-        :type method: typing.Literal['AREA','ANGLE']
-        :return: geom: new flipped faces and edges
+        :param faces: Input faces.
+        :param edges: Edges that can be flipped.
+        :param use_restrict_tag: Restrict edge rotation to mixed tagged vertices.
+        :param method: Method to define what is beautiful.
+        :return: geom:
+    New flipped faces and edges.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def bevel(
@@ -85,57 +81,39 @@ def bevel(
     """Bevel.Bevels edges and vertices
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input edges and vertices
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param offset: amount to offset beveled edge
-        :type offset: float
-        :param offset_type: how to measure the offset
-        :type offset_type: typing.Literal['OFFSET','WIDTH','DEPTH','PERCENT','ABSOLUTE']
+        :param geom: Input edges and vertices.
+        :param offset: Amount to offset beveled edge.
+        :param offset_type: How to measure the offset.
         :param profile_type: The profile type to use for bevel.
-        :type profile_type: typing.Literal['SUPERELLIPSE','CUSTOM']
-        :param segments: number of segments in bevel
-        :type segments: int
-        :param profile: profile shape, 0->1 (.5=>round)
-        :type profile: float
+        :param segments: Number of segments in bevel.
+        :param profile: Profile shape, 0->1 (.5=>round).
         :param affect: Whether to bevel vertices or edges.
-        :type affect: typing.Literal['VERTICES','EDGES']
-        :param clamp_overlap: do not allow beveled edges/vertices to overlap each other
-        :type clamp_overlap: bool
-        :param material: material for bevel faces, -1 means get from adjacent faces
-        :type material: int
-        :param loop_slide: prefer to slide along edges to having even widths
-        :type loop_slide: bool
-        :param mark_seam: extend edge data to allow seams to run across bevels
-        :type mark_seam: bool
-        :param mark_sharp: extend edge data to allow sharp edges to run across bevels
-        :type mark_sharp: bool
-        :param harden_normals: harden normals
-        :type harden_normals: bool
-        :param face_strength_mode: whether to set face strength, and which faces to set if so
-        :type face_strength_mode: typing.Literal['NONE','NEW','AFFECTED','ALL']
-        :param miter_outer: outer miter kind
-        :type miter_outer: typing.Literal['SHARP','PATCH','ARC']
-        :param miter_inner: outer miter kind
-        :type miter_inner: typing.Literal['SHARP','PATCH','ARC']
-        :param spread: amount to offset beveled edge
-        :type spread: float
+        :param clamp_overlap: Do not allow beveled edges/vertices to overlap each other.
+        :param material: Material for bevel faces, -1 means get from adjacent faces.
+        :param loop_slide: Prefer to slide along edges to having even widths.
+        :param mark_seam: Extend edge data to allow seams to run across bevels.
+        :param mark_sharp: Extend edge data to allow sharp edges to run across bevels.
+        :param harden_normals: Harden normals.
+        :param face_strength_mode: Whether to set face strength, and which faces to set if so.
+        :param miter_outer: Outer miter kind.
+        :param miter_inner: Outer miter kind.
+        :param spread: Amount to offset beveled edge.
         :param custom_profile: CurveProfile, if None ignored
-        :type custom_profile: bpy.types.bpy_struct | None
         :param vmesh_method: The method to use to create meshes at intersections.
-        :type vmesh_method: typing.Literal['ADJ','CUTOFF']
-        :return: faces: output faces
+        :return: faces:
+    Output faces.
 
     type list of (`bmesh.types.BMFace`)
 
-    edges: output edges
+    edges:
+    Output edges.
 
     type list of (`bmesh.types.BMEdge`)
 
-    verts: output verts
+    verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def bisect_edges(
@@ -144,20 +122,17 @@ def bisect_edges(
     cuts: int = 0,
     edge_percents={},
 ) -> dict[str, typing.Any]:
-    """Edge Bisect.Splits input edges (but doesn't do anything else).
+    """Edge Bisect.Splits input edges (but doesnt do anything else).
     This creates a 2-valence vert.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param cuts: number of cuts
-        :type cuts: int
+        :param edges: Input edges.
+        :param cuts: Number of cuts.
         :param edge_percents: Undocumented.
-        :return: geom_split: newly created vertices and edges
+        :return: geom_split:
+    Newly created vertices and edges.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def bisect_plane(
@@ -175,42 +150,32 @@ def bisect_plane(
     """Bisect Plane.Bisects the mesh by a plane (cut the mesh in half).
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param dist: minimum distance when testing if a vert is exactly on the plane
-        :type dist: float
-        :param plane_co: point on the plane
-        :type plane_co: collections.abc.Sequence[float] | mathutils.Vector
-        :param plane_no: direction of the plane
-        :type plane_no: collections.abc.Sequence[float] | mathutils.Vector
-        :param use_snap_center: snap axis aligned verts to the center
-        :type use_snap_center: bool
-        :param clear_outer: when enabled. remove all geometry on the positive side of the plane
-        :type clear_outer: bool
-        :param clear_inner: when enabled. remove all geometry on the negative side of the plane
-        :type clear_inner: bool
-        :return: geom_cut: output geometry aligned with the plane (new and existing)
+        :param geom: Input geometry.
+        :param dist: Minimum distance when testing if a vert is exactly on the plane.
+        :param plane_co: Point on the plane.
+        :param plane_no: Direction of the plane.
+        :param use_snap_center: Snap axis aligned verts to the center.
+        :param clear_outer: When enabled. remove all geometry on the positive side of the plane.
+        :param clear_inner: When enabled. remove all geometry on the negative side of the plane.
+        :return: geom_cut:
+    Output geometry aligned with the plane (new and existing).
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`)
 
-    geom: input and output geometry (result of cut).
+    geom:
+    Input and output geometry (result of cut).
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def bmesh_to_mesh(
     bm: bmesh.types.BMesh, mesh: bpy.types.Mesh, object: bpy.types.Object
-):
-    """BMesh to Mesh.Converts a bmesh to a Mesh. This is reserved for exiting editmode.
+) -> None:
+    """BMesh to Mesh.Converts a bmesh to a Mesh. This is reserved for exiting edit-mode.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param mesh: pointer to a mesh structure to fill in
-    :type mesh: bpy.types.Mesh
-    :param object: pointer to an object structure
-    :type object: bpy.types.Object
+    :param mesh: Pointer to a mesh structure to fill in.
+    :param object: Pointer to an object structure.
     """
 
 def bridge_loops(
@@ -225,49 +190,38 @@ def bridge_loops(
     """Bridge edge loops with faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
+        :param edges: Input edges.
         :param use_pairs: Undocumented.
-        :type use_pairs: bool
         :param use_cyclic: Undocumented.
-        :type use_cyclic: bool
-        :param use_merge: merge rather than creating faces
-        :type use_merge: bool
-        :param merge_factor: merge factor
-        :type merge_factor: float
-        :param twist_offset: twist offset for closed loops
-        :type twist_offset: int
-        :return: faces: new faces
+        :param use_merge: Merge rather than creating faces.
+        :param merge_factor: Merge factor.
+        :param twist_offset: Twist offset for closed loops.
+        :return: faces:
+    New faces.
 
     type list of (`bmesh.types.BMFace`)
 
-    edges: new edges
+    edges:
+    New edges.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def collapse(
     bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = [], uvs: bool = False
-):
+) -> None:
     """Collapse Connected.Collapses connected vertices
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param edges: input edges
-    :type edges: list[bmesh.types.BMEdge]
-    :param uvs: also collapse UVs and such
-    :type uvs: bool
+    :param edges: Input edges.
+    :param uvs: Also collapse UVs and such.
     """
 
-def collapse_uvs(bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = []):
+def collapse_uvs(bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = []) -> None:
     """Collapse Connected UVs.Collapses connected UV vertices.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param edges: input edges
-    :type edges: list[bmesh.types.BMEdge]
+    :param edges: Input edges.
     """
 
 def connect_vert_pair(
@@ -279,17 +233,12 @@ def connect_vert_pair(
     """Connect Verts.Split faces by adding edges that connect verts.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
-        :param verts_exclude: input vertices to explicitly exclude from connecting
-        :type verts_exclude: list[bmesh.types.BMVert]
-        :param faces_exclude: input faces to explicitly exclude from connecting
-        :type faces_exclude: list[bmesh.types.BMFace]
+        :param verts: Input vertices.
+        :param verts_exclude: Input vertices to explicitly exclude from connecting.
+        :param faces_exclude: Input faces to explicitly exclude from connecting.
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def connect_verts(
@@ -301,17 +250,12 @@ def connect_verts(
     """Connect Verts.Split faces by adding edges that connect verts.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
-        :param faces_exclude: input faces to explicitly exclude from connecting
-        :type faces_exclude: list[bmesh.types.BMFace]
-        :param check_degenerate: prevent splits with overlaps & intersections
-        :type check_degenerate: bool
+        :param verts: Input vertices.
+        :param faces_exclude: Input faces to explicitly exclude from connecting.
+        :param check_degenerate: Prevent splits with overlaps & intersections.
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def connect_verts_concave(
@@ -320,9 +264,7 @@ def connect_verts_concave(
     """Connect Verts to form Convex Faces.Ensures all faces are convex faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
+        :param faces: Input faces.
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -330,7 +272,6 @@ def connect_verts_concave(
     faces:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def connect_verts_nonplanar(
@@ -339,11 +280,8 @@ def connect_verts_nonplanar(
     """Connect Verts Across non Planer Faces.Split faces by connecting edges along non planer faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param angle_limit: total rotation angle (radians)
-        :type angle_limit: float
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
+        :param angle_limit: Total rotation angle (radians).
+        :param faces: Input faces.
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -351,7 +289,6 @@ def connect_verts_nonplanar(
     faces:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def contextual_create(
@@ -368,21 +305,18 @@ def contextual_create(
     become a wire edge.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry.
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param mat_nr: material to use
-        :type mat_nr: int
-        :param use_smooth: smooth to use
-        :type use_smooth: bool
-        :return: faces: newly-made face(s)
+        :param geom: Input geometry.
+        :param mat_nr: Material to use.
+        :param use_smooth: Smooth to use.
+        :return: faces:
+    Newly-made face(s).
 
     type list of (`bmesh.types.BMFace`)
 
-    edges: newly-made edge(s)
+    edges:
+    Newly-made edge(s).
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def convex_hull(
@@ -392,20 +326,17 @@ def convex_hull(
     | list[bmesh.types.BMVert] = [],
     use_existing_faces: bool = False,
 ) -> dict[str, typing.Any]:
-    """Convex HullBuilds a convex hull from the vertices in 'input'.If 'use_existing_faces' is true, the hull will not output triangles
-    that are covered by a pre-existing face.All hull vertices, faces, and edges are added to 'geom.out'. Any
+    """Convex HullBuilds a convex hull from the vertices in input.If use_existing_faces is true, the hull will not output triangles
+    that are covered by a pre-existing face.All hull vertices, faces, and edges are added to geom.out. Any
     input elements that end up inside the hull (i.e. are not used by an
-    output face) are added to the 'interior_geom' slot. The
-    'unused_geom' slot will contain all interior geometry that is
-    completely unused. Lastly, 'holes_geom' contains edges and faces
+    output face) are added to the interior_geom slot. The
+    unused_geom slot will contain all interior geometry that is
+    completely unused. Lastly, holes_geom contains edges and faces
     that were in the input and are part of the hull.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param input: input geometry
-        :type input: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param use_existing_faces: skip hull triangles that are covered by a pre-existing face
-        :type use_existing_faces: bool
+        :param input: Input geometry.
+        :param use_existing_faces: Skip hull triangles that are covered by a pre-existing face.
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
@@ -421,7 +352,6 @@ def convex_hull(
     geom_holes:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_circle(
@@ -437,23 +367,16 @@ def create_circle(
     """Creates a Circle.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param cap_ends: whether or not to fill in the ends with faces
-        :type cap_ends: bool
-        :param cap_tris: fill ends with triangles instead of ngons
-        :type cap_tris: bool
-        :param segments: number of vertices in the circle
-        :type segments: int
+        :param cap_ends: Whether or not to fill in the ends with faces.
+        :param cap_tris: Fill ends with triangles instead of ngons.
+        :param segments: Number of vertices in the circle.
         :param radius: Radius of the circle.
-        :type radius: float
-        :param matrix: matrix to multiply the new geometry with
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param calc_uvs: calculate default UVs
-        :type calc_uvs: bool
-        :return: verts: output verts
+        :param matrix: Matrix to multiply the new geometry with.
+        :param calc_uvs: Calculate default UVs.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_cone(
@@ -471,27 +394,18 @@ def create_cone(
     """Create Cone.Creates a cone with variable depth at both ends
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param cap_ends: whether or not to fill in the ends with faces
-        :type cap_ends: bool
-        :param cap_tris: fill ends with triangles instead of ngons
-        :type cap_tris: bool
-        :param segments: number of vertices in the base circle
-        :type segments: int
-        :param radius1: radius of one end
-        :type radius1: float
-        :param radius2: radius of the opposite
-        :type radius2: float
-        :param depth: distance between ends
-        :type depth: float
-        :param matrix: matrix to multiply the new geometry with
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param calc_uvs: calculate default UVs
-        :type calc_uvs: bool
-        :return: verts: output verts
+        :param cap_ends: Whether or not to fill in the ends with faces.
+        :param cap_tris: Fill ends with triangles instead of ngons.
+        :param segments: Number of vertices in the base circle.
+        :param radius1: Radius of one end.
+        :param radius2: Radius of the opposite.
+        :param depth: Distance between ends.
+        :param matrix: Matrix to multiply the new geometry with.
+        :param calc_uvs: Calculate default UVs.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_cube(
@@ -504,17 +418,13 @@ def create_cube(
     """Create CubeCreates a cube.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param size: size of the cube
-        :type size: float
-        :param matrix: matrix to multiply the new geometry with
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param calc_uvs: calculate default UVs
-        :type calc_uvs: bool
-        :return: verts: output verts
+        :param size: Size of the cube.
+        :param matrix: Matrix to multiply the new geometry with.
+        :param calc_uvs: Calculate default UVs.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_grid(
@@ -529,21 +439,15 @@ def create_grid(
     """Create Grid.Creates a grid with a variable number of subdivisions
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param x_segments: number of x segments
-        :type x_segments: int
-        :param y_segments: number of y segments
-        :type y_segments: int
-        :param size: size of the grid
-        :type size: float
-        :param matrix: matrix to multiply the new geometry with
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param calc_uvs: calculate default UVs
-        :type calc_uvs: bool
-        :return: verts: output verts
+        :param x_segments: Number of x segments.
+        :param y_segments: Number of y segments.
+        :param size: Size of the grid.
+        :param matrix: Matrix to multiply the new geometry with.
+        :param calc_uvs: Calculate default UVs.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_icosphere(
@@ -557,19 +461,14 @@ def create_icosphere(
     """Create Ico-Sphere.Creates a grid with a variable number of subdivisions
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param subdivisions: how many times to recursively subdivide the sphere
-        :type subdivisions: int
-        :param radius: radius
-        :type radius: float
-        :param matrix: matrix to multiply the new geometry with
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param calc_uvs: calculate default UVs
-        :type calc_uvs: bool
-        :return: verts: output verts
+        :param subdivisions: How many times to recursively subdivide the sphere.
+        :param radius: Radius.
+        :param matrix: Matrix to multiply the new geometry with.
+        :param calc_uvs: Calculate default UVs.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_monkey(
@@ -581,15 +480,12 @@ def create_monkey(
     """Create Suzanne.Creates a monkey (standard blender primitive).
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param matrix: matrix to multiply the new geometry with
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param calc_uvs: calculate default UVs
-        :type calc_uvs: bool
-        :return: verts: output verts
+        :param matrix: Matrix to multiply the new geometry with.
+        :param calc_uvs: Calculate default UVs.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_uvsphere(
@@ -604,21 +500,15 @@ def create_uvsphere(
     """Create UV Sphere.Creates a grid with a variable number of subdivisions
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param u_segments: number of u segments
-        :type u_segments: int
-        :param v_segments: number of v segment
-        :type v_segments: int
-        :param radius: radius
-        :type radius: float
-        :param matrix: matrix to multiply the new geometry with
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param calc_uvs: calculate default UVs
-        :type calc_uvs: bool
-        :return: verts: output verts
+        :param u_segments: Number of u segments.
+        :param v_segments: Number of v segment.
+        :param radius: Radius.
+        :param matrix: Matrix to multiply the new geometry with.
+        :param calc_uvs: Calculate default UVs.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_vert(
@@ -629,13 +519,11 @@ def create_vert(
     for click-create-vertex.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param co: the coordinate of the new vert
-        :type co: collections.abc.Sequence[float] | mathutils.Vector
-        :return: vert: the new vert
+        :param co: The coordinate of the new vert.
+        :return: vert:
+    The new vert.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def delete(
@@ -652,28 +540,22 @@ def delete(
         "FACES_KEEP_BOUNDARY",
         "TAGGED_ONLY",
     ] = "VERTS",
-):
+) -> None:
     """Delete Geometry.Utility operator to delete geometry.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param geom: input geometry
-    :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-    :param context: geometry types to delete
-    :type context: typing.Literal['VERTS','EDGES','FACES_ONLY','EDGES_FACES','FACES','FACES_KEEP_BOUNDARY','TAGGED_ONLY']
+    :param geom: Input geometry.
+    :param context: Geometry types to delete.
     """
 
 def dissolve_degenerate(
     bm: bmesh.types.BMesh, dist: float = 0, edges: list[bmesh.types.BMEdge] = []
-):
+) -> None:
     """Degenerate Dissolve.Dissolve edges with no length, faces with no area.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param dist: maximum distance to consider degenerate
-    :type dist: float
-    :param edges: input edges
-    :type edges: list[bmesh.types.BMEdge]
+    :param dist: Maximum distance to consider degenerate.
+    :param edges: Input edges.
     """
 
 def dissolve_edges(
@@ -681,21 +563,19 @@ def dissolve_edges(
     edges: list[bmesh.types.BMEdge] = [],
     use_verts: bool = False,
     use_face_split: bool = False,
+    angle_threshold: float = 0,
 ) -> dict[str, typing.Any]:
     """Dissolve Edges.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param use_verts: dissolve verts left between only 2 edges.
-        :type use_verts: bool
-        :param use_face_split: split off face corners to maintain surrounding geometry
-        :type use_face_split: bool
+        :param edges: Input edges.
+        :param use_verts: Dissolve verts left between only 2 edges.
+        :param use_face_split: Split off face corners to maintain surrounding geometry.
+        :param angle_threshold: Do not dissolve verts between 2 edges when their angle exceeds this threshold.
+    Disabled by default.
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def dissolve_faces(
@@ -704,15 +584,11 @@ def dissolve_faces(
     """Dissolve Faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param use_verts: dissolve verts left between only 2 edges.
-        :type use_verts: bool
+        :param faces: Input faces.
+        :param use_verts: Dissolve verts left between only 2 edges.
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def dissolve_limit(
@@ -726,20 +602,14 @@ def dissolve_limit(
     """Limited Dissolve.Dissolve planar faces and co-linear edges.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param angle_limit: total rotation angle (radians)
-        :type angle_limit: float
-        :param use_dissolve_boundaries: dissolve all vertices in between face boundaries
-        :type use_dissolve_boundaries: bool
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param delimit: delimit dissolve operation
+        :param angle_limit: Total rotation angle (radians).
+        :param use_dissolve_boundaries: Dissolve all vertices in between face boundaries.
+        :param verts: Input vertices.
+        :param edges: Input edges.
+        :param delimit: Delimit dissolve operation.
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def dissolve_verts(
@@ -747,17 +617,13 @@ def dissolve_verts(
     verts: list[bmesh.types.BMVert] = [],
     use_face_split: bool = False,
     use_boundary_tear: bool = False,
-):
+) -> None:
     """Dissolve Verts.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param verts: input vertices
-    :type verts: list[bmesh.types.BMVert]
-    :param use_face_split: split off face corners to maintain surrounding geometry
-    :type use_face_split: bool
-    :param use_boundary_tear: split off face corners instead of merging faces
-    :type use_boundary_tear: bool
+    :param verts: Input vertices.
+    :param use_face_split: Split off face corners to maintain surrounding geometry.
+    :param use_boundary_tear: Split off face corners instead of merging faces.
     """
 
 def duplicate(
@@ -773,15 +639,10 @@ def duplicate(
     optionally into a destination mesh.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param dest: destination bmesh, if None will use current on
-        :type dest: bmesh.types.BMesh | None
+        :param geom: Input geometry.
+        :param dest: Destination bmesh, if None will use current on.
         :param use_select_history: Undocumented.
-        :type use_select_history: bool
         :param use_edge_flip_from_face: Undocumented.
-        :type use_edge_flip_from_face: bool
         :return: geom_orig:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
@@ -803,13 +664,14 @@ def duplicate(
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
 
     boundary_map:
+    Boundary edges from the split geometry that maps edges from the original geometry
+    to the destination edges.
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
 
     isovert_map:
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
-        :rtype: dict[str, typing.Any]
     """
 
 def edgeloop_fill(
@@ -821,17 +683,13 @@ def edgeloop_fill(
     """Edge Loop Fill.Create faces defined by one or more non overlapping edge loops.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param mat_nr: material to use
-        :type mat_nr: int
-        :param use_smooth: smooth state to use
-        :type use_smooth: bool
-        :return: faces: new faces
+        :param edges: Input edges.
+        :param mat_nr: Material to use.
+        :param use_smooth: Smooth state to use.
+        :return: faces:
+    New faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def edgenet_fill(
@@ -844,35 +702,28 @@ def edgenet_fill(
     """Edge Net Fill.Create faces defined by enclosed edges.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param mat_nr: material to use
-        :type mat_nr: int
-        :param use_smooth: smooth state to use
-        :type use_smooth: bool
-        :param sides: number of sides
-        :type sides: int
-        :return: faces: new faces
+        :param edges: Input edges.
+        :param mat_nr: Material to use.
+        :param use_smooth: Smooth state to use.
+        :param sides: Number of sides.
+        :return: faces:
+    New faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def edgenet_prepare(
     bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = []
 ) -> dict[str, typing.Any]:
     """Edge-net Prepare.Identifies several useful edge loop cases and modifies them so
-    they'll become a face when edgenet_fill is called. The cases covered are:
+    theyll become a face when edgenet_fill is called. The cases covered are:
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :return: edges: new edges
+        :param edges: Input edges.
+        :return: edges:
+    New edges.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def extrude_discrete_faces(
@@ -884,17 +735,13 @@ def extrude_discrete_faces(
     """Individual Face Extrude.Extrudes faces individually.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
+        :param faces: Input faces.
         :param use_normal_flip: Create faces with reversed direction.
-        :type use_normal_flip: bool
-        :param use_select_history: pass to duplicate
-        :type use_select_history: bool
-        :return: faces: output faces
+        :param use_select_history: Pass to duplicate.
+        :return: faces:
+    Output faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def extrude_edge_only(
@@ -903,21 +750,17 @@ def extrude_edge_only(
     use_normal_flip: bool = False,
     use_select_history: bool = False,
 ) -> dict[str, typing.Any]:
-    """Extrude Only Edges.Extrudes Edges into faces, note that this is very simple, there's no fancy
+    """Extrude Only Edges.Extrudes Edges into faces, note that this is very simple, theres no fancy
     winged extrusion.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input vertices
-        :type edges: list[bmesh.types.BMEdge]
+        :param edges: Input vertices.
         :param use_normal_flip: Create faces with reversed direction.
-        :type use_normal_flip: bool
-        :param use_select_history: pass to duplicate
-        :type use_select_history: bool
-        :return: geom: output geometry
+        :param use_select_history: Pass to duplicate.
+        :return: geom:
+    Output geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def extrude_face_region(
@@ -931,28 +774,22 @@ def extrude_face_region(
     use_normal_from_adjacent: bool = False,
     use_dissolve_ortho_edges: bool = False,
     use_select_history: bool = False,
+    skip_input_flip: bool = False,
 ) -> dict[str, typing.Any]:
     """Extrude Faces.Extrude operator (does not transform)
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: edges and faces
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param edges_exclude: input edges to explicitly exclude from extrusion
-        :param use_keep_orig: keep original geometry (requires geom to include edges).
-        :type use_keep_orig: bool
+        :param geom: Edges and faces.
+        :param edges_exclude: Input edges to explicitly exclude from extrusion.
+        :param use_keep_orig: Keep original geometry (requires geom to include edges).
         :param use_normal_flip: Create faces with reversed direction.
-        :type use_normal_flip: bool
         :param use_normal_from_adjacent: Use winding from surrounding faces instead of this region.
-        :type use_normal_from_adjacent: bool
         :param use_dissolve_ortho_edges: Dissolve edges whose faces form a flat surface.
-        :type use_dissolve_ortho_edges: bool
-        :param use_select_history: pass to duplicate
-        :type use_select_history: bool
+        :param use_select_history: Pass to duplicate.
+        :param skip_input_flip: Skip flipping of input faces to preserve original orientation.
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def extrude_vert_indiv(
@@ -963,19 +800,17 @@ def extrude_vert_indiv(
     """Individual Vertex Extrude.Extrudes wire edges from vertices.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
-        :param use_select_history: pass to duplicate
-        :type use_select_history: bool
-        :return: edges: output wire edges
+        :param verts: Input vertices.
+        :param use_select_history: Pass to duplicate.
+        :return: edges:
+    Output wire edges.
 
     type list of (`bmesh.types.BMEdge`)
 
-    verts: output vertices
+    verts:
+    Output vertices.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def face_attribute_fill(
@@ -987,23 +822,20 @@ def face_attribute_fill(
     """Face Attribute Fill.Fill in faces with data from adjacent faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param use_normals: copy face winding
-        :type use_normals: bool
-        :param use_data: copy face data
-        :type use_data: bool
-        :return: faces_fail: faces that could not be handled
+        :param faces: Input faces.
+        :param use_normals: Copy face winding.
+        :param use_data: Copy face data.
+        :return: faces_fail:
+    Faces that could not be handled.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def find_doubles(
     bm: bmesh.types.BMesh,
     verts: list[bmesh.types.BMVert] = [],
     keep_verts: list[bmesh.types.BMVert] = [],
+    use_connected: bool = False,
     dist: float = 0,
 ) -> dict[str, typing.Any]:
     """Find Doubles.Takes input verts and find vertices they should weld to.
@@ -1011,26 +843,22 @@ def find_doubles(
     with vertices in that set.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
-        :param keep_verts: list of verts to keep
-        :type keep_verts: list[bmesh.types.BMVert]
-        :param dist: maximum distance
-        :type dist: float
+        :param verts: Input vertices.
+        :param keep_verts: List of verts to keep.
+        :param use_connected: Limit the search for doubles by connected geometry.
+        :param dist: Maximum distance.
         :return: targetmap:
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
-        :rtype: dict[str, typing.Any]
     """
 
-def flip_quad_tessellation(bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []):
+def flip_quad_tessellation(
+    bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []
+) -> None:
     """Flip Quad TessellationFlip the tessellation direction of the selected quads.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param faces: Undocumented.
-    :type faces: list[bmesh.types.BMFace]
+    :param faces: Input faces.
     """
 
 def grid_fill(
@@ -1043,19 +871,14 @@ def grid_fill(
     """Grid Fill.Create faces defined by 2 disconnected edge loops (which share edges).
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param mat_nr: material to use
-        :type mat_nr: int
-        :param use_smooth: smooth state to use
-        :type use_smooth: bool
-        :param use_interp_simple: use simple interpolation
-        :type use_interp_simple: bool
-        :return: faces: new faces
+        :param edges: Input edges.
+        :param mat_nr: Material to use.
+        :param use_smooth: Smooth state to use.
+        :param use_interp_simple: Use simple interpolation.
+        :return: faces:
+    New faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def holes_fill(
@@ -1064,15 +887,12 @@ def holes_fill(
     """Fill Holes.Fill boundary edges with faces, copying surrounding custom-data.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param sides: number of face sides to fill
-        :type sides: int
-        :return: faces: new faces
+        :param edges: Input edges.
+        :param sides: Number of face sides to fill.
+        :return: faces:
+    New faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def inset_individual(
@@ -1087,23 +907,16 @@ def inset_individual(
     """Face Inset (Individual).Insets individual faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param thickness: thickness
-        :type thickness: float
-        :param depth: depth
-        :type depth: float
-        :param use_even_offset: scale the offset to give more even thickness
-        :type use_even_offset: bool
-        :param use_interpolate: blend face data across the inset
-        :type use_interpolate: bool
-        :param use_relative_offset: scale the offset by surrounding geometry
-        :type use_relative_offset: bool
-        :return: faces: output faces
+        :param faces: Input faces.
+        :param thickness: Thickness.
+        :param depth: Depth.
+        :param use_even_offset: Scale the offset to give more even thickness.
+        :param use_interpolate: Blend face data across the inset.
+        :param use_relative_offset: Scale the offset by surrounding geometry.
+        :return: faces:
+    Output faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def inset_region(
@@ -1122,31 +935,20 @@ def inset_region(
     """Face Inset (Regions).Inset or outset face regions.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param faces_exclude: input faces to explicitly exclude from inset
-        :type faces_exclude: list[bmesh.types.BMFace]
-        :param use_boundary: inset face boundaries
-        :type use_boundary: bool
-        :param use_even_offset: scale the offset to give more even thickness
-        :type use_even_offset: bool
-        :param use_interpolate: blend face data across the inset
-        :type use_interpolate: bool
-        :param use_relative_offset: scale the offset by surrounding geometry
-        :type use_relative_offset: bool
-        :param use_edge_rail: inset the region along existing edges
-        :type use_edge_rail: bool
-        :param thickness: thickness
-        :type thickness: float
-        :param depth: depth
-        :type depth: float
-        :param use_outset: outset rather than inset
-        :type use_outset: bool
-        :return: faces: output faces
+        :param faces: Input faces.
+        :param faces_exclude: Input faces to explicitly exclude from inset.
+        :param use_boundary: Inset face boundaries.
+        :param use_even_offset: Scale the offset to give more even thickness.
+        :param use_interpolate: Blend face data across the inset.
+        :param use_relative_offset: Scale the offset by surrounding geometry.
+        :param use_edge_rail: Inset the region along existing edges.
+        :param thickness: Thickness.
+        :param depth: Depth.
+        :param use_outset: Outset rather than inset.
+        :return: faces:
+    Output faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def join_triangles(
@@ -1168,35 +970,22 @@ def join_triangles(
     to angle threshold and delimiters.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input geometry.
-        :type faces: list[bmesh.types.BMFace]
+        :param faces: Input geometry.
         :param cmp_seam: Compare seam
-        :type cmp_seam: bool
         :param cmp_sharp: Compare sharp
-        :type cmp_sharp: bool
         :param cmp_uvs: Compare UVs
-        :type cmp_uvs: bool
-        :param cmp_vcols: compare VCols
-        :type cmp_vcols: bool
-        :param cmp_materials: compare materials
-        :type cmp_materials: bool
+        :param cmp_vcols: Compare VCols.
+        :param cmp_materials: Compare materials.
         :param angle_face_threshold: Undocumented.
-        :type angle_face_threshold: float
         :param angle_shape_threshold: Undocumented.
-        :type angle_shape_threshold: float
         :param topology_influence: Undocumented.
-        :type topology_influence: float
         :param deselect_joined: Undocumented.
-        :type deselect_joined: bool
         :param merge_limit: Undocumented.
-        :type merge_limit: int
         :param neighbor_debug: Undocumented.
-        :type neighbor_debug: int
-        :return: faces: joined faces
+        :return: faces:
+    Joined faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def mesh_to_bmesh(
@@ -1204,18 +993,14 @@ def mesh_to_bmesh(
     mesh: bpy.types.Mesh,
     object: bpy.types.Object,
     use_shapekey: bool = False,
-):
-    """Mesh to BMesh.Load the contents of a mesh into the bmesh. this BMOP is private, it's
-    reserved exclusively for entering editmode.
+) -> None:
+    """Mesh to BMesh.Load the contents of a mesh into the bmesh. this BMOP is private, its
+    reserved exclusively for entering edit-mode.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param mesh: pointer to a Mesh structure
-        :type mesh: bpy.types.Mesh
-        :param object: pointer to an Object structure
-        :type object: bpy.types.Object
-        :param use_shapekey: load active shapekey coordinates into verts
-        :type use_shapekey: bool
+        :param mesh: Pointer to a Mesh structure.
+        :param object: Pointer to an Object structure.
+        :param use_shapekey: Load active shapekey coordinates into verts.
     """
 
 def mirror(
@@ -1237,41 +1022,29 @@ def mirror(
     parameter (which defines the minimum distance for welding to happen).
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param matrix: matrix defining the mirror transformation
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param merge_dist: maximum distance for merging. does no merging if 0.
-        :type merge_dist: float
-        :param axis: the axis to use.
-        :type axis: typing.Literal['X','Y','Z']
-        :param mirror_u: mirror UVs across the u axis
-        :type mirror_u: bool
-        :param mirror_v: mirror UVs across the v axis
-        :type mirror_v: bool
-        :param mirror_udim: mirror UVs in each tile
-        :type mirror_udim: bool
+        :param geom: Input geometry.
+        :param matrix: Matrix defining the mirror transformation.
+        :param merge_dist: Maximum distance for merging. does no merging if 0.
+        :param axis: The axis to use.
+        :param mirror_u: Mirror UVs across the u axis.
+        :param mirror_v: Mirror UVs across the v axis.
+        :param mirror_udim: Mirror UVs in each tile.
         :param use_shapekey: Transform shape keys too.
-        :type use_shapekey: bool
-        :return: geom: output geometry, mirrored
+        :return: geom:
+    Output geometry, mirrored.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def object_load_bmesh(
     bm: bmesh.types.BMesh, scene: bpy.types.Scene, object: bpy.types.Object
-):
+) -> None:
     """Object Load BMesh.Loads a bmesh into an object/mesh. This is a "private"
     BMOP.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param scene: pointer to an scene structure
-        :type scene: bpy.types.Scene
-        :param object: pointer to an object structure
-        :type object: bpy.types.Object
+        :param scene: Pointer to an scene structure.
+        :param object: Pointer to an object structure.
     """
 
 def offset_edgeloops(
@@ -1282,15 +1055,12 @@ def offset_edgeloops(
     """Edge-loop Offset.Creates edge loops based on simple edge-outset method.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param use_cap_endpoint: extend loop around end-points
-        :type use_cap_endpoint: bool
-        :return: edges: output edges
+        :param edges: Input edges.
+        :param use_cap_endpoint: Extend loop around end-points.
+        :return: edges:
+    Output edges.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def planar_faces(
@@ -1302,47 +1072,37 @@ def planar_faces(
     """Planar Faces.Iteratively flatten faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input geometry.
-        :type faces: list[bmesh.types.BMFace]
+        :param faces: Input geometry.
         :param iterations: Number of times to flatten faces (for when connected faces are used)
-        :type iterations: int
         :param factor: Influence for making planar each iteration
-        :type factor: float
-        :return: geom: output slot, computed boundary geometry.
+        :return: geom:
+    Output slot, computed boundary geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def pointmerge(
     bm: bmesh.types.BMesh,
     verts: list[bmesh.types.BMVert] = [],
     merge_co: collections.abc.Sequence[float] | mathutils.Vector = mathutils.Vector(),
-):
+) -> None:
     """Point Merge.Merge verts together at a point.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param verts: input vertices (all verts will be merged into the first).
-    :type verts: list[bmesh.types.BMVert]
+    :param verts: Input vertices (all verts will be merged into the first).
     :param merge_co: Position to merge at.
-    :type merge_co: collections.abc.Sequence[float] | mathutils.Vector
     """
 
 def pointmerge_facedata(
     bm: bmesh.types.BMesh,
     verts: list[bmesh.types.BMVert] = [],
     vert_snap: bmesh.types.BMVert | None = None,
-):
+) -> None:
     """Face-Data Point Merge.Merge uv/vcols at a specific vertex.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param verts: input vertices
-    :type verts: list[bmesh.types.BMVert]
-    :param vert_snap: snap vertex
-    :type vert_snap: bmesh.types.BMVert | None
+    :param verts: Input vertices.
+    :param vert_snap: Snap vertex.
     """
 
 def poke(
@@ -1355,32 +1115,28 @@ def poke(
     """Pokes a face.Splits a face into a triangle fan.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param offset: center vertex offset along normal
-        :type offset: float
-        :param center_mode: calculation mode for center vertex
-        :type center_mode: typing.Literal['MEAN_WEIGHTED','MEAN','BOUNDS']
-        :param use_relative_offset: apply offset
-        :type use_relative_offset: bool
-        :return: verts: output verts
+        :param faces: Input faces.
+        :param offset: Center vertex offset along normal.
+        :param center_mode: Calculation mode for center vertex.
+        :param use_relative_offset: Apply offset.
+        :return: verts:
+    Output verts.
 
     type list of (`bmesh.types.BMVert`)
 
-    faces: output faces
+    faces:
+    Output faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
-def recalc_face_normals(bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []):
+def recalc_face_normals(
+    bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []
+) -> None:
     """Right-Hand Faces.Computes an "outside" normal for the specified input faces.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param faces: input faces
-    :type faces: list[bmesh.types.BMFace]
+    :param faces: Input faces.
     """
 
 def region_extend(
@@ -1398,71 +1154,59 @@ def region_extend(
     otherwise it spits out faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param use_contract: find boundary inside the regions, not outside.
-        :type use_contract: bool
-        :param use_faces: extend from faces instead of edges
-        :type use_faces: bool
-        :param use_face_step: step over connected faces
-        :type use_face_step: bool
-        :return: geom: output slot, computed boundary geometry.
+        :param geom: Input geometry.
+        :param use_contract: Find boundary inside the regions, not outside.
+        :param use_faces: Extend from faces instead of edges.
+        :param use_face_step: Step over connected faces.
+        :return: geom:
+    Output slot, computed boundary geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def remove_doubles(
-    bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = [], dist: float = 0
-):
+    bm: bmesh.types.BMesh,
+    verts: list[bmesh.types.BMVert] = [],
+    use_connected: bool = False,
+    dist: float = 0,
+) -> None:
     """Remove Doubles.Finds groups of vertices closer than dist and merges them together,
     using the weld verts BMOP.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param verts: input verts
-        :type verts: list[bmesh.types.BMVert]
-        :param dist: minimum distance
-        :type dist: float
+        :param verts: Input verts.
+        :param use_connected: Limit the search for doubles by connected geometry.
+        :param dist: Minimum distance.
     """
 
 def reverse_colors(
     bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = [], color_index: int = 0
-):
+) -> None:
     """Color ReverseReverse the loop colors.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param faces: input faces
-    :type faces: list[bmesh.types.BMFace]
-    :param color_index: index into color attribute list
-    :type color_index: int
+    :param faces: Input faces.
+    :param color_index: Index into color attribute list.
     """
 
 def reverse_faces(
     bm: bmesh.types.BMesh,
     faces: list[bmesh.types.BMFace] = [],
     flip_multires: bool = False,
-):
+) -> None:
     """Reverse Faces.Reverses the winding (vertex order) of faces.
     This has the effect of flipping the normal.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param flip_multires: maintain multi-res offset
-        :type flip_multires: bool
+        :param faces: Input faces.
+        :param flip_multires: Maintain multi-res offset.
     """
 
-def reverse_uvs(bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []):
+def reverse_uvs(bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []) -> None:
     """UV Reverse.Reverse the UVs
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param faces: input faces
-    :type faces: list[bmesh.types.BMFace]
+    :param faces: Input faces.
     """
 
 def rotate(
@@ -1474,21 +1218,15 @@ def rotate(
     space: collections.abc.Sequence[collections.abc.Sequence[float]]
     | mathutils.Matrix = mathutils.Matrix.Identity(4),
     use_shapekey: bool = False,
-):
+) -> None:
     """Rotate.Rotate vertices around a center, using a 3x3 rotation matrix.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param cent: center of rotation
-    :type cent: collections.abc.Sequence[float] | mathutils.Vector
-    :param matrix: matrix defining rotation
-    :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-    :param verts: input vertices
-    :type verts: list[bmesh.types.BMVert]
-    :param space: matrix to define the space (typically object matrix)
-    :type space: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
+    :param cent: Center of rotation.
+    :param matrix: Matrix defining rotation.
+    :param verts: Input vertices.
+    :param space: Matrix to define the space (typically object matrix).
     :param use_shapekey: Transform shape keys too.
-    :type use_shapekey: bool
     """
 
 def rotate_colors(
@@ -1496,48 +1234,38 @@ def rotate_colors(
     faces: list[bmesh.types.BMFace] = [],
     use_ccw: bool = False,
     color_index: int = 0,
-):
+) -> None:
     """Color Rotation.Cycle the loop colors
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param faces: input faces
-    :type faces: list[bmesh.types.BMFace]
-    :param use_ccw: rotate counter-clockwise if true, otherwise clockwise
-    :type use_ccw: bool
-    :param color_index: index into color attribute list
-    :type color_index: int
+    :param faces: Input faces.
+    :param use_ccw: Rotate counter-clockwise if true, otherwise clockwise.
+    :param color_index: Index into color attribute list.
     """
 
 def rotate_edges(
     bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = [], use_ccw: bool = False
 ) -> dict[str, typing.Any]:
     """Edge Rotate.Rotates edges topologically. Also known as "spin edge" to some people.
-    Simple example: [/] becomes [|] then [].
+    Simple example: [/] becomes [|] then [\].
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param use_ccw: rotate edge counter-clockwise if true, otherwise clockwise
-        :type use_ccw: bool
-        :return: edges: newly spun edges
+        :param edges: Input edges.
+        :param use_ccw: Rotate edge counter-clockwise if true, otherwise clockwise.
+        :return: edges:
+    Newly spun edges.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def rotate_uvs(
     bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = [], use_ccw: bool = False
-):
+) -> None:
     """UV Rotation.Cycle the loop UVs
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param faces: input faces
-    :type faces: list[bmesh.types.BMFace]
-    :param use_ccw: rotate counter-clockwise if true, otherwise clockwise
-    :type use_ccw: bool
+    :param faces: Input faces.
+    :param use_ccw: Rotate counter-clockwise if true, otherwise clockwise.
     """
 
 def scale(
@@ -1547,19 +1275,14 @@ def scale(
     | mathutils.Matrix = mathutils.Matrix.Identity(4),
     verts: list[bmesh.types.BMVert] = [],
     use_shapekey: bool = False,
-):
+) -> None:
     """Scale.Scales vertices by an offset.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param vec: scale factor
-    :type vec: collections.abc.Sequence[float] | mathutils.Vector
-    :param space: matrix to define the space (typically object matrix)
-    :type space: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-    :param verts: input vertices
-    :type verts: list[bmesh.types.BMVert]
+    :param vec: Scale factor.
+    :param space: Matrix to define the space (typically object matrix).
+    :param verts: Input vertices.
     :param use_shapekey: Transform shape keys too.
-    :type use_shapekey: bool
     """
 
 def smooth_laplacian_vert(
@@ -1571,26 +1294,18 @@ def smooth_laplacian_vert(
     use_y: bool = False,
     use_z: bool = False,
     preserve_volume: bool = False,
-):
+) -> None:
     """Vertex Smooth Laplacian.Smooths vertices by using Laplacian smoothing propose by.
     Desbrun, et al. Implicit Fairing of Irregular Meshes using Diffusion and Curvature Flow.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
-        :param lambda_factor: lambda param
-        :type lambda_factor: float
-        :param lambda_border: lambda param in border
-        :type lambda_border: float
-        :param use_x: Smooth object along X axis
-        :type use_x: bool
-        :param use_y: Smooth object along Y axis
-        :type use_y: bool
-        :param use_z: Smooth object along Z axis
-        :type use_z: bool
-        :param preserve_volume: Apply volume preservation after smooth
-        :type preserve_volume: bool
+        :param verts: Input vertices.
+        :param lambda_factor: Lambda parameter.
+        :param lambda_border: Lambda param in border.
+        :param use_x: Smooth object along X axis.
+        :param use_y: Smooth object along Y axis.
+        :param use_z: Smooth object along Z axis.
+        :param preserve_volume: Apply volume preservation after smooth.
     """
 
 def smooth_vert(
@@ -1604,29 +1319,19 @@ def smooth_vert(
     use_axis_x: bool = False,
     use_axis_y: bool = False,
     use_axis_z: bool = False,
-):
+) -> None:
     """Vertex Smooth.Smooths vertices by using a basic vertex averaging scheme.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param verts: input vertices
-    :type verts: list[bmesh.types.BMVert]
-    :param factor: smoothing factor
-    :type factor: float
-    :param mirror_clip_x: set vertices close to the x axis before the operation to 0
-    :type mirror_clip_x: bool
-    :param mirror_clip_y: set vertices close to the y axis before the operation to 0
-    :type mirror_clip_y: bool
-    :param mirror_clip_z: set vertices close to the z axis before the operation to 0
-    :type mirror_clip_z: bool
-    :param clip_dist: clipping threshold for the above three slots
-    :type clip_dist: float
-    :param use_axis_x: smooth vertices along X axis
-    :type use_axis_x: bool
-    :param use_axis_y: smooth vertices along Y axis
-    :type use_axis_y: bool
-    :param use_axis_z: smooth vertices along Z axis
-    :type use_axis_z: bool
+    :param verts: Input vertices.
+    :param factor: Smoothing factor.
+    :param mirror_clip_x: Set vertices close to the x axis before the operation to 0.
+    :param mirror_clip_y: Set vertices close to the y axis before the operation to 0.
+    :param mirror_clip_z: Set vertices close to the z axis before the operation to 0.
+    :param clip_dist: Clipping threshold for the above three slots.
+    :param use_axis_x: Smooth vertices along X axis.
+    :param use_axis_y: Smooth vertices along Y axis.
+    :param use_axis_z: Smooth vertices along Z axis.
     """
 
 def solidify(
@@ -1639,15 +1344,11 @@ def solidify(
     """Solidify.Turns a mesh into a shell with thickness
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param thickness: thickness
-        :type thickness: float
+        :param geom: Input geometry.
+        :param thickness: Thickness.
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def spin(
@@ -1670,31 +1371,20 @@ def spin(
     rotating and possibly translating after each step
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param cent: rotation center
-        :type cent: collections.abc.Sequence[float] | mathutils.Vector
-        :param axis: rotation axis
-        :type axis: collections.abc.Sequence[float] | mathutils.Vector
-        :param dvec: translation delta per step
-        :type dvec: collections.abc.Sequence[float] | mathutils.Vector
-        :param angle: total rotation angle (radians)
-        :type angle: float
-        :param space: matrix to define the space (typically object matrix)
-        :type space: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param steps: number of steps
-        :type steps: int
+        :param geom: Input geometry.
+        :param cent: Rotation center.
+        :param axis: Rotation axis.
+        :param dvec: Translation delta per step.
+        :param angle: Total rotation angle (radians).
+        :param space: Matrix to define the space (typically object matrix).
+        :param steps: Number of steps.
         :param use_merge: Merge first/last when the angle is a full revolution.
-        :type use_merge: bool
         :param use_normal_flip: Create faces with reversed direction.
-        :type use_normal_flip: bool
-        :param use_duplicate: duplicate or extrude?
-        :type use_duplicate: bool
-        :return: geom_last: result of last step
+        :param use_duplicate: Duplicate or extrude?.
+        :return: geom_last:
+    Result of last step.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def split(
@@ -1709,25 +1399,25 @@ def split(
     optionally into a destination mesh.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param geom: input geometry
-        :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param dest: destination bmesh, if None will use current one
-        :type dest: bmesh.types.BMesh | None
-        :param use_only_faces: when enabled. don't duplicate loose verts/edges
-        :type use_only_faces: bool
+        :param geom: Input geometry.
+        :param dest: Destination bmesh, if None will use current one.
+        :param use_only_faces: When enabled. dont duplicate loose verts/edges.
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
 
     boundary_map:
+    Boundary edges from the split geometry that maps edges from the original geometry
+    to the destination edges.
+
+    When the source edges have been deleted, the destination edge will be used
+    for both the key and the value.
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
 
     isovert_map:
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
-        :rtype: dict[str, typing.Any]
     """
 
 def split_edges(
@@ -1739,17 +1429,13 @@ def split_edges(
     """Edge Split.Disconnects faces along input edges.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param verts: optional tag verts, use to have greater control of splits
-        :type verts: list[bmesh.types.BMVert]
-        :param use_verts: use 'verts' for splitting, else just find verts to split from edges
-        :type use_verts: bool
-        :return: edges: old output disconnected edges
+        :param edges: Input edges.
+        :param verts: Optional tag verts, use to have greater control of splits.
+        :param use_verts: Use verts for splitting, else just find verts to split from edges.
+        :return: edges:
+    Old output disconnected edges.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def subdivide_edgering(
@@ -1766,23 +1452,16 @@ def subdivide_edgering(
     """Subdivide Edge-Ring.Take an edge-ring, and subdivide with interpolation options.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input vertices
-        :type edges: list[bmesh.types.BMEdge]
-        :param interp_mode: interpolation method
-        :type interp_mode: typing.Literal['LINEAR','PATH','SURFACE']
-        :param smooth: smoothness factor
-        :type smooth: float
-        :param cuts: number of cuts
-        :type cuts: int
-        :param profile_shape: profile shape type
-        :type profile_shape: typing.Literal['SMOOTH','SPHERE','ROOT','SHARP','LINEAR','INVERSE_SQUARE']
-        :param profile_shape_factor: how much intermediary new edges are shrunk/expanded
-        :type profile_shape_factor: float
-        :return: faces: output faces
+        :param edges: Input vertices.
+        :param interp_mode: Interpolation method.
+        :param smooth: Smoothness factor.
+        :param cuts: Number of cuts.
+        :param profile_shape: Profile shape type.
+        :param profile_shape_factor: How much intermediary new edges are shrunk/expanded.
+        :return: faces:
+    Output faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def subdivide_edges(
@@ -1811,35 +1490,21 @@ def subdivide_edges(
     with options for face patterns, smoothing and randomization.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param smooth: smoothness factor
-        :type smooth: float
-        :param smooth_falloff: smooth falloff type
-        :type smooth_falloff: typing.Literal['SMOOTH','SPHERE','ROOT','SHARP','LINEAR','INVERSE_SQUARE']
-        :param fractal: fractal randomness factor
-        :type fractal: float
-        :param along_normal: apply fractal displacement along normal only
-        :type along_normal: float
-        :param cuts: number of cuts
-        :type cuts: int
-        :param seed: seed for the random number generator
-        :type seed: int
-        :param custom_patterns: uses custom pointers
+        :param edges: Input edges.
+        :param smooth: Smoothness factor.
+        :param smooth_falloff: Smooth falloff type.
+        :param fractal: Fractal randomness factor.
+        :param along_normal: Apply fractal displacement along normal only.
+        :param cuts: Number of cuts.
+        :param seed: Seed for the random number generator.
+        :param custom_patterns: Uses custom pointers.
         :param edge_percents: Undocumented.
-        :param quad_corner_type: quad corner type
-        :type quad_corner_type: typing.Literal['STRAIGHT_CUT','INNER_VERT','PATH','FAN']
-        :param use_grid_fill: fill in fully-selected faces with a grid
-        :type use_grid_fill: bool
-        :param use_single_edge: tessellate the case of one edge selected in a quad or triangle
-        :type use_single_edge: bool
+        :param quad_corner_type: Quad corner type.
+        :param use_grid_fill: Fill in fully-selected faces with a grid.
+        :param use_single_edge: Tessellate the case of one edge selected in a quad or triangle.
         :param use_only_quads: Only subdivide quads (for loop-cut).
-        :type use_only_quads: bool
-        :param use_sphere: for making new primitives only
-        :type use_sphere: bool
-        :param use_smooth_even: maintain even offset when smoothing
-        :type use_smooth_even: bool
+        :param use_sphere: For making new primitives only.
+        :param use_smooth_even: Maintain even offset when smoothing.
         :return: geom_inner:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
@@ -1848,10 +1513,10 @@ def subdivide_edges(
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
 
-    geom: contains all output geometry
+    geom:
+    Contains all output geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def symmetrize(
@@ -1869,19 +1534,13 @@ def symmetrize(
     symmetry are split as needed to enforce symmetry.All new vertices, edges, and faces are added to the "geom.out" slot.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param input: input geometry
-        :type input: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param direction: axis to use
-        :type direction: typing.Literal['-X','-Y','-Z','X','Y','Z']
-        :param dist: minimum distance
-        :type dist: float
+        :param input: Input geometry.
+        :param direction: Axis to use.
+        :param dist: Minimum distance.
         :param use_shapekey: Transform shape keys too.
-        :type use_shapekey: bool
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def transform(
@@ -1892,20 +1551,15 @@ def transform(
     | mathutils.Matrix = mathutils.Matrix.Identity(4),
     verts: list[bmesh.types.BMVert] = [],
     use_shapekey: bool = False,
-):
+) -> None:
     """Transform.Transforms a set of vertices by a matrix. Multiplies
     the vertex coordinates with the matrix.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param matrix: transform matrix
-        :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param space: matrix to define the space (typically object matrix)
-        :type space: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param verts: input vertices
-        :type verts: list[bmesh.types.BMVert]
+        :param matrix: Transform matrix.
+        :param space: Matrix to define the space (typically object matrix).
+        :param verts: Input vertices.
         :param use_shapekey: Transform shape keys too.
-        :type use_shapekey: bool
     """
 
 def translate(
@@ -1915,19 +1569,14 @@ def translate(
     | mathutils.Matrix = mathutils.Matrix.Identity(4),
     verts: list[bmesh.types.BMVert] = [],
     use_shapekey: bool = False,
-):
+) -> None:
     """Translate.Translate vertices by an offset.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param vec: translation offset
-    :type vec: collections.abc.Sequence[float] | mathutils.Vector
-    :param space: matrix to define the space (typically object matrix)
-    :type space: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-    :param verts: input vertices
-    :type verts: list[bmesh.types.BMVert]
+    :param vec: Translation offset.
+    :param space: Matrix to define the space (typically object matrix).
+    :param verts: Input vertices.
     :param use_shapekey: Transform shape keys too.
-    :type use_shapekey: bool
     """
 
 def triangle_fill(
@@ -1940,19 +1589,14 @@ def triangle_fill(
     """Triangle Fill.Fill edges with triangles
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param use_beauty: use best triangulation division
-        :type use_beauty: bool
-        :param use_dissolve: dissolve resulting faces
-        :type use_dissolve: bool
-        :param edges: input edges
-        :type edges: list[bmesh.types.BMEdge]
-        :param normal: optionally pass the fill normal to use
-        :type normal: collections.abc.Sequence[float] | mathutils.Vector
-        :return: geom: new faces and edges
+        :param use_beauty: Use best triangulation division.
+        :param use_dissolve: Dissolve resulting faces.
+        :param edges: Input edges.
+        :param normal: Optionally pass the fill normal to use.
+        :return: geom:
+    New faces and edges.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def triangulate(
@@ -1966,13 +1610,9 @@ def triangulate(
     """Triangulate.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param quad_method: method for splitting the quads into triangles
-        :type quad_method: typing.Literal['BEAUTY','FIXED','ALTERNATE','SHORT_EDGE','LONG_EDGE']
-        :param ngon_method: method for splitting the polygons into triangles
-        :type ngon_method: typing.Literal['BEAUTY','EAR_CLIP']
+        :param faces: Input faces.
+        :param quad_method: Method for splitting the quads into triangles.
+        :param ngon_method: Method for splitting the polygons into triangles.
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -1985,33 +1625,31 @@ def triangulate(
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
 
-    face_map_double: duplicate faces
+    face_map_double:
+    Duplicate faces.
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
-        :rtype: dict[str, typing.Any]
     """
 
 def unsubdivide(
     bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = [], iterations: int = 0
-):
+) -> None:
     """Un-Subdivide.Reduce detail in geometry containing grids.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
-    :param verts: input vertices
-    :type verts: list[bmesh.types.BMVert]
-    :param iterations: number of times to unsubdivide
-    :type iterations: int
+    :param verts: Input vertices.
+    :param iterations: Number of times to unsubdivide.
     """
 
-def weld_verts(bm: bmesh.types.BMesh, targetmap={}):
+def weld_verts(bm: bmesh.types.BMesh, targetmap={}, use_centroid: bool = False) -> None:
     """Weld Verts.Welds verts together (kind-of like remove doubles, merge, etc, all of which
     use or will use this BMOP). You pass in mappings from vertices to the vertices
     they weld with.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param targetmap: maps welded vertices to verts they should weld to
+        :param targetmap: Maps welded vertices to verts they should weld to.
+        :param use_centroid: Merged vertices to their centroid position,
+    otherwise the position of the target vertex is used.
     """
 
 def wireframe(
@@ -2030,29 +1668,18 @@ def wireframe(
     """Wire Frame.Makes a wire-frame copy of faces.
 
         :param bm: The bmesh to operate on.
-        :type bm: bmesh.types.BMesh
-        :param faces: input faces
-        :type faces: list[bmesh.types.BMFace]
-        :param thickness: thickness
-        :type thickness: float
-        :param offset: offset the thickness from the center
-        :type offset: float
-        :param use_replace: remove original geometry
-        :type use_replace: bool
-        :param use_boundary: inset face boundaries
-        :type use_boundary: bool
-        :param use_even_offset: scale the offset to give more even thickness
-        :type use_even_offset: bool
-        :param use_crease: crease hub edges for improved subdivision surface
-        :type use_crease: bool
-        :param crease_weight: the mean crease weight for resulting edges
-        :type crease_weight: float
-        :param use_relative_offset: scale the offset by surrounding geometry
-        :type use_relative_offset: bool
-        :param material_offset: offset material index of generated faces
-        :type material_offset: int
-        :return: faces: output faces
+        :param faces: Input faces.
+        :param thickness: Thickness.
+        :param offset: Offset the thickness from the center.
+        :param use_replace: Remove original geometry.
+        :param use_boundary: Inset face boundaries.
+        :param use_even_offset: Scale the offset to give more even thickness.
+        :param use_crease: Crease hub edges for improved subdivision surface.
+        :param crease_weight: The mean crease weight for resulting edges.
+        :param use_relative_offset: Scale the offset by surrounding geometry.
+        :param material_offset: Offset material index of generated faces.
+        :return: faces:
+    Output faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """