fake-bpy-module 20240516__py3-none-any.whl → 20240517__py3-none-any.whl

bmesh/ops/__init__.pyi

@@ -20,9 +20,7 @@ import mathutils
 
 GenericType = typing.TypeVar("GenericType")
 
-def average_vert_facedata(
-    bm: bmesh.types.BMesh, verts: typing.List[bmesh.types.BMVert] = []
-):
+def average_vert_facedata(bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = []):
     """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).
@@ -30,82 +28,80 @@ def average_vert_facedata(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param verts: input vertices
-        :type verts: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
     """
 
     ...
 
 def beautify_fill(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    faces: list[bmesh.types.BMFace] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     use_restrict_tag: bool = False,
-    method: typing.Union[str, int] = "AREA",
-) -> typing.Dict[str, typing.Any]:
+    method: str | int = "AREA",
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :param edges: edges that can be flipped
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :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.Union[str, int]
+        :type method: str | int
         :return: geom: new flipped faces and edges
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def bevel(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     offset: float = 0,
-    offset_type: typing.Union[str, int] = "OFFSET",
-    profile_type: typing.Union[str, int] = "SUPERELLIPSE",
+    offset_type: str | int = "OFFSET",
+    profile_type: str | int = "SUPERELLIPSE",
     segments: int = 0,
     profile: float = 0,
-    affect: typing.Union[str, int] = "VERTICES",
+    affect: str | int = "VERTICES",
     clamp_overlap: bool = False,
     material: int = 0,
     loop_slide: bool = False,
     mark_seam: bool = False,
     mark_sharp: bool = False,
     harden_normals: bool = False,
-    face_strength_mode: typing.Union[str, int] = "NONE",
-    miter_outer: typing.Union[str, int] = "SHARP",
-    miter_inner: typing.Union[str, int] = "SHARP",
+    face_strength_mode: str | int = "NONE",
+    miter_outer: str | int = "SHARP",
+    miter_inner: str | int = "SHARP",
     spread: float = 0,
     custom_profile: bpy.types.bpy_struct = None,
-    vmesh_method: typing.Union[str, int] = "ADJ",
-) -> typing.Dict[str, typing.Any]:
+    vmesh_method: str | int = "ADJ",
+) -> dict[str, typing.Any]:
     """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: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param offset: amount to offset beveled edge
         :type offset: float
         :param offset_type: how to measure the offset
-        :type offset_type: typing.Union[str, int]
+        :type offset_type: str | int
         :param profile_type: The profile type to use for bevel.
-        :type profile_type: typing.Union[str, int]
+        :type profile_type: str | int
         :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.Union[str, int]
+        :type affect: str | int
         :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
@@ -119,17 +115,17 @@ def bevel(
         :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.Union[str, int]
+        :type face_strength_mode: str | int
         :param miter_outer: outer miter kind
-        :type miter_outer: typing.Union[str, int]
+        :type miter_outer: str | int
         :param miter_inner: outer miter kind
-        :type miter_inner: typing.Union[str, int]
+        :type miter_inner: str | int
         :param spread: amount to offset beveled edge
         :type spread: float
         :param custom_profile: CurveProfile, if None ignored
         :type custom_profile: bpy.types.bpy_struct
         :param vmesh_method: The method to use to create meshes at intersections.
-        :type vmesh_method: typing.Union[str, int]
+        :type vmesh_method: str | int
         :return: faces: output faces
 
     type list of (`bmesh.types.BMFace`)
@@ -141,61 +137,59 @@ def bevel(
     verts: output verts
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def bisect_edges(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     cuts: int = 0,
     edge_percents={},
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Edge Bisect.Splits input edges (but doesn't do anything else).
     This creates a 2-valence vert.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def bisect_plane(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     dist: float = 0,
-    plane_co: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-    plane_no: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
+    plane_co: typing.Sequence[float] | mathutils.Vector = None(),
+    plane_no: typing.Sequence[float] | mathutils.Vector = None(),
     use_snap_center: bool = False,
     clear_outer: bool = False,
     clear_inner: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :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: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :type plane_co: typing.Sequence[float] | mathutils.Vector
         :param plane_no: direction of the plane
-        :type plane_no: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :type plane_no: typing.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
@@ -209,7 +203,7 @@ def bisect_plane(
     geom: input and output geometry (result of cut).
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -231,19 +225,19 @@ def bmesh_to_mesh(
 
 def bridge_loops(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     use_pairs: bool = False,
     use_cyclic: bool = False,
     use_merge: bool = False,
     merge_factor: float = 0,
     twist_offset: int = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Bridge edge loops with faces.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param use_pairs: Undocumented.
         :type use_pairs: bool
         :param use_cyclic: Undocumented.
@@ -261,96 +255,94 @@ def bridge_loops(
     edges: new edges
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def collapse(
-    bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
-    uvs: bool = False,
+    bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = [], uvs: bool = False
 ):
     """Collapse Connected.Collapses connected vertices
 
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param edges: input edges
-    :type edges: typing.List[bmesh.types.BMEdge]
+    :type edges: list[bmesh.types.BMEdge]
     :param uvs: also collapse UVs and such
     :type uvs: bool
     """
 
     ...
 
-def collapse_uvs(bm: bmesh.types.BMesh, edges: typing.List[bmesh.types.BMEdge] = []):
+def collapse_uvs(bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = []):
     """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: typing.List[bmesh.types.BMEdge]
