fake-bpy-module 20250604__py3-none-any.whl → 20250606__py3-none-any.whl

bmesh/ops/__init__.pyi

@@ -21,14 +21,16 @@ 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 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
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
     """
 
@@ -43,15 +45,15 @@ def beautify_fill(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param edges: edges that can be flipped
+        :param edges: Edges that can be flipped.
         :type edges: list[bmesh.types.BMEdge]
-        :param use_restrict_tag: restrict edge rotation to mixed tagged vertices
+        :param use_restrict_tag: Restrict edge rotation to mixed tagged vertices.
         :type use_restrict_tag: bool
-        :param method: method to define what is beautiful
+        :param method: Method to define what is beautiful.
         :type method: typing.Literal['AREA','ANGLE']
-        :return: geom: new flipped faces and edges
+        :return: geom: New flipped faces and edges.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -87,53 +89,53 @@ def bevel(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input edges and vertices
+        :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
+        :param offset: Amount to offset beveled edge.
         :type offset: float
-        :param offset_type: how to measure the offset
+        :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
+        :param segments: Number of segments in bevel.
         :type segments: int
-        :param profile: profile shape, 0->1 (.5=>round)
+        :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
+        :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
+        :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
+        :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
+        :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
+        :param mark_sharp: Extend edge data to allow sharp edges to run across bevels.
         :type mark_sharp: bool
-        :param harden_normals: harden normals
+        :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
+        :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
+        :param miter_outer: Outer miter kind.
         :type miter_outer: typing.Literal['SHARP','PATCH','ARC']
-        :param miter_inner: outer miter kind
+        :param miter_inner: Outer miter kind.
         :type miter_inner: typing.Literal['SHARP','PATCH','ARC']
-        :param spread: amount to offset beveled edge
+        :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
+        :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]
@@ -150,12 +152,12 @@ def bisect_edges(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param cuts: number of cuts
+        :param cuts: Number of cuts.
         :type cuts: int
         :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]
@@ -177,25 +179,25 @@ def bisect_plane(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry
+        :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
+        :param dist: Minimum distance when testing if a vert is exactly on the plane.
         :type dist: float
-        :param plane_co: point on the plane
+        :param plane_co: Point on the plane.
         :type plane_co: collections.abc.Sequence[float] | mathutils.Vector
-        :param plane_no: direction of the plane
+        :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
+        :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
+        :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
+        :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)
+        :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]
@@ -203,14 +205,14 @@ def bisect_plane(
 
 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
+    :param mesh: Pointer to a mesh structure to fill in.
     :type mesh: bpy.types.Mesh
-    :param object: pointer to an object structure
+    :param object: Pointer to an object structure.
     :type object: bpy.types.Object
     """
 
