fake-bpy-module 20240210__py3-none-any.whl → 20240326__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -1,4 +1,3 @@
-import sys
 import typing
 import bpy.types
 import mathutils
@@ -6,41 +5,46 @@ import mathutils
 GenericType = typing.TypeVar("GenericType")
 
 class BMDeformVert:
+    """ """
+
     def clear(self):
         """Clears all weights."""
         ...
 
-    def get(self, key: int, default: typing.Any = None):
-        """Returns the deform weight matching the key or default when not found (matches Python's dictionary function of the same name).
+    def get(self, key: int, default=None):
+        """Returns the deform weight matching the key or default
+        when not found (matches Python's dictionary function of the same name).
 
-        :param key: The key associated with deform weight.
-        :type key: int
-        :param default: Optional argument for the value to return if *key* is not found.
-        :type default: typing.Any
+                :param key: The key associated with deform weight.
+                :type key: int
+                :param default: Optional argument for the value to return if
+        key is not found.
         """
         ...
 
-    def items(self) -> typing.List:
-        """Return (group, weight) pairs for this vertex (matching Python's dict.items() functionality).
+    def items(self):
+        """Return (group, weight) pairs for this vertex
+        (matching Python's dict.items() functionality).
 
-        :rtype: typing.List
-        :return: (key, value) pairs for each deform weight of this vertex.
+                :return: (key, value) pairs for each deform weight of this vertex.
         """
         ...
 
-    def keys(self) -> typing.List[int]:
-        """Return the group indices used by this vertex (matching Python's dict.keys() functionality).
+    def keys(self):
+        """Return the group indices used by this vertex
+        (matching Python's dict.keys() functionality).
 
-        :rtype: typing.List[int]
-        :return: the deform group this vertex uses
+                :return: the deform group this vertex uses
+                :rtype: typing.List[int]
         """
         ...
 
-    def values(self) -> typing.List[float]:
-        """Return the weights of the deform vertex (matching Python's dict.values() functionality).
+    def values(self) -> typing.List[int]:
+        """Return the weights of the deform vertex
+        (matching Python's dict.values() functionality).
 
-        :rtype: typing.List[float]
-        :return: The weights that influence this vertex
+                :return: The weights that influence this vertex
+                :rtype: typing.List[float]
         """
         ...
 
@@ -95,16 +99,16 @@ class BMEdge:
     :type: bool
     """
 
-    link_faces: typing.Union[typing.List["BMFace"], "BMElemSeq"]
+    link_faces: typing.Union[typing.List[BMFace], BMElemSeq]
     """ Faces connected to this edge, (read-only).
 
-    :type: typing.Union[typing.List['BMFace'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMFace], BMElemSeq]
     """
 
-    link_loops: typing.Union[typing.List["BMLoop"], "BMElemSeq"]
+    link_loops: typing.Union[typing.List[BMLoop], BMElemSeq]
     """ Loops connected to this edge, (read-only).
 
-    :type: typing.Union[typing.List['BMLoop'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
     """
 
     seam: bool
@@ -131,59 +135,66 @@ class BMEdge:
     :type: bool
     """
 
-    verts: typing.Union[typing.List["BMVert"], "BMElemSeq"]
+    verts: typing.Union[typing.List[BMVert], BMElemSeq]
     """ Verts this edge uses (always 2), (read-only).
 
-    :type: typing.Union[typing.List['BMVert'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMVert], BMElemSeq]
     """
 
-    def calc_face_angle(self, fallback: typing.Any = None) -> float:
+    def calc_face_angle(self, fallback: typing.Any = None) -> typing.Any:
         """
 
-        :param fallback: return this when the edge doesn't have 2 faces (instead of raising a :exc:`ValueError`).
-        :type fallback: typing.Any
-        :rtype: float
-        :return: The angle between 2 connected faces in radians.
+                :param fallback: return this when the edge doesn't have 2 faces
+        (instead of raising a `ValueError`).
+                :type fallback: typing.Any
+                :return: The angle between 2 connected faces in radians.
+                :rtype: float
         """
         ...
 
-    def calc_face_angle_signed(self, fallback: typing.Any = None) -> float:
+    def calc_face_angle_signed(self, fallback: typing.Any = None) -> typing.Any:
         """
 
-        :param fallback: return this when the edge doesn't have 2 faces (instead of raising a :exc:`ValueError`).
-        :type fallback: typing.Any
-        :rtype: float
-        :return: The angle between 2 connected faces in radians (negative for concave join).
+                :param fallback: return this when the edge doesn't have 2 faces
+        (instead of raising a `ValueError`).
+                :type fallback: typing.Any
+                :return: The angle between 2 connected faces in radians (negative for concave join).
+                :rtype: float
         """
         ...
 
     def calc_length(self) -> float:
         """
 
-        :rtype: float
         :return: The length between both verts.
+        :rtype: float
         """
         ...
 
-    def calc_tangent(self, loop: "BMLoop") -> "mathutils.Vector":
-        """Return the tangent at this edge relative to a face (pointing inward into the face). This uses the face normal for calculation.
+    def calc_tangent(self, loop: BMLoop) -> BMLoop:
+        """Return the tangent at this edge relative to a face (pointing inward into the face).
+        This uses the face normal for calculation.
 
-        :param loop: The loop used for tangent calculation.
-        :type loop: 'BMLoop'
-        :rtype: 'mathutils.Vector'
-        :return: a normalized vector.
+                :param loop: The loop used for tangent calculation.
+                :type loop: BMLoop
+                :return: a normalized vector.
+                :rtype: mathutils.Vector
         """
         ...
 
     def copy_from(self, other):
-        """Copy values from another element of matching type."""
+        """Copy values from another element of matching type.
+
+        :param other:
+        """
         ...
 
     def hide_set(self, hide: bool):
-        """Set the hide state. This is different from the *hide* attribute because it updates the selection and hide state of associated geometry.
+        """Set the hide state.
+        This is different from the hide attribute because it updates the selection and hide state of associated geometry.
 
-        :param hide: Hidden or visible.
-        :type hide: bool
+                :param hide: Hidden or visible.
+                :type hide: bool
         """
         ...
 
@@ -191,137 +202,152 @@ class BMEdge:
         """Update normals of all connected faces and the edge verts."""
         ...
 
-    def other_vert(self, vert: "BMVert") -> "BMVert":
+    def other_vert(self, vert: BMVert) -> BMVert:
         """Return the other vertex on this edge or None if the vertex is not used by this edge.
 
         :param vert: a vert in this edge.
-        :type vert: 'BMVert'
-        :rtype: 'BMVert'
+        :type vert: BMVert
         :return: The edges other vert.
         """
         ...
 
     def select_set(self, select: bool):
-        """Set the selection. This is different from the *select* attribute because it updates the selection state of associated geometry.
+        """Set the selection.
+        This is different from the select attribute because it updates the selection state of associated geometry.
 
-        :param select: Select or de-select.
-        :type select: bool
+                :param select: Select or de-select.
+                :type select: bool
         """
         ...
 
 class BMEdgeSeq:
-    layers: "BMLayerAccessEdge"
+    """ """
+
+    layers: BMLayerAccessEdge
     """ custom-data layers (read-only).
 
-    :type: 'BMLayerAccessEdge'
+    :type: BMLayerAccessEdge
     """
 
     def ensure_lookup_table(self):
-        """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg ``bm.verts[index]``. This needs to be called again after adding/removing data in this sequence."""
+        """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
         ...
 
-    def get(self, verts: "BMVert", fallback: typing.Any = None) -> "BMEdge":
-        """Return an edge which uses the **verts** passed.
+    def get(self, verts: BMVert, fallback=None):
+        """Return an edge which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: 'BMVert'
-        :param fallback:  Return this value if nothing is found.
-        :type fallback: typing.Any
-        :rtype: 'BMEdge'
+        :type verts: BMVert
+        :param fallback: Return this value if nothing is found.
         :return: The edge found or None
+        :rtype: BMEdge
         """
         ...
 
     def index_update(self):
-        """Initialize the index values of this sequence. This is the equivalent of looping over all elements and assigning the index values."""
+        """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
         ...
 
-    def new(self, verts: "BMVert", example: "BMEdge" = None) -> "BMEdge":
+    def new(self, verts, example: BMEdge = None) -> BMEdge:
         """Create a new edge from a given pair of verts.
 
         :param verts: Vertex pair.
-        :type verts: 'BMVert'
         :param example: Existing edge to initialize settings (optional argument).
-        :type example: 'BMEdge'
-        :rtype: 'BMEdge'
+        :type example: BMEdge
         :return: The newly created edge.
+        :rtype: BMEdge
         """
         ...
 
     def remove(self, edge):
-        """Remove an edge."""
+        """Remove an edge.
+
+        :param edge:
+        """
         ...
 
-    def sort(self, key: typing.Any = None, reverse: typing.Any = False):
-        """Sort the elements of this sequence, using an optional custom sort key. Indices of elements are not changed, BMElemeSeq.index_update() can be used for that.
+    def sort(self, key=None, reverse=False):
+        """Sort the elements of this sequence, using an optional custom sort key.
+        Indices of elements are not changed, BMElemeSeq.index_update() can be used for that.
 
-        :param key: The key that sets the ordering of the elements.
-        :type key: typing.Any
-        :param reverse: Reverse the order of the elements
-        :type reverse: typing.Any
+                :param key: The key that sets the ordering of the elements.
+                :param reverse: Reverse the order of the elements
         """
         ...
 
-    def __getitem__(self, key: int) -> "BMEdge":
+    def __getitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMEdge'
+        :return:
+        :rtype: BMEdge
         """
         ...
 
-    def __setitem__(self, key: int, value: "BMEdge"):
+    def __setitem__(self, key: int, value: BMEdge):
         """
 
         :param key:
         :type key: int
         :param value:
-        :type value: 'BMEdge'
+        :type value: BMEdge
         """
         ...
 
-    def __delitem__(self, key: int) -> "BMEdge":
+    def __delitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMEdge'
+        :return:
+        :rtype: BMEdge
         """
         ...
 
-    def __iter__(self) -> typing.Iterator["BMEdge"]:
+    def __iter__(self) -> BMEdge:
         """
 
-        :rtype: typing.Iterator['BMEdge']
+        :return:
+        :rtype: typing.Iterator[GenericType]
         """
         ...
 
-    def __next__(self) -> "BMEdge":
+    def __next__(self) -> typing.Iterator[GenericType]:
         """
 
-        :rtype: 'BMEdge'
+        :return:
+        :rtype: GenericType
         """
         ...
 
-    def __len__(self) -> int:
+    def __len__(self) -> GenericType:
         """
 
+        :return:
         :rtype: int
         """
         ...
 
-class BMEditSelIter: ...
+class BMEditSelIter:
+    """ """
+
+    ...
 
 class BMEditSelSeq:
-    active: typing.Union["BMVert", "BMEdge", "BMFace"]
+    """ """
+
+    active: typing.Union[BMVert, BMEdge, BMFace]
     """ The last selected element or None (read-only).
 
-    :type: typing.Union['BMVert', 'BMEdge', 'BMFace']
+    :type: typing.Union[BMVert, BMEdge, BMFace]
     """
 
     def add(self, element):
-        """Add an element to the selection history (no action taken if its already added)."""
+        """Add an element to the selection history (no action taken if its already added).
+
+        :param element:
+        """
         ...
 
     def clear(self):
@@ -329,11 +355,17 @@ class BMEditSelSeq:
         ...
 
     def discard(self, element):
-        """Discard an element from the selection history. Like remove but doesn't raise an error when the elements not in the selection list."""
+        """Discard an element from the selection history.Like remove but doesn't raise an error when the elements not in the selection list.
+
+        :param element:
+        """
         ...
 
     def remove(self, element):
-        """Remove an element from the selection history."""
+        """Remove an element from the selection history.
+
+        :param element:
+        """
         ...
 
     def validate(self):
@@ -341,57 +373,65 @@ class BMEditSelSeq:
         ...
 
 class BMElemSeq:
-    """General sequence type used for accessing any sequence of `BMVert`, `BMEdge`, `BMFace`, `BMLoop`. When accessed via `BMesh.verts`, `BMesh.edges`, `BMesh.faces` there are also functions to create/remove items."""
+    """General sequence type used for accessing any sequence of
+    `BMVert`, `BMEdge`, `BMFace`, `BMLoop`.When accessed via `BMesh.verts`, `BMesh.edges`, `BMesh.faces`
+    there are also functions to create/remove items.
+    """
 
     def index_update(self):
-        """Initialize the index values of this sequence. This is the equivalent of looping over all elements and assigning the index values."""
+        """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
         ...
 
-    def __getitem__(self, key: int) -> "GenericType":
+    def __getitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'GenericType'
+        :return:
+        :rtype: GenericType
         """
         ...
 
-    def __setitem__(self, key: int, value: "GenericType"):
+    def __setitem__(self, key: int, value: GenericType):
         """
 
         :param key:
         :type key: int
         :param value:
-        :type value: 'GenericType'
+        :type value: GenericType
         """
         ...
 
-    def __delitem__(self, key: int) -> "GenericType":
+    def __delitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'GenericType'
+        :return:
+        :rtype: GenericType
         """
         ...
 
-    def __iter__(self) -> typing.Iterator["GenericType"]:
+    def __iter__(self) -> GenericType:
         """
 
-        :rtype: typing.Iterator['GenericType']
+        :return:
+        :rtype: typing.Iterator[GenericType]
         """
         ...
 
-    def __next__(self) -> "GenericType":
+    def __next__(self) -> typing.Iterator[GenericType]:
         """
 
-        :rtype: 'GenericType'
+        :return:
+        :rtype: GenericType
         """
         ...
 
-    def __len__(self) -> int:
+    def __len__(self) -> GenericType:
         """
 
+        :return:
         :rtype: int
         """
         ...
@@ -399,10 +439,10 @@ class BMElemSeq:
 class BMFace:
     """The BMesh face with 3 or more sides"""
 
-    edges: typing.Union[typing.List["BMEdge"], "BMElemSeq"]
+    edges: typing.Union[typing.List[BMEdge], BMElemSeq]
     """ Edges of this face, (read-only).
 
-    :type: typing.Union[typing.List['BMEdge'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMEdge], BMElemSeq]
     """
 
     hide: bool
@@ -423,10 +463,10 @@ class BMFace:
     :type: bool
     """
 
-    loops: typing.Union[typing.List["BMLoop"], "BMElemSeq"]
+    loops: typing.Union[typing.List[BMLoop], BMElemSeq]
     """ Loops of this face, (read-only).
 
-    :type: typing.Union[typing.List['BMLoop'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
     """
 
     material_index: int
@@ -435,10 +475,10 @@ class BMFace:
     :type: int
     """
 
-    normal: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    normal: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal for this face as a 3D, wrapped vector.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     select: bool
@@ -459,115 +499,119 @@ class BMFace:
     :type: bool
     """
 
-    verts: typing.Union[typing.List["BMVert"], "BMElemSeq"]
+    verts: typing.Union[typing.List[BMVert], BMElemSeq]
     """ Verts of this face, (read-only).
 
-    :type: typing.Union[typing.List['BMVert'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMVert], BMElemSeq]
     """
 
-    def calc_area(self) -> float:
+    def calc_area(self) -> typing.Union[typing.List[BMVert], BMElemSeq]:
         """Return the area of the face.
 
-        :rtype: float
         :return: Return the area of the face.
+        :rtype: float
         """
         ...
 
-    def calc_center_bounds(self) -> "mathutils.Vector":
+    def calc_center_bounds(self) -> float:
         """Return bounds center of the face.
 
-        :rtype: 'mathutils.Vector'
         :return: a 3D vector.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def calc_center_median(self) -> "mathutils.Vector":
+    def calc_center_median(self) -> mathutils.Vector:
         """Return median center of the face.
 
-        :rtype: 'mathutils.Vector'
         :return: a 3D vector.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def calc_center_median_weighted(self) -> "mathutils.Vector":
+    def calc_center_median_weighted(self) -> mathutils.Vector:
         """Return median center of the face weighted by edge lengths.
 
-        :rtype: 'mathutils.Vector'
         :return: a 3D vector.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def calc_perimeter(self) -> float:
+    def calc_perimeter(self) -> mathutils.Vector:
         """Return the perimeter of the face.
 
-        :rtype: float
         :return: Return the perimeter of the face.
+        :rtype: float
         """
         ...
 
-    def calc_tangent_edge(self) -> "mathutils.Vector":
+    def calc_tangent_edge(self) -> float:
         """Return face tangent based on longest edge.
 
-        :rtype: 'mathutils.Vector'
         :return: a normalized vector.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def calc_tangent_edge_diagonal(self) -> "mathutils.Vector":
+    def calc_tangent_edge_diagonal(self) -> mathutils.Vector:
         """Return face tangent based on the edge farthest from any vertex.
 
-        :rtype: 'mathutils.Vector'
         :return: a normalized vector.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def calc_tangent_edge_pair(self) -> "mathutils.Vector":
-        """Return face tangent based on the two longest disconnected edges. - Tris: Use the edge pair with the most similar lengths. - Quads: Use the longest edge pair. - NGons: Use the two longest disconnected edges.
+    def calc_tangent_edge_pair(self) -> mathutils.Vector:
+        """Return face tangent based on the two longest disconnected edges.
 
-        :rtype: 'mathutils.Vector'
         :return: a normalized vector.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def calc_tangent_vert_diagonal(self) -> "mathutils.Vector":
+    def calc_tangent_vert_diagonal(self) -> mathutils.Vector:
         """Return face tangent based on the two most distant vertices.
 
-        :rtype: 'mathutils.Vector'
         :return: a normalized vector.
+        :rtype: mathutils.Vector
         """
         ...
 
-    def copy(self, verts: bool = True, edges: bool = True) -> "BMFace":
+    def copy(self, verts: bool = True, edges: bool = True) -> bool:
         """Make a copy of this face.
 
         :param verts: When set, the faces verts will be duplicated too.
         :type verts: bool
         :param edges: When set, the faces edges will be duplicated too.
         :type edges: bool
-        :rtype: 'BMFace'
         :return: The newly created face.
+        :rtype: BMFace
         """
         ...
 
     def copy_from(self, other):
-        """Copy values from another element of matching type."""
+        """Copy values from another element of matching type.
+
+        :param other:
+        """
         ...
 
-    def copy_from_face_interp(self, face: "BMFace", vert: bool = True):
+    def copy_from_face_interp(self, face: BMFace, vert: bool = True):
         """Interpolate the customdata from another face onto this one (faces should overlap).
 
         :param face: The face to interpolate data from.
-        :type face: 'BMFace'
+        :type face: BMFace
         :param vert: When True, also copy vertex data.
         :type vert: bool
         """
         ...
 
     def hide_set(self, hide: bool):
-        """Set the hide state. This is different from the *hide* attribute because it updates the selection and hide state of associated geometry.
+        """Set the hide state.
+        This is different from the hide attribute because it updates the selection and hide state of associated geometry.
 
-        :param hide: Hidden or visible.
-        :type hide: bool
+                :param hide: Hidden or visible.
+                :type hide: bool
         """
         ...
 
@@ -576,129 +620,138 @@ class BMFace:
         ...
 
     def normal_update(self):
-        """Update face normal based on the positions of the face verts. This does not update the normals of face verts."""
+        """Update face normal based on the positions of the face verts.
+        This does not update the normals of face verts.
+
+        """
         ...
 
     def select_set(self, select: bool):
-        """Set the selection. This is different from the *select* attribute because it updates the selection state of associated geometry.
+        """Set the selection.
+        This is different from the select attribute because it updates the selection state of associated geometry.
 
-        :param select: Select or de-select.
-        :type select: bool
+                :param select: Select or de-select.
+                :type select: bool
         """
         ...
 
 class BMFaceSeq:
-    active: "BMFace"
-    """ active face.
+    """ """
 
-    :type: 'BMFace'
-    """
+    active: typing.Any
+    """ active face."""
 
-    layers: "BMLayerAccessFace"
+    layers: BMLayerAccessFace
     """ custom-data layers (read-only).
 
-    :type: 'BMLayerAccessFace'
+    :type: BMLayerAccessFace
     """
 
     def ensure_lookup_table(self):
-        """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg ``bm.verts[index]``. This needs to be called again after adding/removing data in this sequence."""
+        """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
         ...
 
-    def get(self, verts: "BMVert", fallback: typing.Any = None) -> "BMFace":
-        """Return a face which uses the **verts** passed.
+    def get(self, verts: BMVert, fallback=None):
+        """Return a face which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: 'BMVert'
-        :param fallback:  Return this value if nothing is found.
-        :type fallback: typing.Any
-        :rtype: 'BMFace'
+        :type verts: BMVert
+        :param fallback: Return this value if nothing is found.
         :return: The face found or None
+        :rtype: BMFace
         """
         ...
 
     def index_update(self):
-        """Initialize the index values of this sequence. This is the equivalent of looping over all elements and assigning the index values."""
+        """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
         ...
 
-    def new(
-        self, verts: typing.Iterable["BMVert"], example: "BMFace" = None
-    ) -> "BMFace":
+    def new(self, verts: typing.Iterable[BMVert], example: BMFace = None) -> BMFace:
         """Create a new face from a given set of verts.
 
         :param verts: Sequence of 3 or more verts.
-        :type verts: typing.Iterable['BMVert']
+        :type verts: typing.Iterable[BMVert]
         :param example: Existing face to initialize settings (optional argument).
-        :type example: 'BMFace'
-        :rtype: 'BMFace'
+        :type example: BMFace
         :return: The newly created face.
+        :rtype: BMFace
         """
         ...
 
     def remove(self, face):
-        """Remove a face."""
+        """Remove a face.
+
+        :param face:
+        """
         ...
 
-    def sort(self, key: typing.Any = None, reverse: typing.Any = False):
-        """Sort the elements of this sequence, using an optional custom sort key. Indices of elements are not changed, BMElemeSeq.index_update() can be used for that.
+    def sort(self, key=None, reverse=False):
+        """Sort the elements of this sequence, using an optional custom sort key.
+        Indices of elements are not changed, BMElemeSeq.index_update() can be used for that.
 
-        :param key: The key that sets the ordering of the elements.
-        :type key: typing.Any
-        :param reverse: Reverse the order of the elements
-        :type reverse: typing.Any
+                :param key: The key that sets the ordering of the elements.
+                :param reverse: Reverse the order of the elements
         """
         ...
 
-    def __getitem__(self, key: int) -> "BMFace":
+    def __getitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMFace'
+        :return:
+        :rtype: BMFace
         """
         ...
 
-    def __setitem__(self, key: int, value: "BMFace"):
+    def __setitem__(self, key: int, value: BMFace):
         """
 
         :param key:
         :type key: int
         :param value:
-        :type value: 'BMFace'
+        :type value: BMFace
         """
         ...
 
-    def __delitem__(self, key: int) -> "BMFace":
+    def __delitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMFace'
+        :return:
+        :rtype: BMFace
         """
         ...
 
-    def __iter__(self) -> typing.Iterator["BMFace"]:
+    def __iter__(self) -> BMFace:
         """
 
-        :rtype: typing.Iterator['BMFace']
+        :return:
+        :rtype: typing.Iterator[GenericType]
         """
         ...
 
-    def __next__(self) -> "BMFace":
+    def __next__(self) -> typing.Iterator[GenericType]:
         """
 
-        :rtype: 'BMFace'
+        :return:
+        :rtype: GenericType
         """
         ...
 
-    def __len__(self) -> int:
+    def __len__(self) -> GenericType:
         """
 
+        :return:
         :rtype: int
         """
         ...
 
 class BMIter:
-    """Internal BMesh type for looping over verts/faces/edges, used for iterating over `BMElemSeq` types."""
+    """Internal BMesh type for looping over verts/faces/edges,
+    used for iterating over `BMElemSeq` types.
+    """
 
     ...
 
@@ -706,114 +759,114 @@ class BMLayerAccessEdge:
     """Exposes custom-data layer attributes."""
 
     color: typing.Any
-    """ Generic RGBA color with 8-bit precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with 8-bit precision custom-data layer.type: `BMLayerCollection`"""
 
     float: typing.Any
-    """ Generic float custom-data layer. type: `BMLayerCollection`"""
+    """ Generic float custom-data layer.type: `BMLayerCollection`"""
 
     float_color: typing.Any
-    """ Generic RGBA color with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with float precision custom-data layer.type: `BMLayerCollection`"""
 
     float_vector: typing.Any
-    """ Generic 3D vector with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic 3D vector with float precision custom-data layer.type: `BMLayerCollection`"""
 
     freestyle: typing.Any
-    """ Accessor for Freestyle edge layer. type: `BMLayerCollection`"""
+    """ Accessor for Freestyle edge layer.type: `BMLayerCollection`"""
 
     int: typing.Any
-    """ Generic int custom-data layer. type: `BMLayerCollection`"""
+    """ Generic int custom-data layer.type: `BMLayerCollection`"""
 
     string: typing.Any
-    """ Generic string custom-data layer (exposed as bytes, 255 max length). type: `BMLayerCollection`"""
+    """ Generic string custom-data layer (exposed as bytes, 255 max length).type: `BMLayerCollection`"""
 
 class BMLayerAccessFace:
     """Exposes custom-data layer attributes."""
 
     color: typing.Any
-    """ Generic RGBA color with 8-bit precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with 8-bit precision custom-data layer.type: `BMLayerCollection`"""
 
     float: typing.Any
-    """ Generic float custom-data layer. type: `BMLayerCollection`"""
+    """ Generic float custom-data layer.type: `BMLayerCollection`"""
 
     float_color: typing.Any
-    """ Generic RGBA color with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with float precision custom-data layer.type: `BMLayerCollection`"""
 
     float_vector: typing.Any
-    """ Generic 3D vector with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic 3D vector with float precision custom-data layer.type: `BMLayerCollection`"""
 
     freestyle: typing.Any
-    """ Accessor for Freestyle face layer. type: `BMLayerCollection`"""
+    """ Accessor for Freestyle face layer.type: `BMLayerCollection`"""
 
     int: typing.Any
-    """ Generic int custom-data layer. type: `BMLayerCollection`"""
+    """ Generic int custom-data layer.type: `BMLayerCollection`"""
 
     string: typing.Any
-    """ Generic string custom-data layer (exposed as bytes, 255 max length). type: `BMLayerCollection`"""
+    """ Generic string custom-data layer (exposed as bytes, 255 max length).type: `BMLayerCollection`"""
 
 class BMLayerAccessLoop:
     """Exposes custom-data layer attributes."""
 
     color: typing.Any
-    """ Generic RGBA color with 8-bit precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with 8-bit precision custom-data layer.type: `BMLayerCollection`"""
 
     float: typing.Any
-    """ Generic float custom-data layer. type: `BMLayerCollection`"""
+    """ Generic float custom-data layer.type: `BMLayerCollection`"""
 
     float_color: typing.Any
-    """ Generic RGBA color with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with float precision custom-data layer.type: `BMLayerCollection`"""
 
     float_vector: typing.Any
-    """ Generic 3D vector with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic 3D vector with float precision custom-data layer.type: `BMLayerCollection`"""
 
     int: typing.Any
-    """ Generic int custom-data layer. type: `BMLayerCollection`"""
+    """ Generic int custom-data layer.type: `BMLayerCollection`"""
 
     string: typing.Any
-    """ Generic string custom-data layer (exposed as bytes, 255 max length). type: `BMLayerCollection`"""
+    """ Generic string custom-data layer (exposed as bytes, 255 max length).type: `BMLayerCollection`"""
 
     uv: typing.Any
-    """ Accessor for `BMLoopUV` UV (as a 2D Vector). type: `BMLayerCollection`"""
+    """ Accessor for `BMLoopUV` UV (as a 2D Vector).type: `BMLayerCollection`"""
 
 class BMLayerAccessVert:
     """Exposes custom-data layer attributes."""
 
     color: typing.Any
-    """ Generic RGBA color with 8-bit precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with 8-bit precision custom-data layer.type: `BMLayerCollection`"""
 
     deform: typing.Any
-    """ Vertex deform weight `BMDeformVert` (TODO). type: `BMLayerCollection`"""
+    """ Vertex deform weight `BMDeformVert` (TODO).type: `BMLayerCollection`"""
 
     float: typing.Any
-    """ Generic float custom-data layer. type: `BMLayerCollection`"""
+    """ Generic float custom-data layer.type: `BMLayerCollection`"""
 
     float_color: typing.Any
-    """ Generic RGBA color with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic RGBA color with float precision custom-data layer.type: `BMLayerCollection`"""
 
     float_vector: typing.Any
-    """ Generic 3D vector with float precision custom-data layer. type: `BMLayerCollection`"""
+    """ Generic 3D vector with float precision custom-data layer.type: `BMLayerCollection`"""
 
     int: typing.Any
-    """ Generic int custom-data layer. type: `BMLayerCollection`"""
+    """ Generic int custom-data layer.type: `BMLayerCollection`"""
 
-    shape: "BMLayerCollection"
+    shape: BMLayerCollection
     """ Vertex shapekey absolute location (as a 3D Vector).
 
-    :type: 'BMLayerCollection'
+    :type: BMLayerCollection
     """
 
     skin: typing.Any
-    """ Accessor for skin layer. type: `BMLayerCollection`"""
+    """ Accessor for skin layer.type: `BMLayerCollection`"""
 
     string: typing.Any
-    """ Generic string custom-data layer (exposed as bytes, 255 max length). type: `BMLayerCollection`"""
+    """ Generic string custom-data layer (exposed as bytes, 255 max length).type: `BMLayerCollection`"""
 
 class BMLayerCollection:
     """Gives access to a collection of custom-data layers of the same type and behaves like Python dictionaries, except for the ability to do list like index access."""
 
-    active: "BMLayerItem"
+    active: BMLayerItem
     """ The active layer of this type (read-only).
 
-    :type: 'BMLayerItem'
+    :type: BMLayerItem
     """
 
     is_singleton: bool
@@ -822,63 +875,66 @@ class BMLayerCollection:
     :type: bool
     """
 
-    def get(self, key: str, default: typing.Any = None):
-        """Returns the value of the layer matching the key or default when not found (matches Python's dictionary function of the same name).
+    def get(self, key: str, default=None):
+        """Returns the value of the layer matching the key or default
+        when not found (matches Python's dictionary function of the same name).
 
-        :param key: The key associated with the layer.
-        :type key: str
-        :param default: Optional argument for the value to return if *key* is not found.
-        :type default: typing.Any
+                :param key: The key associated with the layer.
+                :type key: str
+                :param default: Optional argument for the value to return if
+        key is not found.
         """
         ...
 
-    def items(self) -> typing.List:
-        """Return the identifiers of collection members (matching Python's dict.items() functionality).
+    def items(self):
+        """Return the identifiers of collection members
+        (matching Python's dict.items() functionality).
 
-        :rtype: typing.List
-        :return: (key, value) pairs for each member of this collection.
+                :return: (key, value) pairs for each member of this collection.
         """
         ...
 
-    def keys(self) -> typing.List[str]:
-        """Return the identifiers of collection members (matching Python's dict.keys() functionality).
+    def keys(self):
+        """Return the identifiers of collection members
+        (matching Python's dict.keys() functionality).
 
-        :rtype: typing.List[str]
-        :return: the identifiers for each member of this collection.
+                :return: the identifiers for each member of this collection.
+                :rtype: typing.List[str]
         """
         ...
 
-    def new(self, name: str) -> "BMLayerItem":
+    def new(self, name: str) -> str:
         """Create a new layer
 
         :param name: Optional name argument (will be made unique).
         :type name: str
-        :rtype: 'BMLayerItem'
         :return: The newly created layer.
+        :rtype: BMLayerItem
         """
         ...
 
-    def remove(self, layer: "BMLayerItem"):
+    def remove(self, layer: BMLayerItem):
         """Remove a layer
 
         :param layer: The layer to remove.
-        :type layer: 'BMLayerItem'
+        :type layer: BMLayerItem
         """
         ...
 
-    def values(self) -> typing.List:
-        """Return the values of collection (matching Python's dict.values() functionality).
+    def values(self) -> BMLayerItem:
+        """Return the values of collection
+        (matching Python's dict.values() functionality).
 
-        :rtype: typing.List
-        :return: the members of this collection.
+                :return: the members of this collection.
+                :rtype: list
         """
         ...
 
-    def verify(self) -> "BMLayerItem":
+    def verify(self) -> list:
         """Create a new layer or return an existing active layer
 
-        :rtype: 'BMLayerItem'
         :return: The newly verified layer.
+        :rtype: BMLayerItem
         """
         ...
 
@@ -891,29 +947,26 @@ class BMLayerItem:
     :type: str
     """
 
-    def copy_from(self, other: typing.Any):
+    def copy_from(self, other):
         """Return a copy of the layer
 
-        :param other:  Another layer to copy from.
-        :type other: typing.Any
-        :param other:  `BMLayerItem`
-        :type other: typing.Any
+        :param other: Another layer to copy from.`BMLayerItem`
         """
         ...
 
 class BMLoop:
     """This is normally accessed from `BMFace.loops` where each face loop represents a corner of the face."""
 
-    edge: "BMEdge"
+    edge: BMEdge
     """ The loop's edge (between this loop and the next), (read-only).
 
-    :type: 'BMEdge'
+    :type: BMEdge
     """
 
-    face: "BMFace"
+    face: BMFace
     """ The face this loop makes (read-only).
 
-    :type: 'BMFace'
+    :type: BMFace
     """
 
     index: int
@@ -934,34 +987,34 @@ class BMLoop:
     :type: bool
     """
 
-    link_loop_next: "BMLoop"
+    link_loop_next: BMLoop
     """ The next face corner (read-only).
 
-    :type: 'BMLoop'
+    :type: BMLoop
     """
 
-    link_loop_prev: "BMLoop"
+    link_loop_prev: BMLoop
     """ The previous face corner (read-only).
 
-    :type: 'BMLoop'
+    :type: BMLoop
     """
 
-    link_loop_radial_next: "BMLoop"
+    link_loop_radial_next: BMLoop
     """ The next loop around the edge (read-only).
 
-    :type: 'BMLoop'
+    :type: BMLoop
     """
 
-    link_loop_radial_prev: "BMLoop"
+    link_loop_radial_prev: BMLoop
     """ The previous loop around the edge (read-only).
 
-    :type: 'BMLoop'
+    :type: BMLoop
     """
 
-    link_loops: typing.Union[typing.List["BMLoop"], "BMElemSeq"]
+    link_loops: typing.Union[typing.List[BMLoop], BMElemSeq]
     """ Loops connected to this loop, (read-only).
 
-    :type: typing.Union[typing.List['BMLoop'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
     """
 
     tag: bool
@@ -970,47 +1023,53 @@ class BMLoop:
     :type: bool
     """
 
-    vert: "BMVert"
+    vert: BMVert
     """ The loop's vertex (read-only).
 
-    :type: 'BMVert'
+    :type: BMVert
     """
 
-    def calc_angle(self) -> float:
-        """Return the angle at this loops corner of the face. This is calculated so sharper corners give lower angles.
+    def calc_angle(self) -> BMVert:
+        """Return the angle at this loops corner of the face.
+        This is calculated so sharper corners give lower angles.
 
-        :rtype: float
-        :return: The angle in radians.
+                :return: The angle in radians.
+                :rtype: float
         """
         ...
 
-    def calc_normal(self) -> "mathutils.Vector":
-        """Return normal at this loops corner of the face. Falls back to the face normal for straight lines.
+    def calc_normal(self) -> float:
+        """Return normal at this loops corner of the face.
+        Falls back to the face normal for straight lines.
 
-        :rtype: 'mathutils.Vector'
-        :return: a normalized vector.
+                :return: a normalized vector.
+                :rtype: mathutils.Vector
         """
         ...
 
-    def calc_tangent(self) -> "mathutils.Vector":
-        """Return the tangent at this loops corner of the face (pointing inward into the face). Falls back to the face normal for straight lines.
+    def calc_tangent(self) -> mathutils.Vector:
+        """Return the tangent at this loops corner of the face (pointing inward into the face).
+        Falls back to the face normal for straight lines.
 
-        :rtype: 'mathutils.Vector'
-        :return: a normalized vector.
+                :return: a normalized vector.
+                :rtype: mathutils.Vector
         """
         ...
 
     def copy_from(self, other):
-        """Copy values from another element of matching type."""
+        """Copy values from another element of matching type.
+
+        :param other:
+        """
         ...
 
     def copy_from_face_interp(
-        self, face: "BMFace", vert: bool = True, multires: bool = True
+        self, face: BMFace, vert: bool = True, multires: bool = True
     ):
         """Interpolate the customdata from a face onto this loop (the loops vert should overlap the face).
 
         :param face: The face to interpolate data from.
-        :type face: 'BMFace'
+        :type face: BMFace
         :param vert: When enabled, interpolate the loops vertex data (optional).
         :type vert: bool
         :param multires: When enabled, interpolate the loops multires data (optional).
@@ -1019,62 +1078,71 @@ class BMLoop:
         ...
 
 class BMLoopSeq:
-    layers: "BMLayerAccessLoop"
+    """ """
+
+    layers: BMLayerAccessLoop
     """ custom-data layers (read-only).
 
-    :type: 'BMLayerAccessLoop'
+    :type: BMLayerAccessLoop
     """
 
-    def __getitem__(self, key: int) -> "BMLoop":
+    def __getitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMLoop'
+        :return:
+        :rtype: BMLoop
         """
         ...
 
-    def __setitem__(self, key: int, value: "BMLoop"):
+    def __setitem__(self, key: int, value: BMLoop):
         """
 
         :param key:
         :type key: int
         :param value:
-        :type value: 'BMLoop'
+        :type value: BMLoop
         """
         ...
 
-    def __delitem__(self, key: int) -> "BMLoop":
+    def __delitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMLoop'
+        :return:
+        :rtype: BMLoop
         """
         ...
 
-    def __iter__(self) -> typing.Iterator["BMLoop"]:
+    def __iter__(self) -> BMLoop:
         """
 
-        :rtype: typing.Iterator['BMLoop']
+        :return:
+        :rtype: typing.Iterator[GenericType]
         """
         ...
 
-    def __next__(self) -> "BMLoop":
+    def __next__(self) -> typing.Iterator[GenericType]:
         """
 
-        :rtype: 'BMLoop'
+        :return:
+        :rtype: GenericType
         """
         ...
 
-    def __len__(self) -> int:
+    def __len__(self) -> GenericType:
         """
 
+        :return:
         :rtype: int
         """
         ...
 
 class BMLoopUV:
+    """ """
+
     pin_uv: bool
     """ UV pin state.
 
@@ -1093,19 +1161,19 @@ class BMLoopUV:
     :type: bool
     """
 
-    uv: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    uv: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ Loops UV (as a 2D Vector).
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
 class BMVert:
     """The BMesh vertex type"""
 
-    co: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    co: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The coordinates for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     hide: bool
@@ -1144,28 +1212,28 @@ class BMVert:
     :type: bool
     """
 
-    link_edges: typing.Union[typing.List["BMEdge"], "BMElemSeq"]
+    link_edges: typing.Union[typing.List[BMEdge], BMElemSeq]
     """ Edges connected to this vertex (read-only).
 
-    :type: typing.Union[typing.List['BMEdge'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMEdge], BMElemSeq]
     """
 
-    link_faces: typing.Union[typing.List["BMFace"], "BMElemSeq"]
+    link_faces: typing.Union[typing.List[BMFace], BMElemSeq]
     """ Faces connected to this vertex (read-only).
 
-    :type: typing.Union[typing.List['BMFace'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMFace], BMElemSeq]
     """
 
-    link_loops: typing.Union[typing.List["BMLoop"], "BMElemSeq"]
+    link_loops: typing.Union[typing.List[BMLoop], BMElemSeq]
     """ Loops that use this vertex (read-only).
 
-    :type: typing.Union[typing.List['BMLoop'], 'BMElemSeq']
+    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
     """
 
-    normal: typing.Union[typing.Sequence[float], "mathutils.Vector"]
+    normal: typing.Union[typing.Sequence[float], mathutils.Vector]
     """ The normal for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
     """
 
     select: bool
@@ -1180,154 +1248,175 @@ class BMVert:
     :type: bool
     """
 
-    def calc_edge_angle(self, fallback: typing.Any = None) -> float:
+    def calc_edge_angle(self, fallback: typing.Any = None) -> typing.Any:
         """Return the angle between this vert's two connected edges.
 
-        :param fallback: return this when the vert doesn't have 2 edges (instead of raising a :exc:`ValueError`).
-        :type fallback: typing.Any
-        :rtype: float
-        :return: Angle between edges in radians.
+                :param fallback: return this when the vert doesn't have 2 edges
+        (instead of raising a `ValueError`).
+                :type fallback: typing.Any
+                :return: Angle between edges in radians.
+                :rtype: float
         """
         ...
 
     def calc_shell_factor(self) -> float:
-        """Return a multiplier calculated based on the sharpness of the vertex. Where a flat surface gives 1.0, and higher values sharper edges. This is used to maintain shell thickness when offsetting verts along their normals.
+        """Return a multiplier calculated based on the sharpness of the vertex.
+        Where a flat surface gives 1.0, and higher values sharper edges.
+        This is used to maintain shell thickness when offsetting verts along their normals.
 
-        :rtype: float
-        :return: offset multiplier
+                :return: offset multiplier
+                :rtype: float
         """
         ...
 
     def copy_from(self, other):
-        """Copy values from another element of matching type."""
+        """Copy values from another element of matching type.
+
+        :param other:
+        """
         ...
 
-    def copy_from_face_interp(self, face: "BMFace"):
+    def copy_from_face_interp(self, face: BMFace):
         """Interpolate the customdata from a face onto this loop (the loops vert should overlap the face).
 
         :param face: The face to interpolate data from.
-        :type face: 'BMFace'
+        :type face: BMFace
         """
         ...
 
-    def copy_from_vert_interp(self, vert_pair: "BMVert", fac):
+    def copy_from_vert_interp(self, vert_pair: BMVert, fac):
         """Interpolate the customdata from a vert between 2 other verts.
 
         :param vert_pair: The vert to interpolate data from.
-        :type vert_pair: 'BMVert'
+        :type vert_pair: BMVert
+        :param fac:
         """
         ...
 
     def hide_set(self, hide: bool):
-        """Set the hide state. This is different from the *hide* attribute because it updates the selection and hide state of associated geometry.
+        """Set the hide state.
+        This is different from the hide attribute because it updates the selection and hide state of associated geometry.
 
-        :param hide: Hidden or visible.
-        :type hide: bool
+                :param hide: Hidden or visible.
+                :type hide: bool
         """
         ...
 
     def normal_update(self):
-        """Update vertex normal. This does not update the normals of adjoining faces."""
+        """Update vertex normal.
+        This does not update the normals of adjoining faces.
+
+        """
         ...
 
     def select_set(self, select: bool):
-        """Set the selection. This is different from the *select* attribute because it updates the selection state of associated geometry.
+        """Set the selection.
+        This is different from the select attribute because it updates the selection state of associated geometry.
 
-        :param select: Select or de-select.
-        :type select: bool
+                :param select: Select or de-select.
+                :type select: bool
         """
         ...
 
 class BMVertSeq:
-    layers: "BMLayerAccessVert"
+    """ """
+
+    layers: BMLayerAccessVert
     """ custom-data layers (read-only).
 
-    :type: 'BMLayerAccessVert'
+    :type: BMLayerAccessVert
     """
 
     def ensure_lookup_table(self):
-        """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg ``bm.verts[index]``. This needs to be called again after adding/removing data in this sequence."""
+        """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
         ...
 
     def index_update(self):
-        """Initialize the index values of this sequence. This is the equivalent of looping over all elements and assigning the index values."""
+        """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
         ...
 
     def new(
         self,
-        co: typing.Union[typing.Sequence[float], "mathutils.Vector"] = (0.0, 0.0, 0.0),
-        example: "BMVert" = None,
-    ) -> "BMVert":
+        co: typing.Union[typing.Sequence[float], mathutils.Vector] = (0.0, 0.0, 0.0),
+        example: BMVert = None,
+    ) -> BMVert:
         """Create a new vertex.
 
         :param co: The initial location of the vertex (optional argument).
-        :type co: typing.Union[typing.Sequence[float], 'mathutils.Vector']
+        :type co: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param example: Existing vert to initialize settings.
-        :type example: 'BMVert'
-        :rtype: 'BMVert'
+        :type example: BMVert
         :return: The newly created vertex.
+        :rtype: BMVert
         """
         ...
 
     def remove(self, vert):
-        """Remove a vert."""
+        """Remove a vert.
+
+        :param vert:
+        """
         ...
 
-    def sort(self, key: typing.Any = None, reverse: typing.Any = False):
-        """Sort the elements of this sequence, using an optional custom sort key. Indices of elements are not changed, BMElemeSeq.index_update() can be used for that.
+    def sort(self, key=None, reverse=False):
+        """Sort the elements of this sequence, using an optional custom sort key.
+        Indices of elements are not changed, BMElemeSeq.index_update() can be used for that.
 
-        :param key: The key that sets the ordering of the elements.
-        :type key: typing.Any
-        :param reverse: Reverse the order of the elements
-        :type reverse: typing.Any
+                :param key: The key that sets the ordering of the elements.
+                :param reverse: Reverse the order of the elements
         """
         ...
 
-    def __getitem__(self, key: int) -> "BMVert":
+    def __getitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMVert'
+        :return:
+        :rtype: BMVert
         """
         ...
 
-    def __setitem__(self, key: int, value: "BMVert"):
+    def __setitem__(self, key: int, value: BMVert):
         """
 
         :param key:
         :type key: int
         :param value:
-        :type value: 'BMVert'
+        :type value: BMVert
         """
         ...
 
-    def __delitem__(self, key: int) -> "BMVert":
+    def __delitem__(self, key: int) -> int:
         """
 
         :param key:
         :type key: int
-        :rtype: 'BMVert'
+        :return:
+        :rtype: BMVert
         """
         ...
 
-    def __iter__(self) -> typing.Iterator["BMVert"]:
+    def __iter__(self) -> BMVert:
         """
 
-        :rtype: typing.Iterator['BMVert']
+        :return:
+        :rtype: typing.Iterator[GenericType]
         """
         ...
 
-    def __next__(self) -> "BMVert":
+    def __next__(self) -> typing.Iterator[GenericType]:
         """
 
-        :rtype: 'BMVert'
+        :return:
+        :rtype: GenericType
         """
         ...
 
-    def __len__(self) -> int:
+    def __len__(self) -> GenericType:
         """
 
+        :return:
         :rtype: int
         """
         ...
@@ -1335,16 +1424,16 @@ class BMVertSeq:
 class BMesh:
     """The BMesh data structure"""
 
-    edges: "BMEdgeSeq"
+    edges: BMEdgeSeq
     """ This meshes edge sequence (read-only).
 
-    :type: 'BMEdgeSeq'
+    :type: BMEdgeSeq
     """
 
-    faces: "BMFaceSeq"
+    faces: BMFaceSeq
     """ This meshes face sequence (read-only).
 
-    :type: 'BMFaceSeq'
+    :type: BMFaceSeq
     """
 
     is_valid: bool
@@ -1359,45 +1448,44 @@ class BMesh:
     :type: bool
     """
 
-    loops: "BMLoopSeq"
+    loops: BMLoopSeq
     """ This meshes loops (read-only).
 
-    :type: 'BMLoopSeq'
+    :type: BMLoopSeq
     """
 
-    select_history: "BMEditSelSeq"
+    select_history: BMEditSelSeq
     """ Sequence of selected items (the last is displayed as active).
 
-    :type: 'BMEditSelSeq'
+    :type: BMEditSelSeq
     """
 
-    select_mode: typing.Set
+    select_mode: set
     """ The selection mode, values can be {'VERT', 'EDGE', 'FACE'}, can't be assigned an empty set.
 
-    :type: typing.Set
+    :type: set
     """
 
-    verts: "BMVertSeq"
+    verts: BMVertSeq
     """ This meshes vert sequence (read-only).
 
-    :type: 'BMVertSeq'
+    :type: BMVertSeq
     """
 
-    def calc_loop_triangles(self) -> typing.List["BMLoop"]:
+    def calc_loop_triangles(self) -> BMVertSeq:
         """Calculate triangle tessellation from quads/ngons.
 
-        :rtype: typing.List['BMLoop']
         :return: The triangulated faces.
         """
         ...
 
-    def calc_volume(self, signed: bool = False) -> float:
+    def calc_volume(self, signed: bool = False) -> bool:
         """Calculate mesh volume based on face normals.
 
         :param signed: when signed is true, negative values may be returned.
         :type signed: bool
-        :rtype: float
         :return: The volume of the mesh.
+        :rtype: float
         """
         ...
 
@@ -1405,11 +1493,11 @@ class BMesh:
         """Clear all mesh data."""
         ...
 
-    def copy(self) -> "BMesh":
+    def copy(self) -> float:
         """
 
-        :rtype: 'BMesh'
         :return: A copy of this BMesh.
+        :rtype: BMesh
         """
         ...
 
@@ -1419,7 +1507,7 @@ class BMesh:
 
     def from_mesh(
         self,
-        mesh: "bpy.types.Mesh",
+        mesh: bpy.types.Mesh,
         face_normals=True,
         vertex_normals=True,
         use_shape_key: bool = False,
@@ -1428,7 +1516,9 @@ class BMesh:
         """Initialize this bmesh from existing mesh datablock.
 
         :param mesh: The mesh data to load.
-        :type mesh: 'bpy.types.Mesh'
+        :type mesh: bpy.types.Mesh
+        :param face_normals:
+        :param vertex_normals:
         :param use_shape_key: Use the locations from a shape key.
         :type use_shape_key: bool
         :param shape_key_index: The shape key index to use.
@@ -1438,7 +1528,7 @@ class BMesh:
 
     def from_object(
         self,
-        object: "bpy.types.Object",
+        object: bpy.types.Object,
         depsgraph,
         cage: bool = False,
         face_normals: bool = True,
@@ -1447,7 +1537,8 @@ class BMesh:
         """Initialize this bmesh from existing object data-block (only meshes are currently supported).
 
         :param object: The object data to load.
-        :type object: 'bpy.types.Object'
+        :type object: bpy.types.Object
+        :param depsgraph:
         :param cage: Get the mesh as a deformed cage.
         :type cage: bool
         :param face_normals: Calculate face normals.
@@ -1473,20 +1564,19 @@ class BMesh:
         """flush selection based on the current mode current `BMesh.select_mode`."""
         ...
 
-    def to_mesh(self, mesh: "bpy.types.Mesh"):
+    def to_mesh(self, mesh: bpy.types.Mesh):
         """Writes this BMesh data into an existing Mesh datablock.
 
         :param mesh: The mesh data to write into.
-        :type mesh: 'bpy.types.Mesh'
+        :type mesh: bpy.types.Mesh
         """
         ...
 
-    def transform(self, matrix: "mathutils.Matrix", filter: typing.Set = None):
+    def transform(self, matrix, filter: set = None):
         """Transform the mesh (optionally filtering flagged data only).
 
         :param matrix: transform matrix.
-        :type matrix: 'mathutils.Matrix'
         :param filter: set of values in ('SELECT', 'HIDE', 'SEAM', 'SMOOTH', 'TAG').
-        :type filter: typing.Set
+        :type filter: set
         """
         ...