+    :type edges: list[bmesh.types.BMEdge]
     """
 
     ...
 
 def connect_vert_pair(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
-    verts_exclude: typing.List[bmesh.types.BMVert] = [],
-    faces_exclude: typing.List[bmesh.types.BMFace] = [],
-) -> typing.Dict[str, typing.Any]:
+    verts: list[bmesh.types.BMVert] = [],
+    verts_exclude: list[bmesh.types.BMVert] = [],
+    faces_exclude: list[bmesh.types.BMFace] = [],
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param verts_exclude: input vertices to explicitly exclude from connecting
-        :type verts_exclude: typing.List[bmesh.types.BMVert]
+        :type verts_exclude: list[bmesh.types.BMVert]
         :param faces_exclude: input faces to explicitly exclude from connecting
-        :type faces_exclude: typing.List[bmesh.types.BMFace]
+        :type faces_exclude: list[bmesh.types.BMFace]
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def connect_verts(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
-    faces_exclude: typing.List[bmesh.types.BMFace] = [],
+    verts: list[bmesh.types.BMVert] = [],
+    faces_exclude: list[bmesh.types.BMFace] = [],
     check_degenerate: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param faces_exclude: input faces to explicitly exclude from connecting
-        :type faces_exclude: typing.List[bmesh.types.BMFace]
+        :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def connect_verts_concave(
-    bm: bmesh.types.BMesh, faces: typing.List[bmesh.types.BMFace] = []
-) -> typing.Dict[str, typing.Any]:
+    bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -358,16 +350,14 @@ def connect_verts_concave(
     faces:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def connect_verts_nonplanar(
-    bm: bmesh.types.BMesh,
-    angle_limit: float = 0,
-    faces: typing.List[bmesh.types.BMFace] = [],
-) -> typing.Dict[str, typing.Any]:
+    bm: bmesh.types.BMesh, angle_limit: float = 0, faces: list[bmesh.types.BMFace] = []
+) -> dict[str, typing.Any]:
     """Connect Verts Across non Planer Faces.Split faces by connecting edges along non planer faces.
 
         :param bm: The bmesh to operate on.