@@ -227,23 +229,23 @@ def bridge_loops(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :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
+        :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
+        :param twist_offset: Twist offset for closed loops.
         :type twist_offset: int
-        :return: faces: new faces
+        :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]
@@ -251,23 +253,23 @@ def bridge_loops(
 
 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
+    :param edges: Input edges.
     :type edges: list[bmesh.types.BMEdge]
-    :param uvs: also collapse UVs and such
+    :param uvs: Also collapse UVs and such.
     :type uvs: bool
     """
 
-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
+    :param edges: Input edges.
     :type edges: list[bmesh.types.BMEdge]
     """
 
@@ -281,11 +283,11 @@ def connect_vert_pair(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param verts: input vertices
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
-        :param verts_exclude: input vertices to explicitly exclude from connecting
+        :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
+        :param faces_exclude: Input faces to explicitly exclude from connecting.
         :type faces_exclude: list[bmesh.types.BMFace]
         :return: edges:
 
@@ -303,11 +305,11 @@ def connect_verts(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param verts: input vertices
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
-        :param faces_exclude: input faces to explicitly exclude from connecting
+        :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
+        :param check_degenerate: Prevent splits with overlaps & intersections.
         :type check_degenerate: bool
         :return: edges:
 
@@ -322,7 +324,7 @@ def connect_verts_concave(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
         :return: edges:
 
@@ -341,9 +343,9 @@ def connect_verts_nonplanar(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param angle_limit: total rotation angle (radians)
+        :param angle_limit: Total rotation angle (radians).
         :type angle_limit: float
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
         :return: edges:
 
@@ -370,17 +372,17 @@ def contextual_create(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry.
+        :param geom: Input geometry.
         :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param mat_nr: material to use
+        :param mat_nr: Material to use.
         :type mat_nr: int
-        :param use_smooth: smooth to use
+        :param use_smooth: Smooth to use.
         :type use_smooth: bool
-        :return: faces: newly-made face(s)
+        :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]
@@ -403,9 +405,9 @@ def convex_hull(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param input: input geometry
+        :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
+        :param use_existing_faces: Skip hull triangles that are covered by a pre-existing face.
         :type use_existing_faces: bool
         :return: geom:
 
@@ -439,19 +441,19 @@ def create_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
+        :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
+        :param cap_tris: Fill ends with triangles instead of ngons.
         :type cap_tris: bool
-        :param segments: number of vertices in the circle
+        :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
+        :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
+        :param calc_uvs: Calculate default UVs.
         :type calc_uvs: bool
-        :return: verts: output verts
+        :return: verts: Output verts.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -473,23 +475,23 @@ def create_cone(
 
         :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
+        :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
+        :param cap_tris: Fill ends with triangles instead of ngons.
         :type cap_tris: bool
-        :param segments: number of vertices in the base circle
+        :param segments: Number of vertices in the base circle.
         :type segments: int
-        :param radius1: radius of one end
+        :param radius1: Radius of one end.
         :type radius1: float
-        :param radius2: radius of the opposite
+        :param radius2: Radius of the opposite.
         :type radius2: float
-        :param depth: distance between ends
+        :param depth: Distance between ends.
         :type depth: float
-        :param matrix: matrix to multiply the new geometry with
+        :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
+        :param calc_uvs: Calculate default UVs.
         :type calc_uvs: bool
-        :return: verts: output verts
+        :return: verts: Output verts.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -506,13 +508,13 @@ def create_cube(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param size: size of the cube
+        :param size: Size of the cube.
         :type size: float
-        :param matrix: matrix to multiply the new geometry with
+        :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
+        :param calc_uvs: Calculate default UVs.
         :type calc_uvs: bool
-        :return: verts: output verts
+        :return: verts: Output verts.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -531,17 +533,17 @@ def create_grid(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param x_segments: number of x segments
+        :param x_segments: Number of x segments.
         :type x_segments: int
-        :param y_segments: number of y segments
+        :param y_segments: Number of y segments.
         :type y_segments: int
-        :param size: size of the grid
+        :param size: Size of the grid.
         :type size: float
-        :param matrix: matrix to multiply the new geometry with
+        :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
+        :param calc_uvs: Calculate default UVs.
         :type calc_uvs: bool
-        :return: verts: output verts
+        :return: verts: Output verts.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -559,15 +561,15 @@ def create_icosphere(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param subdivisions: how many times to recursively subdivide the sphere
+        :param subdivisions: How many times to recursively subdivide the sphere.
         :type subdivisions: int
-        :param radius: radius
+        :param radius: Radius.
         :type radius: float
-        :param matrix: matrix to multiply the new geometry with
+        :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
+        :param calc_uvs: Calculate default UVs.
         :type calc_uvs: bool
-        :return: verts: output verts
+        :return: verts: Output verts.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -583,11 +585,11 @@ def create_monkey(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param matrix: matrix to multiply the new geometry with
+        :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
+        :param calc_uvs: Calculate default UVs.
         :type calc_uvs: bool
-        :return: verts: output verts
+        :return: verts: Output verts.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -606,17 +608,17 @@ def create_uvsphere(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param u_segments: number of u segments
+        :param u_segments: Number of u segments.
         :type u_segments: int
-        :param v_segments: number of v segment
+        :param v_segments: Number of v segment.
         :type v_segments: int
-        :param radius: radius
+        :param radius: Radius.
         :type radius: float
-        :param matrix: matrix to multiply the new geometry with
+        :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
+        :param calc_uvs: Calculate default UVs.
         :type calc_uvs: bool
-        :return: verts: output verts
+        :return: verts: Output verts.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -631,9 +633,9 @@ def create_vert(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param co: the coordinate of the new vert
+        :param co: The coordinate of the new vert.
         :type co: collections.abc.Sequence[float] | mathutils.Vector
-        :return: vert: the new vert
+        :return: vert: The new vert.
 
     type list of (`bmesh.types.BMVert`)
         :rtype: dict[str, typing.Any]
@@ -653,27 +655,27 @@ 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
+    :param geom: Input geometry.
     :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-    :param context: geometry types to delete
+    :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(
     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
+    :param dist: Maximum distance to consider degenerate.
     :type dist: float
-    :param edges: input edges
+    :param edges: Input edges.
     :type edges: list[bmesh.types.BMEdge]
     """
 
@@ -682,17 +684,20 @@ 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
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param use_verts: dissolve verts left between only 2 edges.
+        :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
+        :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.
+        :type angle_threshold: float
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
@@ -706,9 +711,9 @@ def dissolve_faces(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param use_verts: dissolve verts left between only 2 edges.
+        :param use_verts: Dissolve verts left between only 2 edges.
         :type use_verts: bool
         :return: region:
 
@@ -728,15 +733,15 @@ def dissolve_limit(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param angle_limit: total rotation angle (radians)
+        :param angle_limit: Total rotation angle (radians).
         :type angle_limit: float
-        :param use_dissolve_boundaries: dissolve all vertices in between face boundaries
+        :param use_dissolve_boundaries: Dissolve all vertices in between face boundaries.
         :type use_dissolve_boundaries: bool
-        :param verts: input vertices
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param delimit: delimit dissolve operation
+        :param delimit: Delimit dissolve operation.
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
@@ -748,16 +753,16 @@ 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
+    :param verts: Input vertices.
     :type verts: list[bmesh.types.BMVert]
-    :param use_face_split: split off face corners to maintain surrounding geometry
+    :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
+    :param use_boundary_tear: Split off face corners instead of merging faces.
     :type use_boundary_tear: bool
     """
 
@@ -775,9 +780,9 @@ def duplicate(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry
+        :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
+        :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
@@ -823,13 +828,13 @@ def edgeloop_fill(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param mat_nr: material to use
+        :param mat_nr: Material to use.
         :type mat_nr: int
-        :param use_smooth: smooth state to use
+        :param use_smooth: Smooth state to use.
         :type use_smooth: bool
-        :return: faces: new faces
+        :return: faces: New faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -846,15 +851,15 @@ def edgenet_fill(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param mat_nr: material to use
+        :param mat_nr: Material to use.
         :type mat_nr: int
-        :param use_smooth: smooth state to use
+        :param use_smooth: Smooth state to use.
         :type use_smooth: bool
-        :param sides: number of sides
+        :param sides: Number of sides.
         :type sides: int
-        :return: faces: new faces
+        :return: faces: New faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -868,9 +873,9 @@ def edgenet_prepare(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :return: edges: new edges
+        :return: edges: New edges.
 
     type list of (`bmesh.types.BMEdge`)
         :rtype: dict[str, typing.Any]
@@ -886,13 +891,13 @@ def extrude_discrete_faces(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :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
+        :param use_select_history: Pass to duplicate.
         :type use_select_history: bool
-        :return: faces: output faces
+        :return: faces: Output faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -909,13 +914,13 @@ def extrude_edge_only(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input vertices
+        :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
+        :param use_select_history: Pass to duplicate.
         :type use_select_history: bool
-        :return: geom: output geometry
+        :return: geom: Output geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -937,10 +942,10 @@ def extrude_face_region(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: edges and faces
+        :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).
+        :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
@@ -948,7 +953,7 @@ def extrude_face_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
+        :param use_select_history: Pass to duplicate.
         :type use_select_history: bool
         :return: geom:
 
@@ -965,15 +970,15 @@ def extrude_vert_indiv(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param verts: input vertices
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
-        :param use_select_history: pass to duplicate
+        :param use_select_history: Pass to duplicate.
         :type use_select_history: bool
-        :return: edges: output wire edges
+        :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]
@@ -989,13 +994,13 @@ def face_attribute_fill(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param use_normals: copy face winding
+        :param use_normals: Copy face winding.
         :type use_normals: bool
-        :param use_data: copy face data
+        :param use_data: Copy face data.
         :type use_data: bool
-        :return: faces_fail: faces that could not be handled
+        :return: faces_fail: Faces that could not be handled.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1013,11 +1018,11 @@ def find_doubles(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param verts: input vertices
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
-        :param keep_verts: list of verts to keep
+        :param keep_verts: List of verts to keep.
         :type keep_verts: list[bmesh.types.BMVert]
-        :param dist: maximum distance
+        :param dist: Maximum distance.
         :type dist: float
         :return: targetmap:
 
@@ -1025,12 +1030,14 @@ def find_doubles(
         :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.
+    :param faces: Input faces.
     :type faces: list[bmesh.types.BMFace]
     """
 
@@ -1045,15 +1052,15 @@ def grid_fill(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param mat_nr: material to use
+        :param mat_nr: Material to use.
         :type mat_nr: int
-        :param use_smooth: smooth state to use
+        :param use_smooth: Smooth state to use.
         :type use_smooth: bool
-        :param use_interp_simple: use simple interpolation
+        :param use_interp_simple: Use simple interpolation.
         :type use_interp_simple: bool
-        :return: faces: new faces
+        :return: faces: New faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1066,11 +1073,11 @@ def holes_fill(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param sides: number of face sides to fill
+        :param sides: Number of face sides to fill.
         :type sides: int
-        :return: faces: new faces
+        :return: faces: New faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1089,19 +1096,19 @@ def inset_individual(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param thickness: thickness
+        :param thickness: Thickness.
         :type thickness: float
-        :param depth: depth
+        :param depth: Depth.
         :type depth: float
-        :param use_even_offset: scale the offset to give more even thickness
+        :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
+        :param use_interpolate: Blend face data across the inset.
         :type use_interpolate: bool
-        :param use_relative_offset: scale the offset by surrounding geometry
+        :param use_relative_offset: Scale the offset by surrounding geometry.
         :type use_relative_offset: bool
-        :return: faces: output faces
+        :return: faces: Output faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1124,27 +1131,27 @@ def inset_region(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param faces_exclude: input faces to explicitly exclude from inset
+        :param faces_exclude: Input faces to explicitly exclude from inset.
         :type faces_exclude: list[bmesh.types.BMFace]
-        :param use_boundary: inset face boundaries
+        :param use_boundary: Inset face boundaries.
         :type use_boundary: bool
-        :param use_even_offset: scale the offset to give more even thickness
+        :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
+        :param use_interpolate: Blend face data across the inset.
         :type use_interpolate: bool
-        :param use_relative_offset: scale the offset by surrounding geometry
+        :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
+        :param use_edge_rail: Inset the region along existing edges.
         :type use_edge_rail: bool
-        :param thickness: thickness
+        :param thickness: Thickness.
         :type thickness: float
-        :param depth: depth
+        :param depth: Depth.
         :type depth: float
-        :param use_outset: outset rather than inset
+        :param use_outset: Outset rather than inset.
         :type use_outset: bool
-        :return: faces: output faces
+        :return: faces: Output faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1170,7 +1177,7 @@ def join_triangles(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input geometry.
+        :param faces: Input geometry.
         :type faces: list[bmesh.types.BMFace]
         :param cmp_seam: Compare seam
         :type cmp_seam: bool
@@ -1178,9 +1185,9 @@ def join_triangles(
         :type cmp_sharp: bool
         :param cmp_uvs: Compare UVs
         :type cmp_uvs: bool
-        :param cmp_vcols: compare VCols
+        :param cmp_vcols: Compare VCols.
         :type cmp_vcols: bool
-        :param cmp_materials: compare materials
+        :param cmp_materials: Compare materials.
         :type cmp_materials: bool
         :param angle_face_threshold: Undocumented.
         :type angle_face_threshold: float
@@ -1194,7 +1201,7 @@ def join_triangles(
         :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]
@@ -1205,17 +1212,17 @@ def mesh_to_bmesh(
     mesh: bpy.types.Mesh,
     object: bpy.types.Object,
     use_shapekey: bool = False,
-):
+) -> None:
     """Mesh to BMesh.Load the contents of a mesh into the bmesh. this BMOP is private, it's
-    reserved exclusively for entering editmode.
+    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
+        :param mesh: Pointer to a Mesh structure.
         :type mesh: bpy.types.Mesh
-        :param object: pointer to an Object structure
+        :param object: Pointer to an Object structure.
         :type object: bpy.types.Object
-        :param use_shapekey: load active shapekey coordinates into verts
+        :param use_shapekey: Load active shapekey coordinates into verts.
         :type use_shapekey: bool
     """
 
@@ -1239,23 +1246,23 @@ def mirror(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry
+        :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
+        :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.
+        :param merge_dist: Maximum distance for merging. does no merging if 0.
         :type merge_dist: float
-        :param axis: the axis to use.
+        :param axis: The axis to use.
         :type axis: typing.Literal['X','Y','Z']
-        :param mirror_u: mirror UVs across the u axis
+        :param mirror_u: Mirror UVs across the u axis.
         :type mirror_u: bool
-        :param mirror_v: mirror UVs across the v axis
+        :param mirror_v: Mirror UVs across the v axis.
         :type mirror_v: bool
-        :param mirror_udim: mirror UVs in each tile
+        :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
+        :return: geom: Output geometry, mirrored.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1263,15 +1270,15 @@ def mirror(
 
 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
+        :param scene: Pointer to an scene structure.
         :type scene: bpy.types.Scene
-        :param object: pointer to an object structure
+        :param object: Pointer to an object structure.
         :type object: bpy.types.Object
     """
 
@@ -1284,11 +1291,11 @@ def offset_edgeloops(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param use_cap_endpoint: extend loop around end-points
+        :param use_cap_endpoint: Extend loop around end-points.
         :type use_cap_endpoint: bool
-        :return: edges: output edges
+        :return: edges: Output edges.
 
     type list of (`bmesh.types.BMEdge`)
         :rtype: dict[str, typing.Any]
@@ -1304,13 +1311,13 @@ def planar_faces(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input geometry.
+        :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.
+        :return: geom: Output slot, computed boundary geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1320,12 +1327,12 @@ 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).
+    :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
@@ -1335,14 +1342,14 @@ 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
+    :param verts: Input vertices.
     :type verts: list[bmesh.types.BMVert]
-    :param vert_snap: snap vertex
+    :param vert_snap: Snap vertex.
     :type vert_snap: bmesh.types.BMVert | None
     """
 
@@ -1357,30 +1364,32 @@ def poke(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param offset: center vertex offset along normal
+        :param offset: Center vertex offset along normal.
         :type offset: float
-        :param center_mode: calculation mode for center vertex
+        :param center_mode: Calculation mode for center vertex.
         :type center_mode: typing.Literal['MEAN_WEIGHTED','MEAN','BOUNDS']
-        :param use_relative_offset: apply offset
+        :param use_relative_offset: Apply offset.
         :type use_relative_offset: bool
-        :return: verts: output verts
+        :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
+    :param faces: Input faces.
     :type faces: list[bmesh.types.BMFace]
     """
 
@@ -1400,15 +1409,15 @@ def region_extend(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry
+        :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.
+        :param use_contract: Find boundary inside the regions, not outside.
         :type use_contract: bool
-        :param use_faces: extend from faces instead of edges
+        :param use_faces: Extend from faces instead of edges.
         :type use_faces: bool
-        :param use_face_step: step over connected faces
+        :param use_face_step: Step over connected faces.
         :type use_face_step: bool
-        :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]
@@ -1416,28 +1425,28 @@ def region_extend(
 
 def remove_doubles(
     bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = [], 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
+        :param verts: Input verts.
         :type verts: list[bmesh.types.BMVert]
-        :param dist: minimum distance
+        :param dist: Minimum distance.
         :type dist: float
     """
 
 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
+    :param faces: Input faces.
     :type faces: list[bmesh.types.BMFace]
-    :param color_index: index into color attribute list
+    :param color_index: Index into color attribute list.
     :type color_index: int
     """
 
@@ -1445,24 +1454,24 @@ 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
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param flip_multires: maintain multi-res offset
+        :param flip_multires: Maintain multi-res offset.
         :type flip_multires: bool
     """
 
-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
+    :param faces: Input faces.
     :type faces: list[bmesh.types.BMFace]
     """
 
@@ -1475,18 +1484,18 @@ 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
+    :param cent: Center of rotation.
     :type cent: collections.abc.Sequence[float] | mathutils.Vector
-    :param matrix: matrix defining rotation
+    :param matrix: Matrix defining rotation.
     :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-    :param verts: input vertices
+    :param verts: Input vertices.
     :type verts: list[bmesh.types.BMVert]
-    :param space: matrix to define the space (typically object matrix)
+    :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
@@ -1497,16 +1506,16 @@ 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
+    :param faces: Input faces.
     :type faces: list[bmesh.types.BMFace]
-    :param use_ccw: rotate counter-clockwise if true, otherwise clockwise
+    :param use_ccw: Rotate counter-clockwise if true, otherwise clockwise.
     :type use_ccw: bool
-    :param color_index: index into color attribute list
+    :param color_index: Index into color attribute list.
     :type color_index: int
     """
 
@@ -1514,15 +1523,15 @@ 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
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param use_ccw: rotate edge counter-clockwise if true, otherwise clockwise
+        :param use_ccw: Rotate edge counter-clockwise if true, otherwise clockwise.
         :type use_ccw: bool
-        :return: edges: newly spun edges
+        :return: edges: Newly spun edges.
 
     type list of (`bmesh.types.BMEdge`)
         :rtype: dict[str, typing.Any]
@@ -1530,14 +1539,14 @@ def rotate_edges(
 
 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
+    :param faces: Input faces.
     :type faces: list[bmesh.types.BMFace]
-    :param use_ccw: rotate counter-clockwise if true, otherwise clockwise
+    :param use_ccw: Rotate counter-clockwise if true, otherwise clockwise.
     :type use_ccw: bool
     """
 
@@ -1548,16 +1557,16 @@ 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
+    :param vec: Scale factor.
     :type vec: collections.abc.Sequence[float] | mathutils.Vector
-    :param space: matrix to define the space (typically object 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
+    :param verts: Input vertices.
     :type verts: list[bmesh.types.BMVert]
     :param use_shapekey: Transform shape keys too.
     :type use_shapekey: bool
@@ -1572,25 +1581,25 @@ 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
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
-        :param lambda_factor: lambda param
+        :param lambda_factor: Lambda parameter.
         :type lambda_factor: float
-        :param lambda_border: lambda param in border
+        :param lambda_border: Lambda param in border.
         :type lambda_border: float
-        :param use_x: Smooth object along X axis
+        :param use_x: Smooth object along X axis.
         :type use_x: bool
-        :param use_y: Smooth object along Y axis
+        :param use_y: Smooth object along Y axis.
         :type use_y: bool
-        :param use_z: Smooth object along Z axis
+        :param use_z: Smooth object along Z axis.
         :type use_z: bool
-        :param preserve_volume: Apply volume preservation after smooth
+        :param preserve_volume: Apply volume preservation after smooth.
         :type preserve_volume: bool
     """
 
@@ -1605,28 +1614,28 @@ 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
+    :param verts: Input vertices.
     :type verts: list[bmesh.types.BMVert]
-    :param factor: smoothing factor
+    :param factor: Smoothing factor.
     :type factor: float
-    :param mirror_clip_x: set vertices close to the x axis before the operation to 0
+    :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
+    :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
+    :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
+    :param clip_dist: Clipping threshold for the above three slots.
     :type clip_dist: float
-    :param use_axis_x: smooth vertices along X axis
+    :param use_axis_x: Smooth vertices along X axis.
     :type use_axis_x: bool
-    :param use_axis_y: smooth vertices along Y axis
+    :param use_axis_y: Smooth vertices along Y axis.
     :type use_axis_y: bool
-    :param use_axis_z: smooth vertices along Z axis
+    :param use_axis_z: Smooth vertices along Z axis.
     :type use_axis_z: bool
     """
 
@@ -1641,9 +1650,9 @@ def solidify(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry
+        :param geom: Input geometry.
         :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param thickness: thickness
+        :param thickness: Thickness.
         :type thickness: float
         :return: geom:
 
@@ -1672,27 +1681,27 @@ def spin(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry
+        :param geom: Input geometry.
         :type geom: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param cent: rotation center
+        :param cent: Rotation center.
         :type cent: collections.abc.Sequence[float] | mathutils.Vector
-        :param axis: rotation axis
+        :param axis: Rotation axis.
         :type axis: collections.abc.Sequence[float] | mathutils.Vector
-        :param dvec: translation delta per step
+        :param dvec: Translation delta per step.
         :type dvec: collections.abc.Sequence[float] | mathutils.Vector
-        :param angle: total rotation angle (radians)
+        :param angle: Total rotation angle (radians).
         :type angle: float
-        :param space: matrix to define the space (typically object matrix)
+        :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
+        :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?
+        :param use_duplicate: Duplicate or extrude?.
         :type use_duplicate: bool
-        :return: geom_last: result of last step
+        :return: geom_last: Result of last step.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1711,11 +1720,11 @@ def split(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param geom: input geometry
+        :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
+        :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
+        :param use_only_faces: When enabled. don't duplicate loose verts/edges.
         :type use_only_faces: bool
         :return: geom:
 
@@ -1741,13 +1750,13 @@ def split_edges(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param verts: optional tag verts, use to have greater control of splits
+        :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
+        :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
+        :return: edges: Old output disconnected edges.
 
     type list of (`bmesh.types.BMEdge`)
         :rtype: dict[str, typing.Any]
@@ -1768,19 +1777,19 @@ def subdivide_edgering(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input vertices
+        :param edges: Input vertices.
         :type edges: list[bmesh.types.BMEdge]
-        :param interp_mode: interpolation method
+        :param interp_mode: Interpolation method.
         :type interp_mode: typing.Literal['LINEAR','PATH','SURFACE']
-        :param smooth: smoothness factor
+        :param smooth: Smoothness factor.
         :type smooth: float
-        :param cuts: number of cuts
+        :param cuts: Number of cuts.
         :type cuts: int
-        :param profile_shape: profile shape type
+        :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
+        :param profile_shape_factor: How much intermediary new edges are shrunk/expanded.
         :type profile_shape_factor: float
-        :return: faces: output faces
+        :return: faces: Output faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1813,33 +1822,33 @@ def subdivide_edges(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param smooth: smoothness factor
+        :param smooth: Smoothness factor.
         :type smooth: float
-        :param smooth_falloff: smooth falloff type
+        :param smooth_falloff: Smooth falloff type.
         :type smooth_falloff: typing.Literal['SMOOTH','SPHERE','ROOT','SHARP','LINEAR','INVERSE_SQUARE']
-        :param fractal: fractal randomness factor
+        :param fractal: Fractal randomness factor.
         :type fractal: float
-        :param along_normal: apply fractal displacement along normal only
+        :param along_normal: Apply fractal displacement along normal only.
         :type along_normal: float
-        :param cuts: number of cuts
+        :param cuts: Number of cuts.
         :type cuts: int
-        :param seed: seed for the random number generator
+        :param seed: Seed for the random number generator.
         :type seed: int
-        :param custom_patterns: uses custom pointers
+        :param custom_patterns: Uses custom pointers.
         :param edge_percents: Undocumented.
-        :param quad_corner_type: quad corner type
+        :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
+        :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
+        :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
+        :param use_sphere: For making new primitives only.
         :type use_sphere: bool
-        :param use_smooth_even: maintain even offset when smoothing
+        :param use_smooth_even: Maintain even offset when smoothing.
         :type use_smooth_even: bool
         :return: geom_inner:
 
@@ -1849,7 +1858,7 @@ 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]
@@ -1871,11 +1880,11 @@ def symmetrize(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param input: input geometry
+        :param input: Input geometry.
         :type input: list[bmesh.types.BMEdge] | list[bmesh.types.BMFace] | list[bmesh.types.BMVert]
-        :param direction: axis to use
+        :param direction: Axis to use.
         :type direction: typing.Literal['-X','-Y','-Z','X','Y','Z']
-        :param dist: minimum distance
+        :param dist: Minimum distance.
         :type dist: float
         :param use_shapekey: Transform shape keys too.
         :type use_shapekey: bool
@@ -1893,17 +1902,17 @@ 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
+        :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)
+        :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
+        :param verts: Input vertices.
         :type verts: list[bmesh.types.BMVert]
         :param use_shapekey: Transform shape keys too.
         :type use_shapekey: bool
@@ -1916,16 +1925,16 @@ 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
+    :param vec: Translation offset.
     :type vec: collections.abc.Sequence[float] | mathutils.Vector
-    :param space: matrix to define the space (typically object 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
+    :param verts: Input vertices.
     :type verts: list[bmesh.types.BMVert]
     :param use_shapekey: Transform shape keys too.
     :type use_shapekey: bool
@@ -1942,15 +1951,15 @@ def triangle_fill(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param use_beauty: use best triangulation division
+        :param use_beauty: Use best triangulation division.
         :type use_beauty: bool
-        :param use_dissolve: dissolve resulting faces
+        :param use_dissolve: Dissolve resulting faces.
         :type use_dissolve: bool
-        :param edges: input edges
+        :param edges: Input edges.
         :type edges: list[bmesh.types.BMEdge]
-        :param normal: optionally pass the fill normal to use
+        :param normal: Optionally pass the fill normal to use.
         :type normal: collections.abc.Sequence[float] | mathutils.Vector
-        :return: geom: new faces and edges
+        :return: geom: New faces and edges.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]
@@ -1968,11 +1977,11 @@ def triangulate(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param quad_method: method for splitting the quads into triangles
+        :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
+        :param ngon_method: Method for splitting the polygons into triangles.
         :type ngon_method: typing.Literal['BEAUTY','EAR_CLIP']
         :return: edges:
 
@@ -1986,7 +1995,7 @@ 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]
@@ -1994,25 +2003,25 @@ def triangulate(
 
 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
+    :param verts: Input vertices.
     :type verts: list[bmesh.types.BMVert]
-    :param iterations: number of times to unsubdivide
+    :param iterations: Number of times to unsubdivide.
     :type iterations: int
     """
 
-def weld_verts(bm: bmesh.types.BMesh, targetmap={}):
+def weld_verts(bm: bmesh.types.BMesh, targetmap={}) -> 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.
     """
 
 def wireframe(
@@ -2032,27 +2041,27 @@ def wireframe(
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
-        :param faces: input faces
+        :param faces: Input faces.
         :type faces: list[bmesh.types.BMFace]
-        :param thickness: thickness
+        :param thickness: Thickness.
         :type thickness: float
-        :param offset: offset the thickness from the center
+        :param offset: Offset the thickness from the center.
         :type offset: float
-        :param use_replace: remove original geometry
+        :param use_replace: Remove original geometry.
         :type use_replace: bool
-        :param use_boundary: inset face boundaries
+        :param use_boundary: Inset face boundaries.
         :type use_boundary: bool
-        :param use_even_offset: scale the offset to give more even thickness
+        :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
+        :param use_crease: Crease hub edges for improved subdivision surface.
         :type use_crease: bool
-        :param crease_weight: the mean crease weight for resulting edges
+        :param crease_weight: The mean crease weight for resulting edges.
         :type crease_weight: float
-        :param use_relative_offset: scale the offset by surrounding geometry
+        :param use_relative_offset: Scale the offset by surrounding geometry.
         :type use_relative_offset: bool
-        :param material_offset: offset material index of generated faces
+        :param material_offset: Offset material index of generated faces.
         :type material_offset: int
-        :return: faces: output faces
+        :return: faces: Output faces.
 
     type list of (`bmesh.types.BMFace`)
         :rtype: dict[str, typing.Any]