fake-bpy-module 20250828__py3-none-any.whl → 20260118__py3-none-any.whl

bmesh/ops/__init__.pyi

@@ -29,9 +29,7 @@ def average_vert_facedata(
     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]
     """
 
 def beautify_fill(
@@ -44,20 +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.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def bevel(
@@ -89,45 +81,25 @@ 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 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 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 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.
 
@@ -142,7 +114,6 @@ def bevel(
     Output verts.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def bisect_edges(
@@ -155,17 +126,13 @@ def bisect_edges(
     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 edge_percents: Undocumented.
         :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(
@@ -183,21 +150,13 @@ 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).
 
@@ -207,7 +166,6 @@ def bisect_plane(
     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(
@@ -216,11 +174,8 @@ def bmesh_to_mesh(
     """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
     """
 
 def bridge_loops(
@@ -235,19 +190,12 @@ 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 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.
 
@@ -257,7 +205,6 @@ def bridge_loops(
     New edges.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def collapse(
@@ -266,20 +213,15 @@ def collapse(
     """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
     """
 
 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]
     """
 
 def connect_vert_pair(
@@ -291,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]
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def connect_verts(
@@ -313,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
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def connect_verts_concave(
@@ -332,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]
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -342,7 +272,6 @@ def connect_verts_concave(
     faces:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def connect_verts_nonplanar(
@@ -351,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]
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -363,7 +289,6 @@ def connect_verts_nonplanar(
     faces:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def contextual_create(
@@ -380,13 +305,9 @@ 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).
 
@@ -396,7 +317,6 @@ def contextual_create(
     Newly-made edge(s).
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def convex_hull(
@@ -415,11 +335,8 @@ def convex_hull(
     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
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
@@ -435,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(
@@ -451,24 +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 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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_cone(
@@ -486,28 +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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_cube(
@@ -520,18 +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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_grid(
@@ -546,22 +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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_icosphere(
@@ -575,20 +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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_monkey(
@@ -600,16 +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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_uvsphere(
@@ -624,22 +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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def create_vert(
@@ -650,14 +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.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def delete(
@@ -678,11 +544,8 @@ def delete(
     """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']
     """
 
 def dissolve_degenerate(
@@ -691,11 +554,8 @@ def dissolve_degenerate(
     """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]
     """
 
 def dissolve_edges(
@@ -708,20 +568,14 @@ def dissolve_edges(
     """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 angle_threshold: Do not dissolve verts between 2 edges when their angle exceeds this threshold.
     Disabled by default.
-        :type angle_threshold: float
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def dissolve_faces(
@@ -730,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
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def dissolve_limit(
@@ -752,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.
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def dissolve_verts(
@@ -777,13 +621,9 @@ def dissolve_verts(
     """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
     """
 
 def duplicate(
@@ -799,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 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`)
@@ -837,7 +672,6 @@ def duplicate(
     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(
@@ -849,18 +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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def edgenet_fill(
@@ -873,20 +702,14 @@ 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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def edgenet_prepare(
@@ -896,14 +719,11 @@ def edgenet_prepare(
     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.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def extrude_discrete_faces(
@@ -915,18 +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 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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def extrude_edge_only(
@@ -939,18 +754,13 @@ def extrude_edge_only(
     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 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.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def extrude_face_region(
@@ -964,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 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 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(
@@ -996,11 +800,8 @@ 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.
 
@@ -1010,7 +811,6 @@ def extrude_vert_indiv(
     Output vertices.
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: dict[str, typing.Any]
     """
 
 def face_attribute_fill(
@@ -1022,18 +822,13 @@ 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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def find_doubles(
@@ -1048,19 +843,13 @@ 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 use_connected: Limit the search for doubles by connected geometry.
-        :type use_connected: bool
         :param dist: Maximum distance.
-        :type dist: float
         :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(
@@ -1069,9 +858,7 @@ def flip_quad_tessellation(
     """Flip Quad TessellationFlip the tessellation direction of the selected quads.
 
     :param bm: The bmesh to operate on.
-    :type bm: bmesh.types.BMesh
     :param faces: Input faces.
-    :type faces: list[bmesh.types.BMFace]
     """
 
 def grid_fill(
@@ -1084,20 +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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def holes_fill(
@@ -1106,16 +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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def inset_individual(
@@ -1130,24 +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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def inset_region(
@@ -1166,32 +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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def join_triangles(
@@ -1213,36 +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 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 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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def mesh_to_bmesh(
@@ -1255,13 +998,9 @@ def mesh_to_bmesh(
     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
     """
 
 def mirror(
@@ -1283,28 +1022,18 @@ 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 use_shapekey: Transform shape keys too.
-        :type use_shapekey: bool
         :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(
@@ -1314,11 +1043,8 @@ def object_load_bmesh(
     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
     """
 
 def offset_edgeloops(
@@ -1329,16 +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.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def planar_faces(
@@ -1350,18 +1072,13 @@ 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 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.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def pointmerge(
@@ -1372,11 +1089,8 @@ def pointmerge(
     """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 merge_co: Position to merge at.
-    :type merge_co: collections.abc.Sequence[float] | mathutils.Vector
     """
 
 def pointmerge_facedata(
@@ -1387,11 +1101,8 @@ def pointmerge_facedata(
     """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
     """
 
 def poke(
@@ -1404,15 +1115,10 @@ 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.
 
@@ -1422,7 +1128,6 @@ def poke(
     Output faces.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def recalc_face_normals(
@@ -1431,9 +1136,7 @@ def recalc_face_normals(
     """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]
     """
 
 def region_extend(
@@ -1451,20 +1154,14 @@ 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.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def remove_doubles(
@@ -1477,13 +1174,9 @@ def remove_doubles(
     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 use_connected: Limit the search for doubles by connected geometry.
-        :type use_connected: bool
         :param dist: Minimum distance.
-        :type dist: float
     """
 
 def reverse_colors(
@@ -1492,11 +1185,8 @@ def reverse_colors(
     """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
     """
 
 def reverse_faces(
@@ -1508,20 +1198,15 @@ def reverse_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
     """
 
 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]
     """
 
 def rotate(
@@ -1537,17 +1222,11 @@ def rotate(
     """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 use_shapekey: Transform shape keys too.
-    :type use_shapekey: bool
     """
 
 def rotate_colors(
@@ -1559,13 +1238,9 @@ def rotate_colors(
     """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
     """
 
 def rotate_edges(
@@ -1575,16 +1250,12 @@ def rotate_edges(
     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.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def rotate_uvs(
@@ -1593,11 +1264,8 @@ def rotate_uvs(
     """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
     """
 
 def scale(
@@ -1611,15 +1279,10 @@ def scale(
     """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 use_shapekey: Transform shape keys too.
-    :type use_shapekey: bool
     """
 
 def smooth_laplacian_vert(
@@ -1636,21 +1299,13 @@ def smooth_laplacian_vert(
     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 parameter.
-        :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
     """
 
 def smooth_vert(
@@ -1668,25 +1323,15 @@ def smooth_vert(
     """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
     """
 
 def solidify(
@@ -1699,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
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def spin(
@@ -1730,32 +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 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.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def split(
@@ -1770,13 +1399,9 @@ 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. dont duplicate loose verts/edges.
-        :type use_only_faces: bool
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
@@ -1793,7 +1418,6 @@ def split(
     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(
@@ -1805,18 +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.
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: dict[str, typing.Any]
     """
 
 def subdivide_edgering(
@@ -1833,24 +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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def subdivide_edges(
@@ -1879,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 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 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
         :return: geom_inner:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
@@ -1920,7 +1517,6 @@ def subdivide_edges(
     Contains all output geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def symmetrize(
@@ -1938,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 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(
@@ -1966,15 +1556,10 @@ def transform(
     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 use_shapekey: Transform shape keys too.
-        :type use_shapekey: bool
     """
 
 def translate(
@@ -1988,15 +1573,10 @@ def translate(
     """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 use_shapekey: Transform shape keys too.
-    :type use_shapekey: bool
     """
 
 def triangle_fill(
@@ -2009,20 +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.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """
 
 def triangulate(
@@ -2036,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']
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -2059,7 +1629,6 @@ def triangulate(
     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(
@@ -2068,21 +1637,19 @@ def unsubdivide(
     """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
     """
 
-def weld_verts(bm: bmesh.types.BMesh, targetmap={}) -> None:
+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 use_centroid: Merged vertices to their centroid position,
+    otherwise the position of the target vertex is used.
     """
 
 def wireframe(
@@ -2101,30 +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.
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: dict[str, typing.Any]
     """