@@ -375,7 +365,7 @@ def connect_verts_nonplanar(
         :param angle_limit: total rotation angle (radians)
         :type angle_limit: float
         :param faces: input faces
-        :type faces: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -383,21 +373,19 @@ def connect_verts_nonplanar(
     faces:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def contextual_create(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     mat_nr: int = 0,
     use_smooth: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Contextual Create.This is basically F-key, it creates
     new faces from vertices, makes stuff from edge nets,
     makes wire edges, etc. It also dissolves faces.Three verts become a triangle, four become a quad. Two
@@ -406,7 +394,7 @@ def contextual_create(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param geom: input geometry.
-        :type geom: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param mat_nr: material to use
         :type mat_nr: int
         :param use_smooth: smooth to use
@@ -418,20 +406,18 @@ def contextual_create(
     edges: newly-made edge(s)
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def convex_hull(
     bm: bmesh.types.BMesh,
-    input: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    input: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     use_existing_faces: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Convex HullBuilds a convex hull from the vertices in 'input'.If 'use_existing_faces' is true, the hull will not output triangles
     that are covered by a pre-existing face.All hull vertices, faces, and edges are added to 'geom.out'. Any
     input elements that end up inside the hull (i.e. are not used by an
@@ -443,7 +429,7 @@ def convex_hull(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param input: input geometry
-        :type input: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type input: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param use_existing_faces: skip hull triangles that are covered by a pre-existing face
         :type use_existing_faces: bool
         :return: geom:
@@ -461,7 +447,7 @@ def convex_hull(
     geom_holes:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -472,9 +458,9 @@ def create_circle(
     cap_tris: bool = False,
     segments: int = 0,
     radius: float = 0,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     calc_uvs: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Creates a Circle.
 
         :param bm: The bmesh to operate on.
@@ -488,13 +474,13 @@ def create_circle(
         :param radius: Radius of the circle.
         :type radius: float
         :param matrix: matrix to multiply the new geometry with
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -507,9 +493,9 @@ def create_cone(
     radius1: float = 0,
     radius2: float = 0,
     depth: float = 0,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     calc_uvs: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Create Cone.Creates a cone with variable depth at both ends
 
         :param bm: The bmesh to operate on.
@@ -527,13 +513,13 @@ def create_cone(
         :param depth: distance between ends
         :type depth: float
         :param matrix: matrix to multiply the new geometry with
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -541,9 +527,9 @@ def create_cone(
 def create_cube(
     bm: bmesh.types.BMesh,
     size: float = 0,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     calc_uvs: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Create CubeCreates a cube.
 
         :param bm: The bmesh to operate on.
@@ -551,13 +537,13 @@ def create_cube(
         :param size: size of the cube
         :type size: float
         :param matrix: matrix to multiply the new geometry with
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -567,9 +553,9 @@ def create_grid(
     x_segments: int = 0,
     y_segments: int = 0,
     size: float = 0,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     calc_uvs: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Create Grid.Creates a grid with a variable number of subdivisions
 
         :param bm: The bmesh to operate on.
@@ -581,13 +567,13 @@ def create_grid(
         :param size: size of the grid
         :type size: float
         :param matrix: matrix to multiply the new geometry with
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -596,9 +582,9 @@ def create_icosphere(
     bm: bmesh.types.BMesh,
     subdivisions: int = 0,
     radius: float = 0,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     calc_uvs: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Create Ico-Sphere.Creates a grid with a variable number of subdivisions
 
         :param bm: The bmesh to operate on.
@@ -608,34 +594,34 @@ def create_icosphere(
         :param radius: radius
         :type radius: float
         :param matrix: matrix to multiply the new geometry with
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def create_monkey(
     bm: bmesh.types.BMesh,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     calc_uvs: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -645,9 +631,9 @@ def create_uvsphere(
     u_segments: int = 0,
     v_segments: int = 0,
     radius: float = 0,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     calc_uvs: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Create UV Sphere.Creates a grid with a variable number of subdivisions
 
         :param bm: The bmesh to operate on.
@@ -659,59 +645,56 @@ def create_uvsphere(
         :param radius: radius
         :type radius: float
         :param matrix: matrix to multiply the new geometry with
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def create_vert(
-    bm: bmesh.types.BMesh,
-    co: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-) -> typing.Dict[str, typing.Any]:
+    bm: bmesh.types.BMesh, co: typing.Sequence[float] | mathutils.Vector = None()
+) -> dict[str, typing.Any]:
     """Make Vertex.Creates a single vertex; this BMOP was necessary
     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: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :type co: typing.Sequence[float] | mathutils.Vector
         :return: vert: the new vert
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def delete(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
-    context: typing.Union[str, int] = "VERTS",
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
+    context: str | int = "VERTS",
 ):
     """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: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+    :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
     :param context: geometry types to delete
-    :type context: typing.Union[str, int]
+    :type context: str | int
     """
 
     ...
 
 def dissolve_degenerate(
-    bm: bmesh.types.BMesh, dist: float = 0, edges: typing.List[bmesh.types.BMEdge] = []
+    bm: bmesh.types.BMesh, dist: float = 0, edges: list[bmesh.types.BMEdge] = []
 ):
     """Degenerate Dissolve.Dissolve edges with no length, faces with no area.
 
@@ -720,23 +703,23 @@ def dissolve_degenerate(
     :param dist: maximum distance to consider degenerate
     :type dist: float
     :param edges: input edges
-    :type edges: typing.List[bmesh.types.BMEdge]
+    :type edges: list[bmesh.types.BMEdge]
     """
 
     ...
 
 def dissolve_edges(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     use_verts: bool = False,
     use_face_split: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Dissolve Edges.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :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
@@ -744,28 +727,26 @@ def dissolve_edges(
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def dissolve_faces(
-    bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
-    use_verts: bool = False,
-) -> typing.Dict[str, typing.Any]:
+    bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = [], use_verts: bool = False
+) -> dict[str, typing.Any]:
     """Dissolve Faces.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param faces: input faces
-        :type faces: typing.List[bmesh.types.BMFace]
+        :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -774,10 +755,10 @@ def dissolve_limit(
     bm: bmesh.types.BMesh,
     angle_limit: float = 0,
     use_dissolve_boundaries: bool = False,
-    verts: typing.List[bmesh.types.BMVert] = [],
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    verts: list[bmesh.types.BMVert] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     delimit=None(),
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Limited Dissolve.Dissolve planar faces and co-linear edges.
 
         :param bm: The bmesh to operate on.
@@ -787,21 +768,21 @@ def dissolve_limit(
         :param use_dissolve_boundaries: dissolve all vertices in between face boundaries
         :type use_dissolve_boundaries: bool
         :param verts: input vertices
-        :type verts: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param delimit: delimit dissolve operation
         :return: region:
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def dissolve_verts(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
+    verts: list[bmesh.types.BMVert] = [],
     use_face_split: bool = False,
     use_boundary_tear: bool = False,
 ):
@@ -810,7 +791,7 @@ def dissolve_verts(
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param verts: input vertices
-    :type verts: typing.List[bmesh.types.BMVert]
+    :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
@@ -821,22 +802,20 @@ def dissolve_verts(
 
 def duplicate(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     dest: bmesh.types.BMesh = None,
     use_select_history: bool = False,
     use_edge_flip_from_face: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Duplicate Geometry.Utility operator to duplicate geometry,
     optionally into a destination mesh.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param geom: input geometry
-        :type geom: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param dest: destination bmesh, if None will use current on
         :type dest: bmesh.types.BMesh
         :param use_select_history: Undocumented.
@@ -870,23 +849,23 @@ def duplicate(
     isovert_map:
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def edgeloop_fill(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     mat_nr: int = 0,
     use_smooth: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param mat_nr: material to use
         :type mat_nr: int
         :param use_smooth: smooth state to use
@@ -894,24 +873,24 @@ def edgeloop_fill(
         :return: faces: new faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def edgenet_fill(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     mat_nr: int = 0,
     use_smooth: bool = False,
     sides: int = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param mat_nr: material to use
         :type mat_nr: int
         :param use_smooth: smooth state to use
@@ -921,41 +900,41 @@ def edgenet_fill(
         :return: faces: new faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def edgenet_prepare(
-    bm: bmesh.types.BMesh, edges: typing.List[bmesh.types.BMEdge] = []
-) -> typing.Dict[str, typing.Any]:
+    bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = []
+) -> dict[str, typing.Any]:
     """Edge-net Prepare.Identifies several useful edge loop cases and modifies them so
     they'll become a face when edgenet_fill is called. The cases covered are:
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :return: edges: new edges
 
     type list of (`bmesh.types.BMEdge`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def extrude_discrete_faces(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     use_normal_flip: bool = False,
     use_select_history: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Individual Face Extrude.Extrudes faces individually.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param faces: input faces
-        :type faces: typing.List[bmesh.types.BMFace]
+        :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
@@ -963,24 +942,24 @@ def extrude_discrete_faces(
         :return: faces: output faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def extrude_edge_only(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     use_normal_flip: bool = False,
     use_select_history: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Extrude Only Edges.Extrudes Edges into faces, note that this is very simple, there's no fancy
     winged extrusion.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param edges: input vertices
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :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
@@ -988,31 +967,29 @@ def extrude_edge_only(
         :return: geom: output geometry
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def extrude_face_region(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     edges_exclude=None(),
     use_keep_orig: bool = False,
     use_normal_flip: bool = False,
     use_normal_from_adjacent: bool = False,
     use_dissolve_ortho_edges: bool = False,
     use_select_history: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> 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: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :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
@@ -1027,22 +1004,22 @@ def extrude_face_region(
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def extrude_vert_indiv(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
+    verts: list[bmesh.types.BMVert] = [],
     use_select_history: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param use_select_history: pass to duplicate
         :type use_select_history: bool
         :return: edges: output wire edges
@@ -1052,23 +1029,23 @@ def extrude_vert_indiv(
     verts: output vertices
 
     type list of (`bmesh.types.BMVert`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def face_attribute_fill(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     use_normals: bool = False,
     use_data: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :param use_normals: copy face winding
         :type use_normals: bool
         :param use_data: copy face data
@@ -1076,17 +1053,17 @@ def face_attribute_fill(
         :return: faces_fail: faces that could not be handled
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def find_doubles(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
-    keep_verts: typing.List[bmesh.types.BMVert] = [],
+    verts: list[bmesh.types.BMVert] = [],
+    keep_verts: list[bmesh.types.BMVert] = [],
     dist: float = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Find Doubles.Takes input verts and find vertices they should weld to.
     Outputs a mapping slot suitable for use with the weld verts BMOP.If keep_verts is used, vertices outside that set can only be merged
     with vertices in that set.
@@ -1094,45 +1071,43 @@ def find_doubles(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param verts: input vertices
-        :type verts: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param keep_verts: list of verts to keep
-        :type keep_verts: typing.List[bmesh.types.BMVert]
+        :type keep_verts: list[bmesh.types.BMVert]
         :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
-def flip_quad_tessellation(
-    bm: bmesh.types.BMesh, faces: typing.List[bmesh.types.BMFace] = []
-):
+def flip_quad_tessellation(bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []):
     """Flip Quad TessellationFlip the tessellation direction of the selected quads.
 
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param faces: Undocumented.
-    :type faces: typing.List[bmesh.types.BMFace]
+    :type faces: list[bmesh.types.BMFace]
     """
 
     ...
 
 def grid_fill(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     mat_nr: int = 0,
     use_smooth: bool = False,
     use_interp_simple: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param mat_nr: material to use
         :type mat_nr: int
         :param use_smooth: smooth state to use
@@ -1142,45 +1117,45 @@ def grid_fill(
         :return: faces: new faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def holes_fill(
-    bm: bmesh.types.BMesh, edges: typing.List[bmesh.types.BMEdge] = [], sides: int = 0
-) -> typing.Dict[str, typing.Any]:
+    bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = [], sides: int = 0
+) -> dict[str, typing.Any]:
     """Fill Holes.Fill boundary edges with faces, copying surrounding customdata.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def inset_individual(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     thickness: float = 0,
     depth: float = 0,
     use_even_offset: bool = False,
     use_interpolate: bool = False,
     use_relative_offset: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Face Inset (Individual).Insets individual faces.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param faces: input faces
-        :type faces: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :param thickness: thickness
         :type thickness: float
         :param depth: depth
@@ -1194,15 +1169,15 @@ def inset_individual(
         :return: faces: output faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def inset_region(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
-    faces_exclude: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
+    faces_exclude: list[bmesh.types.BMFace] = [],
     use_boundary: bool = False,
     use_even_offset: bool = False,
     use_interpolate: bool = False,
@@ -1211,15 +1186,15 @@ def inset_region(
     thickness: float = 0,
     depth: float = 0,
     use_outset: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :param faces_exclude: input faces to explicitly exclude from inset
-        :type faces_exclude: typing.List[bmesh.types.BMFace]
+        :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
@@ -1239,14 +1214,14 @@ def inset_region(
         :return: faces: output faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def join_triangles(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     cmp_seam: bool = False,
     cmp_sharp: bool = False,
     cmp_uvs: bool = False,
@@ -1254,14 +1229,14 @@ def join_triangles(
     cmp_materials: bool = False,
     angle_face_threshold: float = 0,
     angle_shape_threshold: float = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Join Triangles.Tries to intelligently join triangles according
     to angle threshold and delimiters.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param faces: input geometry.
-        :type faces: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :param cmp_seam: Compare seam
         :type cmp_seam: bool
         :param cmp_sharp: Compare sharp
@@ -1279,7 +1254,7 @@ def join_triangles(
         :return: faces: joined faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -1307,19 +1282,17 @@ def mesh_to_bmesh(
 
 def mirror(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
     merge_dist: float = 0,
-    axis: typing.Union[str, int] = "X",
+    axis: str | int = "X",
     mirror_u: bool = False,
     mirror_v: bool = False,
     mirror_udim: bool = False,
     use_shapekey: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Mirror.Mirrors geometry along an axis. The resulting geometry is welded on using
     merge_dist. Pairs of original/mirrored vertices are welded using the merge_dist
     parameter (which defines the minimum distance for welding to happen).
@@ -1327,13 +1300,13 @@ def mirror(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param geom: input geometry
-        :type geom: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param matrix: matrix defining the mirror transformation
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.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.Union[str, int]
+        :type axis: str | int
         :param mirror_u: mirror UVs across the u axis
         :type mirror_u: bool
         :param mirror_v: mirror UVs across the v axis
@@ -1345,7 +1318,7 @@ def mirror(
         :return: geom: output geometry, mirrored
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
@@ -1368,37 +1341,37 @@ def object_load_bmesh(
 
 def offset_edgeloops(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     use_cap_endpoint: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMEdge]
+        :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def planar_faces(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     iterations: int = 0,
     factor: float = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Planar Faces.Iteratively flatten faces.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param faces: input geometry.
-        :type faces: typing.List[bmesh.types.BMFace]
+        :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
@@ -1406,31 +1379,31 @@ def planar_faces(
         :return: geom: output slot, computed boundary geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def pointmerge(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
-    merge_co: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
+    verts: list[bmesh.types.BMVert] = [],
+    merge_co: typing.Sequence[float] | mathutils.Vector = None(),
 ):
     """Point Merge.Merge verts together at a point.
 
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param verts: input vertices (all verts will be merged into the first).
-    :type verts: typing.List[bmesh.types.BMVert]
+    :type verts: list[bmesh.types.BMVert]
     :param merge_co: Position to merge at.
-    :type merge_co: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type merge_co: typing.Sequence[float] | mathutils.Vector
     """
 
     ...
 
 def pointmerge_facedata(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
+    verts: list[bmesh.types.BMVert] = [],
     vert_snap: bmesh.types.BMVert = None,
 ):
     """Face-Data Point Merge.Merge uv/vcols at a specific vertex.
@@ -1438,7 +1411,7 @@ def pointmerge_facedata(
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param verts: input vertices
-    :type verts: typing.List[bmesh.types.BMVert]
+    :type verts: list[bmesh.types.BMVert]
     :param vert_snap: snap vertex
     :type vert_snap: bmesh.types.BMVert
     """
@@ -1447,21 +1420,21 @@ def pointmerge_facedata(
 
 def poke(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     offset: float = 0,
-    center_mode: typing.Union[str, int] = "MEAN_WEIGHTED",
+    center_mode: str | int = "MEAN_WEIGHTED",
     use_relative_offset: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMFace]
+        :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.Union[str, int]
+        :type center_mode: str | int
         :param use_relative_offset: apply offset
         :type use_relative_offset: bool
         :return: verts: output verts
@@ -1471,35 +1444,31 @@ def poke(
     faces: output faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
-def recalc_face_normals(
-    bm: bmesh.types.BMesh, faces: typing.List[bmesh.types.BMFace] = []
-):
+def recalc_face_normals(bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []):
     """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: typing.List[bmesh.types.BMFace]
+    :type faces: list[bmesh.types.BMFace]
     """
 
     ...
 
 def region_extend(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     use_contract: bool = False,
     use_faces: bool = False,
     use_face_step: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Region Extend.used to implement the select more/less tools.
     this puts some geometry surrounding regions of
     geometry in geom into geom.out.if use_faces is 0 then geom.out spits out verts and edges,
@@ -1508,7 +1477,7 @@ def region_extend(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param geom: input geometry
-        :type geom: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param use_contract: find boundary inside the regions, not outside.
         :type use_contract: bool
         :param use_faces: extend from faces instead of edges
@@ -1518,13 +1487,13 @@ def region_extend(
         :return: geom: output slot, computed boundary geometry.
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def remove_doubles(
-    bm: bmesh.types.BMesh, verts: typing.List[bmesh.types.BMVert] = [], dist: float = 0
+    bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = [], dist: float = 0
 ):
     """Remove Doubles.Finds groups of vertices closer than dist and merges them together,
     using the weld verts BMOP.
@@ -1532,7 +1501,7 @@ def remove_doubles(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param verts: input verts
-        :type verts: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param dist: minimum distance
         :type dist: float
     """
@@ -1540,16 +1509,14 @@ def remove_doubles(
     ...
 
 def reverse_colors(
-    bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
-    color_index: int = 0,
+    bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = [], color_index: int = 0
 ):
     """Color ReverseReverse the loop colors.
 
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param faces: input faces
-    :type faces: typing.List[bmesh.types.BMFace]
+    :type faces: list[bmesh.types.BMFace]
     :param color_index: index into color attribute list
     :type color_index: int
     """
@@ -1558,7 +1525,7 @@ def reverse_colors(
 
 def reverse_faces(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     flip_multires: bool = False,
 ):
     """Reverse Faces.Reverses the winding (vertex order) of faces.
@@ -1567,30 +1534,30 @@ def reverse_faces(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param faces: input faces
-        :type faces: typing.List[bmesh.types.BMFace]
+        :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: typing.List[bmesh.types.BMFace] = []):
+def reverse_uvs(bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = []):
     """UV Reverse.Reverse the UVs
 
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param faces: input faces
-    :type faces: typing.List[bmesh.types.BMFace]
+    :type faces: list[bmesh.types.BMFace]
     """
 
     ...
 
 def rotate(
     bm: bmesh.types.BMesh,
-    cent: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
-    verts: typing.List[bmesh.types.BMVert] = [],
-    space: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    cent: typing.Sequence[float] | mathutils.Vector = None(),
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
+    verts: list[bmesh.types.BMVert] = [],
+    space: typing.Sequence[float] | mathutils.Matrix = None(4),
     use_shapekey: bool = False,
 ):
     """Rotate.Rotate vertices around a center, using a 3x3 rotation matrix.
@@ -1598,13 +1565,13 @@ def rotate(
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param cent: center of rotation
-    :type cent: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type cent: typing.Sequence[float] | mathutils.Vector
     :param matrix: matrix defining rotation
-    :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+    :type matrix: typing.Sequence[float] | mathutils.Matrix
     :param verts: input vertices
-    :type verts: typing.List[bmesh.types.BMVert]
+    :type verts: list[bmesh.types.BMVert]
     :param space: matrix to define the space (typically object matrix)
-    :type space: typing.Union[typing.Sequence[float], mathutils.Matrix]
+    :type space: typing.Sequence[float] | mathutils.Matrix
     :param use_shapekey: Transform shape keys too.
     :type use_shapekey: bool
     """
@@ -1613,7 +1580,7 @@ def rotate(
 
 def rotate_colors(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     use_ccw: bool = False,
     color_index: int = 0,
 ):
@@ -1622,7 +1589,7 @@ def rotate_colors(
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param faces: input faces
-    :type faces: typing.List[bmesh.types.BMFace]
+    :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
@@ -1632,38 +1599,34 @@ def rotate_colors(
     ...
 
 def rotate_edges(
-    bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
-    use_ccw: bool = False,
-) -> typing.Dict[str, typing.Any]:
+    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 [].
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def rotate_uvs(
-    bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
-    use_ccw: bool = False,
+    bm: bmesh.types.BMesh, faces: list[bmesh.types.BMFace] = [], use_ccw: bool = False
 ):
     """UV Rotation.Cycle the loop UVs
 
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param faces: input faces
-    :type faces: typing.List[bmesh.types.BMFace]
+    :type faces: list[bmesh.types.BMFace]
     :param use_ccw: rotate counter-clockwise if true, otherwise clockwise
     :type use_ccw: bool
     """
@@ -1672,9 +1635,9 @@ def rotate_uvs(
 
 def scale(
     bm: bmesh.types.BMesh,
-    vec: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-    space: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
-    verts: typing.List[bmesh.types.BMVert] = [],
+    vec: typing.Sequence[float] | mathutils.Vector = None(),
+    space: typing.Sequence[float] | mathutils.Matrix = None(4),
+    verts: list[bmesh.types.BMVert] = [],
     use_shapekey: bool = False,
 ):
     """Scale.Scales vertices by an offset.
@@ -1682,11 +1645,11 @@ def scale(
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param vec: scale factor
-    :type vec: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type vec: typing.Sequence[float] | mathutils.Vector
     :param space: matrix to define the space (typically object matrix)
-    :type space: typing.Union[typing.Sequence[float], mathutils.Matrix]
+    :type space: typing.Sequence[float] | mathutils.Matrix
     :param verts: input vertices
-    :type verts: typing.List[bmesh.types.BMVert]
+    :type verts: list[bmesh.types.BMVert]
     :param use_shapekey: Transform shape keys too.
     :type use_shapekey: bool
     """
@@ -1695,7 +1658,7 @@ def scale(
 
 def smooth_laplacian_vert(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
+    verts: list[bmesh.types.BMVert] = [],
     lambda_factor: float = 0,
     lambda_border: float = 0,
     use_x: bool = False,
@@ -1709,7 +1672,7 @@ def smooth_laplacian_vert(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param verts: input vertices
-        :type verts: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param lambda_factor: lambda param
         :type lambda_factor: float
         :param lambda_border: lambda param in border
@@ -1728,7 +1691,7 @@ def smooth_laplacian_vert(
 
 def smooth_vert(
     bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
+    verts: list[bmesh.types.BMVert] = [],
     factor: float = 0,
     mirror_clip_x: bool = False,
     mirror_clip_y: bool = False,
@@ -1743,7 +1706,7 @@ def smooth_vert(
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param verts: input vertices
-    :type verts: typing.List[bmesh.types.BMVert]
+    :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
@@ -1766,63 +1729,59 @@ def smooth_vert(
 
 def solidify(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     thickness: float = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param thickness: thickness
         :type thickness: float
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def spin(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
-    cent: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-    axis: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-    dvec: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
+    cent: typing.Sequence[float] | mathutils.Vector = None(),
+    axis: typing.Sequence[float] | mathutils.Vector = None(),
+    dvec: typing.Sequence[float] | mathutils.Vector = None(),
     angle: float = 0,
-    space: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
+    space: typing.Sequence[float] | mathutils.Matrix = None(4),
     steps: int = 0,
     use_merge: bool = False,
     use_normal_flip: bool = False,
     use_duplicate: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Spin.Extrude or duplicate geometry a number of times,
     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: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param cent: rotation center
-        :type cent: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :type cent: typing.Sequence[float] | mathutils.Vector
         :param axis: rotation axis
-        :type axis: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :type axis: typing.Sequence[float] | mathutils.Vector
         :param dvec: translation delta per step
-        :type dvec: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :type dvec: typing.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: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type space: typing.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.
@@ -1834,28 +1793,26 @@ def spin(
         :return: geom_last: result of last step
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def split(
     bm: bmesh.types.BMesh,
-    geom: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
+    geom: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
     dest: bmesh.types.BMesh = None,
     use_only_faces: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Split Off Geometry.Disconnect geometry from adjacent edges and faces,
     optionally into a destination mesh.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param geom: input geometry
-        :type geom: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type geom: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param dest: destination bmesh, if None will use current one
         :type dest: bmesh.types.BMesh
         :param use_only_faces: when enabled. don't duplicate loose verts/edges
@@ -1871,97 +1828,97 @@ def split(
     isovert_map:
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def split_edges(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
-    verts: typing.List[bmesh.types.BMVert] = [],
+    edges: list[bmesh.types.BMEdge] = [],
+    verts: list[bmesh.types.BMVert] = [],
     use_verts: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param verts: optional tag verts, use to have greater control of splits
-        :type verts: typing.List[bmesh.types.BMVert]
+        :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def subdivide_edgering(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
-    interp_mode: typing.Union[str, int] = "LINEAR",
+    edges: list[bmesh.types.BMEdge] = [],
+    interp_mode: str | int = "LINEAR",
     smooth: float = 0,
     cuts: int = 0,
-    profile_shape: typing.Union[str, int] = "SMOOTH",
+    profile_shape: str | int = "SMOOTH",
     profile_shape_factor: float = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param interp_mode: interpolation method
-        :type interp_mode: typing.Union[str, int]
+        :type interp_mode: str | int
         :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.Union[str, int]
+        :type profile_shape: str | int
         :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: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def subdivide_edges(
     bm: bmesh.types.BMesh,
-    edges: typing.List[bmesh.types.BMEdge] = [],
+    edges: list[bmesh.types.BMEdge] = [],
     smooth: float = 0,
-    smooth_falloff: typing.Union[str, int] = "SMOOTH",
+    smooth_falloff: str | int = "SMOOTH",
     fractal: float = 0,
     along_normal: float = 0,
     cuts: int = 0,
     seed: int = 0,
     custom_patterns={},
     edge_percents={},
-    quad_corner_type: typing.Union[str, int] = "STRAIGHT_CUT",
+    quad_corner_type: str | int = "STRAIGHT_CUT",
     use_grid_fill: bool = False,
     use_single_edge: bool = False,
     use_only_quads: bool = False,
     use_sphere: bool = False,
     use_smooth_even: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Subdivide Edges.Advanced operator for subdividing 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: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param smooth: smoothness factor
         :type smooth: float
         :param smooth_falloff: smooth falloff type
-        :type smooth_falloff: typing.Union[str, int]
+        :type smooth_falloff: str | int
         :param fractal: fractal randomness factor
         :type fractal: float
         :param along_normal: apply fractal displacement along normal only
@@ -1973,7 +1930,7 @@ def subdivide_edges(
         :param custom_patterns: uses custom pointers
         :param edge_percents: Undocumented.
         :param quad_corner_type: quad corner type
-        :type quad_corner_type: typing.Union[str, int]
+        :type quad_corner_type: str | int
         :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
@@ -1995,22 +1952,20 @@ def subdivide_edges(
     geom: contains all output geometry
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def symmetrize(
     bm: bmesh.types.BMesh,
-    input: typing.Union[
-        typing.List[bmesh.types.BMVert],
-        typing.List[bmesh.types.BMEdge],
-        typing.List[bmesh.types.BMFace],
-    ] = [],
-    direction: typing.Union[str, int] = "-X",
+    input: list[bmesh.types.BMVert]
+    | list[bmesh.types.BMEdge]
+    | list[bmesh.types.BMFace] = [],
+    direction: str | int = "-X",
     dist: float = 0,
     use_shapekey: bool = False,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """Symmetrize.Makes the mesh elements in the "input" slot symmetrical. Unlike
     normal mirroring, it only copies in one direction, as specified by
     the "direction" slot. The edges and faces that cross the plane of
@@ -2019,9 +1974,9 @@ def symmetrize(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param input: input geometry
-        :type input: typing.Union[typing.List[bmesh.types.BMVert], typing.List[bmesh.types.BMEdge], typing.List[bmesh.types.BMFace]]
+        :type input: list[bmesh.types.BMVert] | list[bmesh.types.BMEdge] | list[bmesh.types.BMFace]
         :param direction: axis to use
-        :type direction: typing.Union[str, int]
+        :type direction: str | int
         :param dist: minimum distance
         :type dist: float
         :param use_shapekey: Transform shape keys too.
@@ -2029,16 +1984,16 @@ def symmetrize(
         :return: geom:
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def transform(
     bm: bmesh.types.BMesh,
-    matrix: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
-    space: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
-    verts: typing.List[bmesh.types.BMVert] = [],
+    matrix: typing.Sequence[float] | mathutils.Matrix = None(4),
+    space: typing.Sequence[float] | mathutils.Matrix = None(4),
+    verts: list[bmesh.types.BMVert] = [],
     use_shapekey: bool = False,
 ):
     """Transform.Transforms a set of vertices by a matrix. Multiplies
@@ -2047,11 +2002,11 @@ def transform(
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param matrix: transform matrix
-        :type matrix: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type matrix: typing.Sequence[float] | mathutils.Matrix
         :param space: matrix to define the space (typically object matrix)
-        :type space: typing.Union[typing.Sequence[float], mathutils.Matrix]
+        :type space: typing.Sequence[float] | mathutils.Matrix
         :param verts: input vertices
-        :type verts: typing.List[bmesh.types.BMVert]
+        :type verts: list[bmesh.types.BMVert]
         :param use_shapekey: Transform shape keys too.
         :type use_shapekey: bool
     """
@@ -2060,9 +2015,9 @@ def transform(
 
 def translate(
     bm: bmesh.types.BMesh,
-    vec: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-    space: typing.Union[typing.Sequence[float], mathutils.Matrix] = None(4),
-    verts: typing.List[bmesh.types.BMVert] = [],
+    vec: typing.Sequence[float] | mathutils.Vector = None(),
+    space: typing.Sequence[float] | mathutils.Matrix = None(4),
+    verts: list[bmesh.types.BMVert] = [],
     use_shapekey: bool = False,
 ):
     """Translate.Translate vertices by an offset.
@@ -2070,11 +2025,11 @@ def translate(
     :param bm: The bmesh to operate on.
     :type bm: bmesh.types.BMesh
     :param vec: translation offset
-    :type vec: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type vec: typing.Sequence[float] | mathutils.Vector
     :param space: matrix to define the space (typically object matrix)
-    :type space: typing.Union[typing.Sequence[float], mathutils.Matrix]
+    :type space: typing.Sequence[float] | mathutils.Matrix
     :param verts: input vertices
-    :type verts: typing.List[bmesh.types.BMVert]
+    :type verts: list[bmesh.types.BMVert]
     :param use_shapekey: Transform shape keys too.
     :type use_shapekey: bool
     """
@@ -2085,9 +2040,9 @@ def triangle_fill(
     bm: bmesh.types.BMesh,
     use_beauty: bool = False,
     use_dissolve: bool = False,
-    edges: typing.List[bmesh.types.BMEdge] = [],
-    normal: typing.Union[typing.Sequence[float], mathutils.Vector] = None(),
-) -> typing.Dict[str, typing.Any]:
+    edges: list[bmesh.types.BMEdge] = [],
+    normal: typing.Sequence[float] | mathutils.Vector = None(),
+) -> dict[str, typing.Any]:
     """Triangle Fill.Fill edges with triangles
 
         :param bm: The bmesh to operate on.
@@ -2097,33 +2052,33 @@ def triangle_fill(
         :param use_dissolve: dissolve resulting faces
         :type use_dissolve: bool
         :param edges: input edges
-        :type edges: typing.List[bmesh.types.BMEdge]
+        :type edges: list[bmesh.types.BMEdge]
         :param normal: optionally pass the fill normal to use
-        :type normal: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :type normal: typing.Sequence[float] | mathutils.Vector
         :return: geom: new faces and edges
 
     type list of (`bmesh.types.BMVert`, `bmesh.types.BMEdge`, `bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def triangulate(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
-    quad_method: typing.Union[str, int] = "BEAUTY",
-    ngon_method: typing.Union[str, int] = "BEAUTY",
-) -> typing.Dict[str, typing.Any]:
+    faces: list[bmesh.types.BMFace] = [],
+    quad_method: str | int = "BEAUTY",
+    ngon_method: str | int = "BEAUTY",
+) -> dict[str, typing.Any]:
     """Triangulate.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh
         :param faces: input faces
-        :type faces: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :param quad_method: method for splitting the quads into triangles
-        :type quad_method: typing.Union[str, int]
+        :type quad_method: str | int
         :param ngon_method: method for splitting the polygons into triangles
-        :type ngon_method: typing.Union[str, int]
+        :type ngon_method: str | int
         :return: edges:
 
     type list of (`bmesh.types.BMEdge`)
@@ -2139,22 +2094,20 @@ def triangulate(
     face_map_double: duplicate faces
 
     type dict mapping vert/edge/face types to `bmesh.types.BMVert`/`bmesh.types.BMEdge`/`bmesh.types.BMFace`
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...
 
 def unsubdivide(
-    bm: bmesh.types.BMesh,
-    verts: typing.List[bmesh.types.BMVert] = [],
-    iterations: int = 0,
+    bm: bmesh.types.BMesh, verts: list[bmesh.types.BMVert] = [], iterations: int = 0
 ):
     """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: typing.List[bmesh.types.BMVert]
+    :type verts: list[bmesh.types.BMVert]
     :param iterations: number of times to unsubdivide
     :type iterations: int
     """
@@ -2175,7 +2128,7 @@ def weld_verts(bm: bmesh.types.BMesh, targetmap={}):
 
 def wireframe(
     bm: bmesh.types.BMesh,
-    faces: typing.List[bmesh.types.BMFace] = [],
+    faces: list[bmesh.types.BMFace] = [],
     thickness: float = 0,
     offset: float = 0,
     use_replace: bool = False,
@@ -2185,13 +2138,13 @@ def wireframe(
     crease_weight: float = 0,
     use_relative_offset: bool = False,
     material_offset: int = 0,
-) -> typing.Dict[str, typing.Any]:
+) -> dict[str, typing.Any]:
     """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: typing.List[bmesh.types.BMFace]
+        :type faces: list[bmesh.types.BMFace]
         :param thickness: thickness
         :type thickness: float
         :param offset: offset the thickness from the center
@@ -2213,7 +2166,7 @@ def wireframe(
         :return: faces: output faces
 
     type list of (`bmesh.types.BMFace`)
-        :rtype: typing.Dict[str, typing.Any]
+        :rtype: dict[str, typing.Any]
     """
 
     ...