diff --git a/src/_numtype/@test/test_to_array.pyi b/src/_numtype/@test/test_to_array.pyi
index 68d175be..65b7612f 100644
--- a/src/_numtype/@test/test_to_array.pyi
+++ b/src/_numtype/@test/test_to_array.pyi
@@ -59,28 +59,28 @@ bool_0d_reject_sc: _nt.ToBool_0d = f_0d  # type: ignore[assignment]  # pyright:
 bool_0d_reject_1d: _nt.ToBool_0d = b1_1d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_0d_reject_2d: _nt.ToBool_0d = b1_2d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_0d_reject_3d: _nt.ToBool_0d = b1_3d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
-bool_0d_reject_nd: _nt.ToBool_0d = b1_nd  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+bool_0d_reject_nd: _nt.ToBool_0d = b1_nd
 
 bool_1d_accept: _nt.ToBool_1d = like_bool_1d
 bool_1d_reject_sc: _nt.ToBool_1d = f_1d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_1d_reject_0d: _nt.ToBool_1d = b1  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_1d_reject_2d: _nt.ToBool_1ds = b1_2d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_1d_reject_3d: _nt.ToBool_1ds = b1_3d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
-bool_1d_reject_nd: _nt.ToBool_1ds = b1_nd  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+bool_1d_reject_nd: _nt.ToBool_1ds = b1_nd
 
 bool_2d_accept: _nt.ToBool_2d = like_bool_2d
 bool_2d_reject_sc: _nt.ToBool_2d = f_2d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_2d_reject_0d: _nt.ToBool_2d = b1  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_2d_reject_1d: _nt.ToBool_2ds = b1_1d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_2d_reject_3d: _nt.ToBool_2ds = b1_3d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
-bool_2d_reject_nd: _nt.ToBool_2ds = b1_nd  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+bool_2d_reject_nd: _nt.ToBool_2ds = b1_nd
 
 bool_3d_accept: _nt.ToBool_3d = like_bool_3d
 bool_3d_reject_sc: _nt.ToBool_3d = f_3d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_3d_reject_0d: _nt.ToBool_3d = b1  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_3d_reject_1d: _nt.ToBool_3ds = b1_1d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
 bool_3d_reject_2d: _nt.ToBool_3ds = b1_2d  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
-bool_3d_reject_nd: _nt.ToBool_3ds = b1_nd  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+bool_3d_reject_nd: _nt.ToBool_3ds = b1_nd
 
 bool_nd_accept_0d: _nt.ToBool_nd = b1_0d
 bool_nd_accept_1d: _nt.ToBool_nd = like_bool_1d
diff --git a/src/_numtype/__init__.pyi b/src/_numtype/__init__.pyi
index 34c68921..7091474e 100644
--- a/src/_numtype/__init__.pyi
+++ b/src/_numtype/__init__.pyi
@@ -141,6 +141,7 @@ from ._scalar_co import (
 )
 from ._shape import (
     AnyShape as AnyShape,
+    NeitherShape as NeitherShape,
     Shape as Shape,
     Shape0 as Shape0,
     Shape0N as Shape0N,
@@ -188,13 +189,17 @@ class CanArray3D(Protocol[_ScalarT_co]):
 @type_check_only
 class CanArrayND(Protocol[_ScalarT_co]):
     # TODO: remove `| Rank0` once python/mypy#19110 is fixed
-    def __array__(self, /) -> np.ndarray[Shape | Rank0, np.dtype[_ScalarT_co]]: ...
+    def __array__(self, /) -> np.ndarray[AnyShape | Rank0, np.dtype[_ScalarT_co]]: ...
 
 @type_check_only
 class CanLenArrayND(Protocol[_ScalarT_co]):
     def __len__(self, /) -> int: ...
     # TODO: remove `| Rank0` once python/mypy#19110 is fixed
-    def __array__(self, /) -> np.ndarray[Shape, np.dtype[_ScalarT_co]]: ...
+    def __array__(self, /) -> np.ndarray[AnyShape, np.dtype[_ScalarT_co]]: ...
+
+@type_check_only
+class CanArray(Protocol[_ScalarT_co, _ShapeT_co]):
+    def __array__(self, /) -> np.ndarray[_ShapeT_co, np.dtype[_ScalarT_co]]: ...
 
 @type_check_only
 class CanLenArray(Protocol[_ScalarT_co, _ShapeT_co]):
@@ -260,6 +265,7 @@ _ToArray_2nd: TypeAlias = CanLenArray[_ScalarT, Shape2N] | Sequence[_ToArray_1nd
 _ToArray2_2nd: TypeAlias = CanLenArray[_ScalarT, Shape2N] | Sequence[_ToArray2_1nd[_ScalarT, _ToT]]
 _ToArray_3nd: TypeAlias = CanLenArray[_ScalarT, Shape3N] | Sequence[_ToArray_2nd[_ScalarT]]
 _ToArray2_3nd: TypeAlias = CanLenArray[_ScalarT, Shape3N] | Sequence[_ToArray2_2nd[_ScalarT, _ToT]]
+_ToArray_nnd: TypeAlias = CanArray[_ScalarT, NeitherShape]  # noqa: PYI047
 
 ###
 # Non-overlapping scalar- and array-like aliases for all scalar types.
diff --git a/src/_numtype/_array.pyi b/src/_numtype/_array.pyi
index df7026fe..ecd7e716 100644
--- a/src/_numtype/_array.pyi
+++ b/src/_numtype/_array.pyi
@@ -32,7 +32,7 @@ __all__ = [
 ###
 
 # TODO: use `AnyShape` instead of `Shape` once python/mypy#19110 is fixed
-_RankT = TypeVar("_RankT", bound=AnyShape, default=Shape)
+_RankT = TypeVar("_RankT", bound=AnyShape, default=AnyShape)
 _ScalarT = TypeVar("_ScalarT", bound=np.generic, default=Any)
 _NaT = TypeVar("_NaT", default=Never)
 
diff --git a/src/_numtype/_nep50.pyi b/src/_numtype/_nep50.pyi
index a9453341..1294791b 100644
--- a/src/_numtype/_nep50.pyi
+++ b/src/_numtype/_nep50.pyi
@@ -9,6 +9,7 @@ import numpy as np
 from numpy._typing import _NestedSequence
 
 from . import _shape
+from ._rank import Rank0
 
 __all__ = [
     "Casts",
@@ -122,7 +123,7 @@ class _LikeArray(Protocol[_LikeT_co, _ShapeT_co]):
 @type_check_only
 class _LikeScalar(Protocol[_LikeT_co]):
     @property
-    def shape(self, /) -> _shape.Shape0: ...
+    def __inner_shape__(self, /) -> Rank0: ...
     @property
     def dtype(self, /) -> _HasType[_LikeT_co]: ...
 
diff --git a/src/_numtype/_shape.pyi b/src/_numtype/_shape.pyi
index e40494da..e8899833 100644
--- a/src/_numtype/_shape.pyi
+++ b/src/_numtype/_shape.pyi
@@ -1,8 +1,9 @@
-from typing import Any, TypeAlias
+from typing import Any, Never, TypeAlias
 from typing_extensions import TypeAliasType
 
 __all__ = [
     "AnyShape",
+    "NeitherShape",
     "Shape",
     "Shape0",
     "Shape0N",
@@ -17,8 +18,9 @@ __all__ = [
     "ShapeN",
 ]
 
-AnyShape = TypeAliasType("AnyShape", tuple[Any, ...])
 Shape = TypeAliasType("Shape", tuple[int, ...])
+AnyShape = TypeAliasType("AnyShape", tuple[Any, ...])
+NeitherShape = TypeAliasType("NeitherShape", tuple[Never, ...])
 
 # TODO: remove `| Rank0` once python/mypy#19110 is fixed
 Shape0 = TypeAliasType("Shape0", tuple[()])
diff --git a/src/numpy-stubs/@test/static/accept/array_constructors.pyi b/src/numpy-stubs/@test/static/accept/array_constructors.pyi
index da27fd42..91101116 100644
--- a/src/numpy-stubs/@test/static/accept/array_constructors.pyi
+++ b/src/numpy-stubs/@test/static/accept/array_constructors.pyi
@@ -24,10 +24,10 @@ def func(i: int, j: int, **kwargs: object) -> MyArray[np.float64]: ...
 assert_type(np.array(A), _nt.Array[np.float64])
 assert_type(np.array(B), _nt.Array1D[np.float64])
 assert_type(np.array(D), _nt.Array1D[np.float64 | np.int64])
-assert_type(np.array([1, 1.0]), _nt.Array[Any])
-assert_type(np.array(deque([1, 2, 3])), _nt.Array[Any])
+assert_type(np.array([1, 1.0]), _nt.Array)
+assert_type(np.array(deque([1, 2, 3])), _nt.Array)
 assert_type(np.array(A, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.array(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.array(A, dtype="c16"), _nt.Array)
 assert_type(np.array(A, like=A), _nt.Array[np.float64])
 assert_type(np.array(A, subok=True), _nt.Array[np.float64])
 assert_type(np.array(B, subok=True), MyArray[np.float64])
@@ -36,68 +36,68 @@ assert_type(np.array(B, subok=True, ndmin=1), MyArray[np.float64])
 
 assert_type(np.zeros([1, 5, 6]), _nt.Array[np.float64])
 assert_type(np.zeros([1, 5, 6], dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.zeros([1, 5, 6], dtype="c16"), _nt.Array[Any])
+assert_type(np.zeros([1, 5, 6], dtype="c16"), _nt.Array)
 
 assert_type(np.empty([1, 5, 6]), _nt.Array[np.float64])
 assert_type(np.empty([1, 5, 6], dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.empty([1, 5, 6], dtype="c16"), _nt.Array[Any])
+assert_type(np.empty([1, 5, 6], dtype="c16"), _nt.Array)
 
 assert_type(np.concatenate(A), _nt.Array[np.float64])
-assert_type(np.concatenate([A, A]), _nt.Array[Any])  # pyright: ignore[reportAssertTypeFailure]  # _nt.Array[np.float64]
-assert_type(np.concatenate([[1], A]), _nt.Array[Any])
-assert_type(np.concatenate([[1], [1]]), _nt.Array[Any])
+assert_type(np.concatenate([A, A]), _nt.Array[np.float64])  # type: ignore[assert-type]  # mypy fail
+assert_type(np.concatenate([[1], A]), _nt.Array)
+assert_type(np.concatenate([[1], [1]]), _nt.Array)
 assert_type(np.concatenate((A, A)), _nt.Array[np.float64])
-assert_type(np.concatenate(([1], [1])), _nt.Array[Any])
-assert_type(np.concatenate([1, 1.0]), _nt.Array[Any])
+assert_type(np.concatenate(([1], [1])), _nt.Array)
+assert_type(np.concatenate([1, 1.0]), _nt.Array)
 assert_type(np.concatenate(A, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.concatenate(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.concatenate(A, dtype="c16"), _nt.Array)
 assert_type(np.concatenate([1, 1.0], out=A), _nt.Array[np.float64])
 
 assert_type(np.asarray(A), _nt.Array[np.float64])
 assert_type(np.asarray(B), _nt.Array1D[np.float64])
-assert_type(np.asarray([1, 1.0]), _nt.Array[Any])
+assert_type(np.asarray([1, 1.0]), _nt.Array)
 assert_type(np.asarray(A, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.asarray(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.asarray(A, dtype="c16"), _nt.Array)
 
 assert_type(np.asanyarray(A), _nt.Array[np.float64])
 assert_type(np.asanyarray(B), MyArray[np.float64])
-assert_type(np.asanyarray([1, 1.0]), _nt.Array[Any])
+assert_type(np.asanyarray([1, 1.0]), _nt.Array)
 assert_type(np.asanyarray(A, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.asanyarray(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.asanyarray(A, dtype="c16"), _nt.Array)
 
 assert_type(np.ascontiguousarray(A), _nt.Array[np.float64])
 assert_type(np.ascontiguousarray(B), _nt.Array1D[np.float64])
-assert_type(np.ascontiguousarray([1, 1.0]), _nt.Array[Any])
+assert_type(np.ascontiguousarray([1, 1.0]), _nt.Array)
 assert_type(np.ascontiguousarray(A, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.ascontiguousarray(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.ascontiguousarray(A, dtype="c16"), _nt.Array)
 
 assert_type(np.asfortranarray(A), _nt.Array[np.float64])
 assert_type(np.asfortranarray(B), _nt.Array1D[np.float64])
-assert_type(np.asfortranarray([1, 1.0]), _nt.Array[Any])
+assert_type(np.asfortranarray([1, 1.0]), _nt.Array)
 assert_type(np.asfortranarray(A, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.asfortranarray(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.asfortranarray(A, dtype="c16"), _nt.Array)
 
 assert_type(np.fromstring("1 1 1", sep=" "), _nt.Array[np.float64])
 assert_type(np.fromstring(b"1 1 1", sep=" "), _nt.Array[np.float64])
 assert_type(np.fromstring("1 1 1", dtype=np.int64, sep=" "), _nt.Array[np.int64])
 assert_type(np.fromstring(b"1 1 1", dtype=np.int64, sep=" "), _nt.Array[np.int64])
-assert_type(np.fromstring("1 1 1", dtype="c16", sep=" "), _nt.Array[Any])
-assert_type(np.fromstring(b"1 1 1", dtype="c16", sep=" "), _nt.Array[Any])
+assert_type(np.fromstring("1 1 1", dtype="c16", sep=" "), _nt.Array)
+assert_type(np.fromstring(b"1 1 1", dtype="c16", sep=" "), _nt.Array)
 
 assert_type(np.fromfile("test.txt", sep=" "), _nt.Array[np.float64])
 assert_type(np.fromfile("test.txt", dtype=np.int64, sep=" "), _nt.Array[np.int64])
-assert_type(np.fromfile("test.txt", dtype="c16", sep=" "), _nt.Array[Any])
+assert_type(np.fromfile("test.txt", dtype="c16", sep=" "), _nt.Array)
 with open("test.txt", encoding="utf-8") as f:
     assert_type(np.fromfile(f, sep=" "), _nt.Array[np.float64])
     assert_type(np.fromfile(b"test.txt", sep=" "), _nt.Array[np.float64])
     assert_type(np.fromfile(Path("test.txt"), sep=" "), _nt.Array[np.float64])
 
 assert_type(np.fromiter("12345", np.float64), _nt.Array[np.float64])
-assert_type(np.fromiter("12345", float), _nt.Array[Any])
+assert_type(np.fromiter("12345", float), _nt.Array)
 
 assert_type(np.frombuffer(A), _nt.Array[np.float64])
 assert_type(np.frombuffer(A, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.frombuffer(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.frombuffer(A, dtype="c16"), _nt.Array)
 
 assert_type(np.arange(False, True), _nt.Array1D[np.int_])
 assert_type(np.arange(10), _nt.Array1D[np.int_])
@@ -115,7 +115,7 @@ assert_type(np.arange(0, 10, dtype="f8"), _nt.Array1D[np.float64])
 assert_type(np.require(A), _nt.Array[np.float64])
 assert_type(np.require(B), MyArray[np.float64])
 assert_type(np.require(B, requirements=None), MyArray[np.float64])
-assert_type(np.require(B, dtype=int), _nt.Array[Any])
+assert_type(np.require(B, dtype=int), _nt.Array)
 assert_type(np.require(B, requirements="E"), _nt.Array[np.float64])
 assert_type(np.require(B, requirements=["ENSUREARRAY"]), _nt.Array[np.float64])
 assert_type(np.require(B, requirements={"F", "E"}), _nt.Array[np.float64])
@@ -127,28 +127,28 @@ assert_type(np.require(C), _nt.Array[np.intp])
 assert_type(np.linspace(0, 10), _nt.Array[np.floating])
 assert_type(np.linspace(0, 10j), _nt.Array[np.inexact])
 assert_type(np.linspace(0, 10, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.linspace(0, 10, dtype=int), _nt.Array[Any])
+assert_type(np.linspace(0, 10, dtype=int), _nt.Array)
 assert_type(np.linspace(0, 10, retstep=True), tuple[_nt.Array[np.floating], np.floating])
 assert_type(np.linspace(0j, 10, retstep=True), tuple[_nt.Array[np.inexact], np.inexact])
 assert_type(np.linspace(0, 10, retstep=True, dtype=np.int64), tuple[_nt.Array[np.int64], np.int64])
-assert_type(np.linspace(0j, 10, retstep=True, dtype=int), tuple[_nt.Array[Any], Any])
+assert_type(np.linspace(0j, 10, retstep=True, dtype=int), tuple[_nt.Array, Any])
 
 assert_type(np.logspace(0, 10), _nt.Array[np.floating])
 assert_type(np.logspace(0, 10j), _nt.Array[np.inexact])
 assert_type(np.logspace(0, 10, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.logspace(0, 10, dtype=int), _nt.Array[Any])
+assert_type(np.logspace(0, 10, dtype=int), _nt.Array)
 
 assert_type(np.geomspace(0, 10), _nt.Array[np.floating])
 assert_type(np.geomspace(0, 10j), _nt.Array[np.inexact])
 assert_type(np.geomspace(0, 10, dtype=np.int64), _nt.Array[np.int64])
-assert_type(np.geomspace(0, 10, dtype=int), _nt.Array[Any])
+assert_type(np.geomspace(0, 10, dtype=int), _nt.Array)
 
 assert_type(np.empty_like(A), _nt.Array[np.float64])
 assert_type(np.empty_like(A, dtype=float), _nt.Array[np.float64])
-assert_type(np.empty_like(A, shape=(2, 2)), _nt.Array[np.float64, _nt.Shape2])
+assert_type(np.empty_like(A, shape=(2, 2)), _nt.Array2D[np.float64])
 assert_type(np.empty_like(A, dtype=np.int64), _nt.Array[np.int64])
 assert_type(np.empty_like(A, dtype=np.int64, shape=(2, 2)), _nt.Array[np.int64, _nt.Shape2])
-assert_type(np.empty_like(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.empty_like(A, dtype="c16"), _nt.Array)
 assert_type(np.empty_like(A, dtype="c16", shape=(2, 2)), np.ndarray[_nt.Shape2, np.dtype])
 assert_type(np.empty_like(B), MyArray[np.float64])
 assert_type(np.empty_like(B, dtype=np.int64), _nt.Array[np.int64])
@@ -171,10 +171,10 @@ assert_type(np.empty_like([[[4j]]]), _nt.Array3D[np.complex128])
 
 assert_type(np.zeros_like(A), _nt.Array[np.float64])
 assert_type(np.zeros_like(A, dtype=float), _nt.Array[np.float64])
-assert_type(np.zeros_like(A, shape=(2, 2)), _nt.Array[np.float64, _nt.Shape2])
+assert_type(np.zeros_like(A, shape=(2, 2)), _nt.Array2D[np.float64])
 assert_type(np.zeros_like(A, dtype=np.int64), _nt.Array[np.int64])
 assert_type(np.zeros_like(A, dtype=np.int64, shape=(2, 2)), _nt.Array[np.int64, _nt.Shape2])
-assert_type(np.zeros_like(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.zeros_like(A, dtype="c16"), _nt.Array)
 assert_type(np.zeros_like(A, dtype="c16", shape=(2, 2)), np.ndarray[_nt.Shape2, np.dtype])
 assert_type(np.zeros_like(B), MyArray[np.float64])
 assert_type(np.zeros_like(B, dtype=np.int64), _nt.Array[np.int64])
@@ -197,10 +197,10 @@ assert_type(np.zeros_like([[[4j]]]), _nt.Array3D[np.complex128])
 
 assert_type(np.ones_like(A), _nt.Array[np.float64])
 assert_type(np.ones_like(A, dtype=float), _nt.Array[np.float64])
-assert_type(np.ones_like(A, shape=(2, 2)), _nt.Array[np.float64, _nt.Shape2])
+assert_type(np.ones_like(A, shape=(2, 2)), _nt.Array2D[np.float64])
 assert_type(np.ones_like(A, dtype=np.int64), _nt.Array[np.int64])
 assert_type(np.ones_like(A, dtype=np.int64, shape=(2, 2)), _nt.Array[np.int64, _nt.Shape2])
-assert_type(np.ones_like(A, dtype="c16"), _nt.Array[Any])
+assert_type(np.ones_like(A, dtype="c16"), _nt.Array)
 assert_type(np.ones_like(A, dtype="c16", shape=(2, 2)), np.ndarray[_nt.Shape2, np.dtype])
 assert_type(np.ones_like(B), MyArray[np.float64])
 assert_type(np.ones_like(B, dtype=np.int64), _nt.Array[np.int64])
@@ -223,7 +223,7 @@ assert_type(np.ones_like([[[4j]]]), _nt.Array3D[np.complex128])
 
 assert_type(np.full_like(A, i8), _nt.Array[np.float64])
 assert_type(np.full_like(C, i8), _nt.Array1D[np.intp])
-assert_type(np.full_like(A, i8, dtype=int), _nt.Array[Any])
+assert_type(np.full_like(A, i8, dtype=int), _nt.Array)
 assert_type(np.full_like(B, i8), MyArray[np.float64])
 assert_type(np.full_like(B, i8, dtype=np.int64), _nt.Array[np.int64])
 
@@ -240,8 +240,8 @@ assert_type(np.ones(_shape_2d), _nt.Array[np.float64, _nt.Shape2])
 assert_type(np.ones(_shape_nd), np.ndarray[_nt.Shape, np.dtype[np.float64]])
 assert_type(np.ones(_shape_1d, dtype=np.int64), _nt.Array1D[np.int64])
 assert_type(np.ones(_shape_like), _nt.Array[np.float64])
-assert_type(np.ones(_shape_like, dtype=np.dtypes.StringDType()), np.ndarray[Any, np.dtypes.StringDType])
-assert_type(np.ones(_shape_like, dtype=int), _nt.Array[Any])
+assert_type(np.ones(_shape_like, dtype=np.dtypes.StringDType()), np.ndarray[_nt.AnyShape, np.dtypes.StringDType])
+assert_type(np.ones(_shape_like, dtype=int), _nt.Array)
 
 assert_type(np.full(_size, i8), _nt.Array1D[np.int64])
 assert_type(np.full(_shape_2d, i8), _nt.Array[np.int64, _nt.Shape2])
@@ -265,12 +265,12 @@ assert_type(np.identity(10, dtype=np.int64), _nt.Array2D[np.int64])
 assert_type(np.identity(10, dtype=int), _nt.Array2D)
 
 assert_type(np.atleast_1d(A), _nt.Array[np.float64])
-assert_type(np.atleast_1d(C), _nt.Array[Any])
+assert_type(np.atleast_1d(C), _nt.Array)
 assert_type(np.atleast_1d(A, A), tuple[_nt.Array[np.float64], _nt.Array[np.float64]])
-assert_type(np.atleast_1d(A, C), tuple[_nt.Array[Any], _nt.Array[Any]])
-assert_type(np.atleast_1d(C, C), tuple[_nt.Array[Any], _nt.Array[Any]])
+assert_type(np.atleast_1d(A, C), tuple[_nt.Array, _nt.Array])
+assert_type(np.atleast_1d(C, C), tuple[_nt.Array, _nt.Array])
 assert_type(np.atleast_1d(A, A, A), tuple[_nt.Array[np.float64], ...])
-assert_type(np.atleast_1d(C, C, C), tuple[_nt.Array[Any], ...])
+assert_type(np.atleast_1d(C, C, C), tuple[_nt.Array, ...])
 
 assert_type(np.atleast_2d(A), _nt.Array[np.float64])
 assert_type(np.atleast_2d(A, A), tuple[_nt.Array[np.float64], _nt.Array[np.float64]])
@@ -280,28 +280,28 @@ assert_type(np.atleast_3d(A), _nt.Array[np.float64])
 assert_type(np.atleast_3d(A, A), tuple[_nt.Array[np.float64], _nt.Array[np.float64]])
 assert_type(np.atleast_3d(A, A, A), tuple[_nt.Array[np.float64], ...])
 
-assert_type(np.vstack([A, A]), _nt.Array[np.float64])
+assert_type(np.vstack([A, A]), _nt.Array[np.float64])  # type: ignore[assert-type]  # mypy fail
 assert_type(np.vstack([A, A], dtype=np.float32), _nt.Array[np.float32])
-assert_type(np.vstack([A, C]), _nt.Array[Any])
-assert_type(np.vstack([C, C]), _nt.Array[Any])
+assert_type(np.vstack([A, C]), _nt.Array)
+assert_type(np.vstack([C, C]), _nt.Array)
 
-assert_type(np.hstack([A, A]), _nt.Array[np.float64])
+assert_type(np.hstack([A, A]), _nt.Array[np.float64])  # type: ignore[assert-type]  # mypy fail
 assert_type(np.hstack([A, A], dtype=np.float32), _nt.Array[np.float32])
 
-assert_type(np.stack([A, A]), _nt.Array[np.float64])
+assert_type(np.stack([A, A]), _nt.Array[np.float64])  # type: ignore[assert-type]  # mypy fail
 assert_type(np.stack([A, A], dtype=np.float32), _nt.Array[np.float32])
-assert_type(np.stack([A, C]), _nt.Array[Any])
-assert_type(np.stack([C, C]), _nt.Array[Any])
-assert_type(np.stack([A, A], axis=0), _nt.Array[np.float64])
+assert_type(np.stack([A, C]), _nt.Array)
+assert_type(np.stack([C, C]), _nt.Array)
+assert_type(np.stack([A, A], axis=0), _nt.Array[np.float64])  # type: ignore[assert-type]  # mypy fail
 assert_type(np.stack([A, A], out=B), MyArray[np.float64])
 
-assert_type(np.block([[A, A], [A, A]]), _nt.Array[Any])  # pyright: ignore[reportAssertTypeFailure]  # _nt.Array[np.float64]
-assert_type(np.block(C), _nt.Array[Any])
+assert_type(np.block([[A, A], [A, A]]), _nt.Array)  # pyright: ignore[reportAssertTypeFailure]  # _nt.Array[np.float64]
+assert_type(np.block(C), _nt.Array)
 
 if sys.version_info >= (3, 12):
     from collections.abc import Buffer
 
-    def create_array(obj: npt.ArrayLike) -> _nt.Array[Any]: ...
+    def create_array(obj: npt.ArrayLike) -> _nt.Array: ...
 
     buffer: Buffer
-    assert_type(create_array(buffer), _nt.Array[Any])
+    assert_type(create_array(buffer), _nt.Array)
diff --git a/src/numpy-stubs/@test/static/accept/arrayterator.pyi b/src/numpy-stubs/@test/static/accept/arrayterator.pyi
index 3649bae6..8064bacd 100644
--- a/src/numpy-stubs/@test/static/accept/arrayterator.pyi
+++ b/src/numpy-stubs/@test/static/accept/arrayterator.pyi
@@ -5,7 +5,7 @@ import _numtype as _nt
 import numpy as np
 
 AR_i8: _nt.Array[np.int64]
-ar_iter: np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]]
+ar_iter: np.lib.Arrayterator[_nt.AnyShape, np.dtype[np.int64]]
 
 ###
 
@@ -14,16 +14,16 @@ assert_type(ar_iter.buf_size, int | None)
 assert_type(ar_iter.start, list[int])
 assert_type(ar_iter.stop, list[int])
 assert_type(ar_iter.step, list[int])
-assert_type(ar_iter.shape, tuple[int, ...])
-assert_type(ar_iter.flat, Generator[np.int64, None, None])
+assert_type(ar_iter.shape, _nt.AnyShape)
+assert_type(ar_iter.flat, Generator[np.int64])
 
 assert_type(ar_iter.__array__(), _nt.Array[np.int64])
 
 for i in ar_iter:
     assert_type(i, _nt.Array[np.int64])
 
-assert_type(ar_iter[0], np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]])
-assert_type(ar_iter[...], np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]])
-assert_type(ar_iter[:], np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]])
-assert_type(ar_iter[0, 0, 0], np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]])
-assert_type(ar_iter[..., 0, :], np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]])
+assert_type(ar_iter[0], np.lib.Arrayterator[_nt.AnyShape, np.dtype[np.int64]])
+assert_type(ar_iter[...], np.lib.Arrayterator[_nt.AnyShape, np.dtype[np.int64]])
+assert_type(ar_iter[:], np.lib.Arrayterator[_nt.AnyShape, np.dtype[np.int64]])
+assert_type(ar_iter[0, 0, 0], np.lib.Arrayterator[_nt.AnyShape, np.dtype[np.int64]])
+assert_type(ar_iter[..., 0, :], np.lib.Arrayterator[_nt.AnyShape, np.dtype[np.int64]])
diff --git a/src/numpy-stubs/@test/static/accept/char.pyi b/src/numpy-stubs/@test/static/accept/char.pyi
index 0051aad6..a8a318d8 100644
--- a/src/numpy-stubs/@test/static/accept/char.pyi
+++ b/src/numpy-stubs/@test/static/accept/char.pyi
@@ -5,7 +5,7 @@ import numpy as np
 
 BytesArray: TypeAlias = _nt.Array[np.bytes_]
 StrArray: TypeAlias = _nt.Array[np.str_]
-StringArray: TypeAlias = np.ndarray[_nt.Shape, np.dtypes.StringDType]
+StringArray: TypeAlias = np.ndarray[_nt.AnyShape, np.dtypes.StringDType]
 
 AR_S: BytesArray
 AR_U: StrArray
@@ -186,16 +186,16 @@ assert_type(np.char.istitle(AR_SUT), _nt.Array[np.bool])
 assert_type(np.char.isupper(AR_SUT), _nt.Array[np.bool])
 assert_type(np.char.str_len(AR_SUT), _nt.Array[np.int_])
 
-assert_type(np.char.array(AR_U), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
-assert_type(np.char.array(AR_S, order="K"), np.char.chararray[tuple[int, ...], np.dtype[np.bytes_]])
-assert_type(np.char.array("bob", copy=True), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
-assert_type(np.char.array(b"bob", itemsize=5), np.char.chararray[tuple[int, ...], np.dtype[np.bytes_]])
-assert_type(np.char.array(1, unicode=False), np.char.chararray[tuple[int, ...], np.dtype[np.bytes_]])
-assert_type(np.char.array(1, unicode=True), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
-
-assert_type(np.char.asarray(AR_U), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
-assert_type(np.char.asarray(AR_S, order="K"), np.char.chararray[tuple[int, ...], np.dtype[np.bytes_]])
-assert_type(np.char.asarray("bob"), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
-assert_type(np.char.asarray(b"bob", itemsize=5), np.char.chararray[tuple[int, ...], np.dtype[np.bytes_]])
-assert_type(np.char.asarray(1, unicode=False), np.char.chararray[tuple[int, ...], np.dtype[np.bytes_]])
-assert_type(np.char.asarray(1, unicode=True), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
+assert_type(np.char.array(AR_U), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
+assert_type(np.char.array(AR_S, order="K"), np.char.chararray[_nt.AnyShape, np.dtype[np.bytes_]])
+assert_type(np.char.array("bob", copy=True), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
+assert_type(np.char.array(b"bob", itemsize=5), np.char.chararray[_nt.AnyShape, np.dtype[np.bytes_]])
+assert_type(np.char.array(1, unicode=False), np.char.chararray[_nt.AnyShape, np.dtype[np.bytes_]])
+assert_type(np.char.array(1, unicode=True), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
+
+assert_type(np.char.asarray(AR_U), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
+assert_type(np.char.asarray(AR_S, order="K"), np.char.chararray[_nt.AnyShape, np.dtype[np.bytes_]])
+assert_type(np.char.asarray("bob"), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
+assert_type(np.char.asarray(b"bob", itemsize=5), np.char.chararray[_nt.AnyShape, np.dtype[np.bytes_]])
+assert_type(np.char.asarray(1, unicode=False), np.char.chararray[_nt.AnyShape, np.dtype[np.bytes_]])
+assert_type(np.char.asarray(1, unicode=True), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
diff --git a/src/numpy-stubs/@test/static/accept/chararray.pyi b/src/numpy-stubs/@test/static/accept/chararray.pyi
index e7715f47..02723523 100644
--- a/src/numpy-stubs/@test/static/accept/chararray.pyi
+++ b/src/numpy-stubs/@test/static/accept/chararray.pyi
@@ -4,7 +4,7 @@ from typing_extensions import TypeVar
 import _numtype as _nt
 import numpy as np
 
-_ShapeT = TypeVar("_ShapeT", bound=_nt.Shape, default=_nt.Shape)
+_ShapeT = TypeVar("_ShapeT", bound=_nt.Shape, default=_nt.AnyShape)
 
 _BytesArray: TypeAlias = np.char.chararray[_ShapeT, np.dtype[np.bytes_]]
 _StrArray: TypeAlias = np.char.chararray[_ShapeT, np.dtype[np.str_]]
diff --git a/src/numpy-stubs/@test/static/accept/fromnumeric.pyi b/src/numpy-stubs/@test/static/accept/fromnumeric.pyi
index 481b311d..a744a13b 100644
--- a/src/numpy-stubs/@test/static/accept/fromnumeric.pyi
+++ b/src/numpy-stubs/@test/static/accept/fromnumeric.pyi
@@ -151,7 +151,7 @@ assert_type(np.shape(i_1d), tuple[int])
 assert_type(np.shape(i_2d), tuple[int, int])
 assert_type(np.shape(i_3d), tuple[int, int, int])
 assert_type(np.shape(i_4d), tuple[int, ...])
-assert_type(np.shape(AR_b1), tuple[int, ...])
+assert_type(np.shape(AR_b1), tuple[Any, ...])
 assert_type(np.shape(AR_nd), tuple[int, ...])
 # these fail on mypy, but it works as expected with pyright/pylance
 assert_type(np.shape(AR_0d), tuple[()])  # type: ignore[assert-type]
diff --git a/src/numpy-stubs/@test/static/accept/lib_function_base.pyi b/src/numpy-stubs/@test/static/accept/lib_function_base.pyi
index ec94003f..6f52c341 100644
--- a/src/numpy-stubs/@test/static/accept/lib_function_base.pyi
+++ b/src/numpy-stubs/@test/static/accept/lib_function_base.pyi
@@ -10,8 +10,9 @@ import numpy as np
 vectorized_func: np.vectorize
 
 f8: np.float64
-AR_LIKE_f8: list[float]
-AR_LIKE_c16: list[complex]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
 AR_LIKE_O: list[Fraction]
 
 AR_i8: _nt.Array[np.int64]
@@ -22,7 +23,7 @@ AR_M: _nt.Array[np.datetime64]
 AR_O: _nt.Array[np.object_]
 AR_b: _nt.Array[np.bool]
 AR_U: _nt.Array[np.str_]
-CHAR_AR_U: np.char.chararray[tuple[int, ...], np.dtype[np.str_]]
+CHAR_AR_U: np.char.chararray[_nt.AnyShape, np.dtype[np.str_]]
 
 AR_b_list: list[_nt.Array[np.bool]]
 
@@ -41,12 +42,12 @@ assert_type(np.vectorize(int), np.vectorize)
 assert_type(np.vectorize(int, otypes="i", doc="doc", excluded=(), cache=True, signature=None), np.vectorize)
 
 assert_type(np.rot90(AR_f8, k=2), _nt.Array[np.float64])
-assert_type(np.rot90(AR_LIKE_f8, axes=(0, 1)), _nt.Array[Any])
+assert_type(np.rot90(AR_LIKE_f, axes=(0, 1)), _nt.Array[Any])
 
 assert_type(np.flip(f8), np.float64)
 assert_type(np.flip(1.0), Any)
 assert_type(np.flip(AR_f8, axis=(0, 1)), _nt.Array[np.float64])
-assert_type(np.flip(AR_LIKE_f8, axis=0), _nt.Array[Any])
+assert_type(np.flip(AR_LIKE_f, axis=0), _nt.Array[Any])
 
 assert_type(np.iterable(1), bool)
 assert_type(np.iterable([1]), bool)
@@ -61,7 +62,7 @@ assert_type(np.average(AR_f8, axis=0), Any)
 assert_type(np.average(AR_f8, axis=0, returned=True), tuple[Any, Any])
 
 assert_type(np.asarray_chkfinite(AR_f8), _nt.Array[np.float64])
-assert_type(np.asarray_chkfinite(AR_LIKE_f8), _nt.Array[Any])
+assert_type(np.asarray_chkfinite(AR_LIKE_f), _nt.Array[Any])
 assert_type(np.asarray_chkfinite(AR_f8, dtype=np.float64), _nt.Array[np.float64])
 assert_type(np.asarray_chkfinite(AR_f8, dtype=float), _nt.Array[Any])
 
@@ -69,22 +70,22 @@ assert_type(np.piecewise(AR_f8, AR_b, [func]), _nt.Array[np.float64])
 assert_type(np.piecewise(AR_f8, AR_b_list, [func]), _nt.Array[np.float64])
 assert_type(np.piecewise(AR_f8, AR_b_list, [func], True, -1, kwarg=""), _nt.Array[np.float64])
 assert_type(np.piecewise(AR_f8, AR_b_list, [func], True, arg=-1, kwarg=""), _nt.Array[np.float64])
-assert_type(np.piecewise(AR_LIKE_f8, AR_b_list, [func]), _nt.Array[Any])
+assert_type(np.piecewise(AR_LIKE_f, AR_b_list, [func]), _nt.Array[Any])
 
 assert_type(np.select([AR_f8], [AR_f8]), _nt.Array[np.float64])
 
-assert_type(np.copy(AR_LIKE_f8), _nt.Array[Any])
+assert_type(np.copy(AR_LIKE_f), _nt.Array[Any])
 assert_type(np.copy(AR_U), _nt.Array[np.str_])
 assert_type(np.copy(CHAR_AR_U), _nt.Array[np.str_])
-assert_type(np.copy(CHAR_AR_U, "K", subok=True), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
-assert_type(np.copy(CHAR_AR_U, subok=True), np.char.chararray[tuple[int, ...], np.dtype[np.str_]])
+assert_type(np.copy(CHAR_AR_U, "K", subok=True), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
+assert_type(np.copy(CHAR_AR_U, subok=True), np.char.chararray[_nt.AnyShape, np.dtype[np.str_]])
 
 assert_type(np.gradient(AR_f8, axis=None), Any)
-assert_type(np.gradient(AR_LIKE_f8, edge_order=2), Any)
+assert_type(np.gradient(AR_LIKE_f, edge_order=2), Any)
 
 assert_type(np.diff("bob", n=0), str)
 assert_type(np.diff(AR_f8, axis=0), _nt.Array[np.float64])
-assert_type(np.diff(AR_LIKE_f8, prepend=1.5), _nt.Array[Any])
+assert_type(np.diff(AR_LIKE_f, prepend=1.5), _nt.Array[Any])
 
 assert_type(np.interp(1, [1], AR_f8), np.float64)
 assert_type(np.interp(1, [1], [1]), np.float64)
@@ -107,10 +108,10 @@ assert_type(np.unwrap(AR_O), _nt.Array[np.object_])
 assert_type(np.sort_complex(AR_f8), _nt.Array[np.complexfloating])
 
 assert_type(np.trim_zeros(AR_f8), _nt.Array[np.float64])
-assert_type(np.trim_zeros(AR_LIKE_f8), list[float])
+assert_type(np.trim_zeros(AR_LIKE_f), list[float])
 
 assert_type(np.extract(AR_i8, AR_f8), _nt.Array[np.float64])
-assert_type(np.extract(AR_i8, AR_LIKE_f8), _nt.Array[Any])
+assert_type(np.extract(AR_i8, AR_LIKE_f), _nt.Array[Any])
 
 assert_type(np.place(AR_f8, mask=AR_i8, vals=5.0), None)
 
@@ -142,7 +143,7 @@ assert_type(np.median(AR_m), np.timedelta64)
 assert_type(np.median(AR_O), Any)
 assert_type(np.median(AR_f8, keepdims=True), Any)
 assert_type(np.median(AR_c16, axis=0), Any)
-assert_type(np.median(AR_LIKE_f8, out=AR_c16), _nt.Array[np.complex128])
+assert_type(np.median(AR_LIKE_f, out=AR_c16), _nt.Array[np.complex128])
 
 assert_type(np.percentile(AR_f8, 50), np.floating)
 assert_type(np.percentile(AR_c16, 50), np.complexfloating)
@@ -172,38 +173,45 @@ assert_type(np.quantile(AR_f8, [0.5], keepdims=True), Any)
 assert_type(np.quantile(AR_f8, [0.5], axis=[1]), Any)
 assert_type(np.quantile(AR_f8, [0.5], out=AR_c16), _nt.Array[np.complex128])
 
-assert_type(np.trapezoid(AR_LIKE_f8), np.float64)
-assert_type(np.trapezoid(AR_LIKE_f8, AR_LIKE_f8), np.float64)
-assert_type(np.trapezoid(AR_LIKE_c16), np.complexfloating)
-assert_type(np.trapezoid(AR_LIKE_c16, AR_LIKE_f8), np.complexfloating)
-assert_type(np.trapezoid(AR_LIKE_f8, AR_LIKE_c16), np.complexfloating)
+assert_type(np.trapezoid(AR_LIKE_i), np.float64)
+assert_type(np.trapezoid(AR_LIKE_f), np.float64)
+assert_type(np.trapezoid(AR_LIKE_f, AR_LIKE_f), np.float64)
+assert_type(np.trapezoid(AR_LIKE_f, AR_LIKE_i), np.float64)
+assert_type(np.trapezoid(AR_LIKE_i, AR_LIKE_f), np.float64)
+assert_type(np.trapezoid(AR_LIKE_c), np.complexfloating)
+assert_type(np.trapezoid(AR_LIKE_c, AR_LIKE_f), np.complexfloating)
+assert_type(np.trapezoid(AR_LIKE_f, AR_LIKE_c), np.complexfloating)
 # pyright bug: https://github.com/microsoft/pyright/issues/9896
 assert_type(np.trapezoid(AR_LIKE_O), float)  # pyright: ignore[reportAssertTypeFailure]
-assert_type(np.trapezoid(AR_LIKE_O, AR_LIKE_f8), float)  # pyright: ignore[reportAssertTypeFailure]
-assert_type(np.trapezoid(AR_f8), np.floating | _nt.Array[np.floating])
-assert_type(np.trapezoid(AR_f8, AR_f8), np.floating | _nt.Array[np.floating])
-assert_type(np.trapezoid(AR_c16), np.complexfloating | _nt.Array[np.complexfloating])
-assert_type(np.trapezoid(AR_c16, AR_c16), np.complexfloating | _nt.Array[np.complexfloating])
+assert_type(np.trapezoid(AR_LIKE_O, AR_LIKE_f), float)  # pyright: ignore[reportAssertTypeFailure]
+assert_type(np.trapezoid(AR_i8), np.float64 | _nt.Array[np.float64])
+assert_type(np.trapezoid(AR_i8, AR_i8), np.float64 | _nt.Array[np.float64])
+assert_type(np.trapezoid(AR_f8), np.float64 | _nt.Array[np.float64])
+assert_type(np.trapezoid(AR_f8, AR_f8), np.float64 | _nt.Array[np.float64])
+assert_type(np.trapezoid(AR_i8, AR_f8), np.float64 | _nt.Array[np.float64])
+assert_type(np.trapezoid(AR_f8, AR_i8), np.float64 | _nt.Array[np.float64])
+assert_type(np.trapezoid(AR_c16), np.complex128 | _nt.Array[np.complex128])
+assert_type(np.trapezoid(AR_c16, AR_c16), np.complex128 | _nt.Array[np.complex128])
 assert_type(np.trapezoid(AR_m), np.timedelta64 | _nt.Array[np.timedelta64])
 assert_type(np.trapezoid(AR_O), Any)
-assert_type(np.trapezoid(AR_O, AR_LIKE_f8), Any)
+assert_type(np.trapezoid(AR_O, AR_LIKE_f), Any)
 
 assert_type(np.meshgrid(), tuple[()])
 assert_type(np.meshgrid(AR_c16, indexing="ij"), tuple[_nt.Array1D[np.complex128]])
 assert_type(np.meshgrid(AR_i8, AR_f8, copy=False), tuple[_nt.Array2D[np.int64], _nt.Array2D[np.float64]])
-assert_type(np.meshgrid(AR_LIKE_f8, AR_f8), tuple[_nt.Array2D, _nt.Array2D[np.float64]])
-assert_type(np.meshgrid(AR_LIKE_f8, AR_i8, AR_c16), tuple[_nt.Array3D, _nt.Array3D, _nt.Array3D])
+assert_type(np.meshgrid(AR_LIKE_f, AR_f8), tuple[_nt.Array2D, _nt.Array2D[np.float64]])
+assert_type(np.meshgrid(AR_LIKE_f, AR_i8, AR_c16), tuple[_nt.Array3D, _nt.Array3D, _nt.Array3D])
 assert_type(np.meshgrid(AR_f8, AR_f8, AR_f8, AR_f8), tuple[_nt.Array4D, _nt.Array4D, _nt.Array4D, _nt.Array4D])
-assert_type(np.meshgrid(*AR_LIKE_f8), tuple[_nt.Array[Any], ...])
+assert_type(np.meshgrid(*AR_LIKE_f), tuple[_nt.Array[Any], ...])
 
 assert_type(np.delete(AR_f8, np.s_[:5]), _nt.Array[np.float64])
-assert_type(np.delete(AR_LIKE_f8, [0, 4, 9], axis=0), _nt.Array[Any])
+assert_type(np.delete(AR_LIKE_f, [0, 4, 9], axis=0), _nt.Array[Any])
 
 assert_type(np.insert(AR_f8, np.s_[:5], 5), _nt.Array[np.float64])
-assert_type(np.insert(AR_LIKE_f8, [0, 4, 9], [0.5, 9.2, 7], axis=0), _nt.Array[Any])
+assert_type(np.insert(AR_LIKE_f, [0, 4, 9], [0.5, 9.2, 7], axis=0), _nt.Array[Any])
 
 assert_type(np.append(AR_f8, 5), _nt.Array[Any])
-assert_type(np.append(AR_LIKE_f8, 1j, axis=0), _nt.Array[Any])
+assert_type(np.append(AR_LIKE_f, 1j, axis=0), _nt.Array[Any])
 
 assert_type(np.digitize(4.5, [1]), np.intp)
 assert_type(np.digitize(AR_f8, [1, 2, 3]), _nt.Array[np.intp])
diff --git a/src/numpy-stubs/@test/static/accept/lib_polynomial.pyi b/src/numpy-stubs/@test/static/accept/lib_polynomial.pyi
index 17c4f708..160fb164 100644
--- a/src/numpy-stubs/@test/static/accept/lib_polynomial.pyi
+++ b/src/numpy-stubs/@test/static/accept/lib_polynomial.pyi
@@ -89,10 +89,10 @@ assert_type(
 assert_type(np.polyfit(AR_u4, AR_c16, 1.0, cov=True), tuple[_nt.Array[np.complex128], _nt.Array[np.complex128]])
 
 assert_type(np.polyval(AR_b, AR_b), _nt.Array[np.bool])
-assert_type(np.polyval(AR_u4, AR_b), _nt.Array[np.unsignedinteger])
-assert_type(np.polyval(AR_i8, AR_i8), _nt.Array[np.signedinteger])
-assert_type(np.polyval(AR_f8, AR_i8), _nt.Array[np.floating])
-assert_type(np.polyval(AR_i8, AR_c16), _nt.Array[np.complexfloating])
+assert_type(np.polyval(AR_u4, AR_b), _nt.Array[np.uint32])
+assert_type(np.polyval(AR_i8, AR_i8), _nt.Array[np.int64])
+assert_type(np.polyval(AR_f8, AR_i8), _nt.Array[np.float64])
+assert_type(np.polyval(AR_i8, AR_c16), _nt.Array[np.complex128])
 assert_type(np.polyval(AR_O, AR_O), _nt.Array[np.object_])
 
 assert_type(np.polyadd(poly_obj, AR_i8), np.poly1d)  # type: ignore[assert-type]  # mypy fail
diff --git a/src/numpy-stubs/@test/static/accept/ndarray_misc.pyi b/src/numpy-stubs/@test/static/accept/ndarray_misc.pyi
index c6459894..4d12eb50 100644
--- a/src/numpy-stubs/@test/static/accept/ndarray_misc.pyi
+++ b/src/numpy-stubs/@test/static/accept/ndarray_misc.pyi
@@ -9,7 +9,7 @@ import numpy as np
 
 ###
 
-class SubArray(np.ndarray[_nt.Shape, np.dtype[np.object_]]): ...
+class SubArray(np.ndarray[_nt.AnyShape, np.dtype[np.object_]]): ...
 
 f8: np.float64
 i8: np.int64
@@ -151,7 +151,7 @@ assert_type(AR_f8.var(out=AR_O_sub), SubArray)
 
 assert_type(AR_f8.argpartition([0]), _nt.Array[np.intp])
 
-assert_type(AR_f8.diagonal(), _nt.Array[np.float64, Any])
+assert_type(AR_f8.diagonal(), _nt.Array[np.float64])
 
 assert_type(AR_f8.dot(1), _nt.Array[Any])
 assert_type(AR_f8.dot([1]), Any)
diff --git a/src/numpy-stubs/@test/static/accept/polynomial_series.pyi b/src/numpy-stubs/@test/static/accept/polynomial_series.pyi
index 7cdac4ff..37d7b12f 100644
--- a/src/numpy-stubs/@test/static/accept/polynomial_series.pyi
+++ b/src/numpy-stubs/@test/static/accept/polynomial_series.pyi
@@ -79,11 +79,11 @@ assert_type(npp.polynomial.polyval3d(AR_f8, AR_f8, AR_f8, AR_i8), _Floating_nd)
 assert_type(npp.polynomial.polyval3d(AR_i8, AR_i8, AR_i8, AR_c16), _ComplexFloating_nd)
 assert_type(npp.polynomial.polyval3d(AR_O, AR_O, AR_O, AR_O), _Object_nd)
 
-assert_type(npp.polynomial.polyvalfromroots(AR_b, AR_b), _Floating_nd)
-assert_type(npp.polynomial.polyvalfromroots(AR_u4, AR_b), _Floating_nd)
-assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_i8), _Floating_nd)
-assert_type(npp.polynomial.polyvalfromroots(AR_f8, AR_i8), _Floating_nd)
-assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_c16), _ComplexFloating_nd)
+assert_type(npp.polynomial.polyvalfromroots(AR_b, AR_b), _Float64_nd)
+assert_type(npp.polynomial.polyvalfromroots(AR_u4, AR_b), _Float64_nd)
+assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_i8), _Float64_nd)
+assert_type(npp.polynomial.polyvalfromroots(AR_f8, AR_i8), _Float64_nd)
+assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_c16), _Complex128_nd)
 assert_type(npp.polynomial.polyvalfromroots(AR_O, AR_O), _Object_nd)
 
 assert_type(npp.polynomial.polyvander(AR_f8, 3), _Float64_nd)
diff --git a/src/numpy-stubs/@test/static/accept/ufunclike.pyi b/src/numpy-stubs/@test/static/accept/ufunclike.pyi
index c6cfb3b1..a4271aa4 100644
--- a/src/numpy-stubs/@test/static/accept/ufunclike.pyi
+++ b/src/numpy-stubs/@test/static/accept/ufunclike.pyi
@@ -3,7 +3,7 @@ from typing import assert_type
 import _numtype as _nt
 import numpy as np
 
-AR_u: _nt.Array[np.uint32]
+AR_u4: _nt.Array[np.uint32]
 AR_U: _nt.Array[np.str_]
 AR_LIKE_b: list[bool]
 AR_LIKE_i: list[int]
@@ -11,19 +11,19 @@ AR_LIKE_f: list[float]
 
 ###
 
-assert_type(np.fix(AR_u), _nt.Array[np.uint32])
+assert_type(np.fix(AR_u4), _nt.Array[np.uint32])
 assert_type(np.fix(AR_LIKE_b), _nt.Array[np.bool])
 assert_type(np.fix(AR_LIKE_i), _nt.Array[np.intp])
 assert_type(np.fix(AR_LIKE_f), _nt.Array[np.float64])
 assert_type(np.fix(AR_LIKE_f, out=AR_U), _nt.Array[np.str_])
 
-assert_type(np.isposinf(AR_u), _nt.Array[np.bool])
+assert_type(np.isposinf(AR_u4), _nt.Array[np.bool])
 assert_type(np.isposinf(AR_LIKE_b), _nt.Array1D[np.bool])
 assert_type(np.isposinf(AR_LIKE_i), _nt.Array1D[np.bool])
 assert_type(np.isposinf(AR_LIKE_f), _nt.Array1D[np.bool])
 assert_type(np.isposinf(AR_LIKE_f, out=AR_U), _nt.Array[np.str_])
 
-assert_type(np.isneginf(AR_u), _nt.Array[np.bool])
+assert_type(np.isneginf(AR_u4), _nt.Array[np.bool])
 assert_type(np.isneginf(AR_LIKE_b), _nt.Array1D[np.bool])
 assert_type(np.isneginf(AR_LIKE_i), _nt.Array1D[np.bool])
 assert_type(np.isneginf(AR_LIKE_f), _nt.Array1D[np.bool])
diff --git a/src/numpy-stubs/@test/static/reject/lib_polynomial.pyi b/src/numpy-stubs/@test/static/reject/lib_polynomial.pyi
index 78c918c3..f2ea5331 100644
--- a/src/numpy-stubs/@test/static/reject/lib_polynomial.pyi
+++ b/src/numpy-stubs/@test/static/reject/lib_polynomial.pyi
@@ -26,6 +26,6 @@ np.polyfit(AR_f8, AR_f8, 1, rcond=1j)  # type: ignore[call-overload]  # pyright:
 np.polyfit(AR_f8, AR_f8, 1, w=AR_c16)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
 np.polyfit(AR_f8, AR_f8, 1, cov="bob")  # type: ignore[call-overload]  # pyright: ignore[reportArgumentType, reportCallIssue]
 
-np.polyval(AR_f8, AR_U)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
+np.polyval(AR_f8, AR_U)  # type: ignore[misc]  # pyright: ignore[reportArgumentType, reportCallIssue]
 np.polyadd(AR_f8, AR_U)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
 np.polysub(AR_f8, AR_U)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
diff --git a/src/numpy-stubs/@test/static/reject/linalg.pyi b/src/numpy-stubs/@test/static/reject/linalg.pyi
index 10b7065e..84f6e05e 100644
--- a/src/numpy-stubs/@test/static/reject/linalg.pyi
+++ b/src/numpy-stubs/@test/static/reject/linalg.pyi
@@ -39,4 +39,4 @@ np.linalg.slogdet(AR_O)  # type: ignore[arg-type]  # pyright: ignore[reportArgum
 
 np.linalg.norm(AR_f8, ord="bob")  # type: ignore[call-overload]  # pyright: ignore[reportArgumentType, reportCallIssue]
 
-np.linalg.multi_dot([AR_M])  # type: ignore[list-item]  # pyright: ignore[reportArgumentType, reportCallIssue]
+np.linalg.multi_dot([AR_M])  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
diff --git a/src/numpy-stubs/@test/static/reject/ufunclike.pyi b/src/numpy-stubs/@test/static/reject/ufunclike.pyi
index 2bc67c70..d22a974e 100644
--- a/src/numpy-stubs/@test/static/reject/ufunclike.pyi
+++ b/src/numpy-stubs/@test/static/reject/ufunclike.pyi
@@ -6,9 +6,9 @@ AR_m: _nt.Array[np.timedelta64]
 AR_M: _nt.Array[np.datetime64]
 AR_O: _nt.Array[np.object_]
 
-np.fix(AR_c)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
-np.fix(AR_m)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
-np.fix(AR_M)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
+np.fix(AR_c)  # type: ignore[type-var]  # pyright: ignore[reportArgumentType, reportCallIssue]
+np.fix(AR_m)  # type: ignore[type-var]  # pyright: ignore[reportArgumentType, reportCallIssue]
+np.fix(AR_M)  # type: ignore[type-var]  # pyright: ignore[reportArgumentType, reportCallIssue]
 
 np.isposinf(AR_c)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
 np.isposinf(AR_m)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
diff --git a/src/numpy-stubs/__init__.pyi b/src/numpy-stubs/__init__.pyi
index b329c68a..77c83f36 100644
--- a/src/numpy-stubs/__init__.pyi
+++ b/src/numpy-stubs/__init__.pyi
@@ -1776,11 +1776,11 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
     @overload
     def __getitem__(
         self, key: _ArrayInteger_co | tuple[_ArrayInteger_co, ...], /
-    ) -> ndarray[_nt.Shape, _DTypeT_co]: ...
+    ) -> ndarray[_nt.AnyShape, _DTypeT_co]: ...
     @overload
     def __getitem__(self, key: CanIndex | tuple[CanIndex, ...], /) -> Any: ...
     @overload
-    def __getitem__(self, key: _ToIndices, /) -> ndarray[_nt.Shape, _DTypeT_co]: ...
+    def __getitem__(self, key: _ToIndices, /) -> ndarray[_nt.AnyShape, _DTypeT_co]: ...
     @overload
     def __getitem__(self: _nt.Array[void], key: str, /) -> ndarray[_ShapeT_co]: ...
     @overload
@@ -2452,55 +2452,47 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
 
     #
     @overload
-    def __divmod__(self: _nt.Array[bool_, _nt.Shape], x: _nt.ToBool_nd, /) -> _Tuple2[_nt.Array[int8]]: ...
+    def __divmod__(self: _nt.Array[bool_], x: _nt.ToBool_nd, /) -> _Tuple2[_nt.Array[int8]]: ...
     @overload
     def __divmod__(
-        self: _nt.Array[_RealNumberT, _nt.Shape], x: _nt.Casts[_RealNumberT, _nt.Shape] | _nt.ToBool_nd, /
+        self: _nt.Array[_RealNumberT], x: _nt.Casts[_RealNumberT] | _nt.ToBool_nd, /
     ) -> _Tuple2[_nt.Array[_RealNumberT]]: ...
     @overload
     def __divmod__(
-        self: _nt.Array[_CoFloatingT, _nt.Shape], x: _nt.CastsWith[_CoFloatingT, _RealScalarT, _nt.Shape], /
+        self: _nt.Array[_CoFloatingT], x: _nt.CastsWith[_CoFloatingT, _RealScalarT], /
     ) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
     @overload
-    def __divmod__(
-        self: _nt.CastsWithInt[_RealScalarT, _nt.Shape], x: _PyIntND, /
-    ) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
+    def __divmod__(self: _nt.CastsWithInt[_RealScalarT], x: _PyIntND, /) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
     @overload
-    def __divmod__(
-        self: _nt.CastsWithFloat[_RealScalarT, _nt.Shape], x: _PyFloatND, /
-    ) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
+    def __divmod__(self: _nt.CastsWithFloat[_RealScalarT], x: _PyFloatND, /) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
     @overload
     def __divmod__(
-        self: _nt.Array[timedelta64, _nt.Shape], x: _nt.ToTimeDelta_nd, /
+        self: _nt.Array[timedelta64], x: _nt.ToTimeDelta_nd, /
     ) -> tuple[_nt.Array[int64], _nt.Array[timedelta64]]: ...
     @overload
-    def __divmod__(self: _nt.Array[object_, _nt.Shape], x: object, /) -> _Tuple2[_nt.Array[object_]]: ...
+    def __divmod__(self: _nt.Array[object_], x: object, /) -> _Tuple2[_nt.Array[object_]]: ...
 
     #
     @overload
-    def __rdivmod__(self: _nt.Array[bool_, _nt.Shape], x: _nt.ToBool_nd, /) -> _Tuple2[_nt.Array[int8]]: ...
+    def __rdivmod__(self: _nt.Array[bool_], x: _nt.ToBool_nd, /) -> _Tuple2[_nt.Array[int8]]: ...
     @overload
     def __rdivmod__(
-        self: _nt.Array[_RealNumberT, _nt.Shape], x: _nt.Casts[_RealNumberT, _nt.Shape] | _nt.ToBool_nd, /
+        self: _nt.Array[_RealNumberT], x: _nt.Casts[_RealNumberT] | _nt.ToBool_nd, /
     ) -> _Tuple2[_nt.Array[_RealNumberT]]: ...
     @overload
     def __rdivmod__(
-        self: _nt.Array[_CoFloatingT, _nt.Shape], x: _nt.CastsWith[_CoFloatingT, _RealScalarT, _nt.Shape], /
+        self: _nt.Array[_CoFloatingT], x: _nt.CastsWith[_CoFloatingT, _RealScalarT], /
     ) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
     @overload
-    def __rdivmod__(
-        self: _nt.CastsWithInt[_RealScalarT, _nt.Shape], x: _PyIntND, /
-    ) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
+    def __rdivmod__(self: _nt.CastsWithInt[_RealScalarT], x: _PyIntND, /) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
     @overload
-    def __rdivmod__(
-        self: _nt.CastsWithFloat[_RealScalarT, _nt.Shape], x: _PyFloatND, /
-    ) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
+    def __rdivmod__(self: _nt.CastsWithFloat[_RealScalarT], x: _PyFloatND, /) -> _Tuple2[_nt.Array[_RealScalarT]]: ...
     @overload
     def __rdivmod__(
-        self: _nt.Array[timedelta64, _nt.Shape], x: _nt.ToTimeDelta_nd, /
+        self: _nt.Array[timedelta64], x: _nt.ToTimeDelta_nd, /
     ) -> tuple[_nt.Array[int64], _nt.Array[timedelta64]]: ...
     @overload
-    def __rdivmod__(self: _nt.Array[object_, _nt.Shape], x: object, /) -> _Tuple2[_nt.Array[object_]]: ...
+    def __rdivmod__(self: _nt.Array[object_], x: object, /) -> _Tuple2[_nt.Array[object_]]: ...
 
     #
     @overload
@@ -2701,8 +2693,12 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
     def item(self: _HasDTypeWithItem[_T], /, *args: CanIndex) -> _T: ...
 
     #
-    @overload  # TODO(jorenham): remove `| Rank0` once python/mypy#19110 is fixed
-    def tolist(self: _HasShapeAndItem[_nt.Shape0 | _nt.Rank0, _T], /) -> _T: ...  # type: ignore[overload-overlap]
+    @overload  # workaround for python/mypy#19110
+    def tolist(self: _HasShapeAndItem[_nt.Rank0, _T], /) -> _T: ...  # type: ignore[overload-overlap]
+    @overload  # workaround for microsoft/pyright#10232
+    def tolist(self: ndarray[_nt.NeitherShape], /) -> Any: ...
+    @overload
+    def tolist(self: _HasShapeAndItem[_nt.Shape0, _T], /) -> _T: ...
     @overload
     def tolist(self: _HasShapeAndItem[_nt.Shape1, _T], /) -> list[_T]: ...
     @overload
@@ -2741,7 +2737,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
 
     #
     def swapaxes(self, /, axis1: CanIndex, axis2: CanIndex) -> Self: ...
-    def squeeze(self, /, axis: CanIndex | tuple[CanIndex, ...] | None = None) -> ndarray[_nt.Shape, _DTypeT_co]: ...
+    def squeeze(self, /, axis: CanIndex | tuple[CanIndex, ...] | None = None) -> ndarray[_nt.AnyShape, _DTypeT_co]: ...
     def byteswap(self, /, inplace: py_bool = False) -> Self: ...
 
     #
@@ -2751,6 +2747,10 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
     def transpose(self, /, *axes: CanIndex) -> Self: ...
 
     # NOTE: always raises when called on `generic`.
+    @overload  # this overload is a workaround for microsoft/pyright#10232
+    def diagonal(  # type: ignore[overload-overlap]
+        self: ndarray[_nt.NeitherShape, _DTypeT], /, offset: CanIndex = 0, axis1: CanIndex = 0, axis2: CanIndex = 1
+    ) -> ndarray[_nt.AnyShape, _DTypeT]: ...
     @overload
     def diagonal(
         self: ndarray[_nt.Shape2, _DTypeT], /, offset: CanIndex = 0, axis1: CanIndex = 0, axis2: CanIndex = 1
@@ -2770,7 +2770,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
     @overload
     def diagonal(
         self, /, offset: CanIndex = 0, axis1: CanIndex = 0, axis2: CanIndex = 1
-    ) -> ndarray[Any, _DTypeT_co]: ...
+    ) -> ndarray[_nt.AnyShape, _DTypeT_co]: ...
 
     #
     @overload
@@ -2995,7 +2995,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
     @overload
     def take(
         self, /, indices: _nt.CoInteger_nd, axis: CanIndex | None = None, out: None = None, mode: _ModeKind = "raise"
-    ) -> ndarray[_nt.Shape, _DTypeT_co]: ...
+    ) -> ndarray[_nt.AnyShape, _DTypeT_co]: ...
     @overload
     def take(
         self, /, indices: _nt.CoInteger_nd, axis: CanIndex | None, out: _ArrayT, mode: _ModeKind = "raise"
diff --git a/src/numpy-stubs/_core/_multiarray_umath.pyi b/src/numpy-stubs/_core/_multiarray_umath.pyi
index a284634d..c258dd91 100644
--- a/src/numpy-stubs/_core/_multiarray_umath.pyi
+++ b/src/numpy-stubs/_core/_multiarray_umath.pyi
@@ -599,6 +599,16 @@ def empty_like(
     *,
     device: _Device | None = None,
 ) -> np.ndarray[_ShapeT, _DTypeT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def empty_like(
+    prototype: _nt._ToArray_nnd[np.bool_],
+    dtype: _nt.ToDTypeBool | None = None,
+    order: _OrderKACF = "K",
+    subok: bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.bool_]: ...
 @overload  # bool 0d array-like
 def empty_like(  # type: ignore[overload-overlap]
     prototype: _nt.ToBool_0d,
@@ -639,6 +649,16 @@ def empty_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.bool_]: ...
+@overload  # workaround for microsoft/pyright#10232
+def empty_like(
+    prototype: _nt._ToArray_nnd[np.intp],
+    dtype: _nt.ToDTypeInt64 | None = None,
+    order: _OrderKACF = "K",
+    subok: bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.intp]: ...
 @overload  # int 0d array-like
 def empty_like(  # type: ignore[overload-overlap]
     prototype: _nt.ToInt_0d,
@@ -679,6 +699,16 @@ def empty_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.intp]: ...
+@overload  # workaround for microsoft/pyright#10232
+def empty_like(
+    prototype: _nt._ToArray_nnd[np.float64],
+    dtype: _nt.ToDTypeFloat64 | None = None,
+    order: _OrderKACF = "K",
+    subok: bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.float64]: ...
 @overload  # float 0d array-like
 def empty_like(  # type: ignore[overload-overlap]
     prototype: _nt.ToFloat64_0d,
@@ -729,6 +759,16 @@ def empty_like(  # type: ignore[overload-overlap]
     *,
     device: _Device | None = None,
 ) -> _nt.Array0D[np.complex128]: ...
+@overload  # workaround for microsoft/pyright#10232
+def empty_like(
+    prototype: _nt._ToArray_nnd[np.complex128],
+    dtype: _nt.ToDTypeComplex128 | None = None,
+    order: _OrderKACF = "K",
+    subok: bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.complex128]: ...
 @overload  # complex 1d array-like
 def empty_like(
     prototype: _nt.ToComplex128_1ds,
@@ -770,7 +810,7 @@ def empty_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT, _AnyShapeT]: ...
 @overload  # array-like with known scalar-type, unknown shape
-def empty_like(  # type: ignore[overload-overlap]
+def empty_like(
     prototype: _ArrayLike[_ScalarT],
     dtype: np.dtype[_ScalarT] | None = None,
     order: _OrderKACF = "K",
@@ -820,7 +860,7 @@ def empty_like(
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT]: ...
 @overload  # bool array-like
-def empty_like(  # type: ignore[overload-overlap]
+def empty_like(
     prototype: _nt.ToBool_nd,
     dtype: _nt.ToDTypeBool | None = None,
     order: _OrderKACF = "K",
@@ -830,7 +870,7 @@ def empty_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.bool_]: ...
 @overload  # int array-like
-def empty_like(  # type: ignore[overload-overlap]
+def empty_like(
     prototype: _nt.ToInt_nd,
     dtype: _nt.ToDTypeInt64 | None = None,
     order: _OrderKACF = "K",
@@ -840,7 +880,7 @@ def empty_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.intp]: ...
 @overload  # float array-like
-def empty_like(  # type: ignore[overload-overlap]
+def empty_like(
     prototype: _nt.ToFloat64_nd,
     dtype: _nt.ToDTypeFloat64 | None = None,
     order: _OrderKACF = "K",
@@ -850,7 +890,7 @@ def empty_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.float64]: ...
 @overload  # complex array-like
-def empty_like(  # type: ignore[overload-overlap]
+def empty_like(
     prototype: _nt.ToComplex128_nd,
     dtype: _nt.ToDTypeComplex128 | None = None,
     order: _OrderKACF = "K",
@@ -932,7 +972,7 @@ def array(
     **kwargs: Unpack[_KwargsCL],
 ) -> _nt.Array[_ScalarT]: ...
 @overload
-def array(  # type: ignore[overload-overlap]
+def array(
     object: _ScalarLike_co,
     dtype: _DTypeLike[_ScalarT],
     *,
@@ -942,7 +982,7 @@ def array(  # type: ignore[overload-overlap]
     **kwargs: Unpack[_KwargsCL],
 ) -> _nt.Array0D[_ScalarT]: ...
 @overload
-def array(  # type: ignore[overload-overlap]
+def array(
     object: _ScalarLike_co,
     dtype: npt.DTypeLike | None,
     *,
@@ -985,11 +1025,11 @@ def asarray(
     a: _ArrayLike[_ScalarT], dtype: None = None, order: _OrderKACF = None, **kwargs: Unpack[_KwargsDCL]
 ) -> _nt.Array[_ScalarT]: ...
 @overload
-def asarray(  # type: ignore[overload-overlap]
+def asarray(
     a: _ScalarLike_co, dtype: _DTypeLike[_ScalarT], order: _OrderKACF = None, **kwargs: Unpack[_KwargsDCL]
 ) -> _nt.Array0D[_ScalarT]: ...
 @overload
-def asarray(  # type: ignore[overload-overlap]
+def asarray(
     a: _ScalarLike_co, dtype: npt.DTypeLike | None = None, order: _OrderKACF = None, **kwargs: Unpack[_KwargsDCL]
 ) -> _nt.Array0D[Incomplete]: ...
 @overload
diff --git a/src/numpy-stubs/_core/defchararray.pyi b/src/numpy-stubs/_core/defchararray.pyi
index d5dc2f3a..31e94e0a 100644
--- a/src/numpy-stubs/_core/defchararray.pyi
+++ b/src/numpy-stubs/_core/defchararray.pyi
@@ -120,9 +120,9 @@ __all__ = [
 
 ###
 
-_ShapeT = TypeVar("_ShapeT", bound=_nt.Shape, default=_nt.Shape)
-_ShapeT_co = TypeVar("_ShapeT_co", bound=_nt.Shape, default=_nt.Shape, covariant=True)
-_DTypeT_co = TypeVar("_DTypeT_co", bound=np.dtype[np.character], default=np.dtype[Any], covariant=True)
+_ShapeT = TypeVar("_ShapeT", bound=_nt.Shape, default=_nt.AnyShape)
+_ShapeT_co = TypeVar("_ShapeT_co", bound=_nt.Shape, default=_nt.AnyShape, covariant=True)
+_DTypeT_co = TypeVar("_DTypeT_co", bound=np.dtype[np.character], default=np.dtype, covariant=True)
 _CharT = TypeVar("_CharT", bound=np.character, default=Any)
 
 _CharArray = TypeAliasType("_CharArray", chararray[_ShapeT, np.dtype[_CharT]], type_params=(_CharT, _ShapeT))
@@ -203,11 +203,11 @@ class chararray(np.ndarray[_ShapeT_co, _DTypeT_co]):
     @overload  # type: ignore[override]
     def __mul__(self, rhs: _nt.ToInteger_0d, /) -> Self: ...
     @overload
-    def __mul__(self, rhs: _nt.ToInteger_nd, /) -> chararray[_nt.Shape, _DTypeT_co]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+    def __mul__(self, rhs: _nt.ToInteger_nd, /) -> chararray[_nt.AnyShape, _DTypeT_co]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
     @overload  # type: ignore[override]
     def __rmul__(self, lhs: int, /) -> Self: ...
     @overload
-    def __rmul__(self, lhs: _nt.ToInteger_nd, /) -> chararray[_nt.Shape, _DTypeT_co]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
+    def __rmul__(self, lhs: _nt.ToInteger_nd, /) -> chararray[_nt.AnyShape, _DTypeT_co]: ...  # pyright: ignore[reportIncompatibleMethodOverride]
 
     #
     @override
@@ -263,7 +263,7 @@ class chararray(np.ndarray[_ShapeT_co, _DTypeT_co]):
     @overload
     def expandtabs(self, /, tabsize: _nt.ToInteger_0d = 8) -> Self: ...
     @overload
-    def expandtabs(self, /, tabsize: _nt.ToInteger_nd) -> chararray[_nt.Shape, _DTypeT_co]: ...
+    def expandtabs(self, /, tabsize: _nt.ToInteger_nd) -> chararray[_nt.AnyShape, _DTypeT_co]: ...
 
     #
     @overload
diff --git a/src/numpy-stubs/_core/fromnumeric.pyi b/src/numpy-stubs/_core/fromnumeric.pyi
index 47b6067b..fba41f12 100644
--- a/src/numpy-stubs/_core/fromnumeric.pyi
+++ b/src/numpy-stubs/_core/fromnumeric.pyi
@@ -56,8 +56,8 @@ __all__ = [
     "var",
 ]
 
+_T = TypeVar("_T")
 _ArrayT = TypeVar("_ArrayT", bound=np.ndarray[Any, Any])
-
 _ShapeT = TypeVar("_ShapeT", bound=_nt.Shape)
 _ScalarT = TypeVar("_ScalarT", bound=np.generic)
 _NumberT = TypeVar("_NumberT", bound=np.number | np.object_)
@@ -79,6 +79,7 @@ _AnyShapeT = TypeVar(
     tuple[int, ...],
 )
 
+_Option: TypeAlias = _T | _NoValueType
 _Order: TypeAlias = str | Sequence[str]
 
 @type_check_only
@@ -336,59 +337,59 @@ def argsort(
 ) -> _nt.Array[np.intp]: ...
 
 #
-@overload  # 0d or 1d , keepdims=False
+@overload  # workaround for microsoft/pyright#10232
 def argmax(
-    a: _nt.ToGeneric_0d | _nt.ToGeneric_1ds,
-    axis: CanIndex,
-    out: None = None,
-    *,
-    keepdims: L[False] | _NoValueType = ...,
+    a: _nt._ToArray_nnd[Any], axis: None = None, out: None = None, *, keepdims: _Option[L[False]] = ...
 ) -> np.intp: ...
-@overload  # axis=None, keepdims=False
+@overload  # workaround for microsoft/pyright#10232
+def argmax(
+    a: _nt._ToArray_nnd[Any], axis: CanIndex, out: None = None, *, keepdims: _Option[L[False]] = ...
+) -> Incomplete: ...
+@overload  # 0d or 1d , keepdims=False
 def argmax(
-    a: ArrayLike, axis: None = None, out: None = None, *, keepdims: L[False] | _NoValueType = ...
+    a: _nt.ToGeneric_0d | _nt.ToGeneric_1ds, axis: CanIndex, out: None = None, *, keepdims: _Option[L[False]] = ...
 ) -> np.intp: ...
+@overload  # axis=None, keepdims=False
+def argmax(a: ArrayLike, axis: None = None, out: None = None, *, keepdims: _Option[L[False]] = ...) -> np.intp: ...
 @overload  # keepdims=True
 def argmax(
     a: ArrayLike, axis: CanIndex | None = None, out: None = None, *, keepdims: L[True]
 ) -> _nt.Array[np.intp]: ...
 @overload  # out=<given> (positional)
-def argmax(a: ArrayLike, axis: CanIndex | None, out: _ArrayT, *, keepdims: bool | _NoValueType = ...) -> _ArrayT: ...
+def argmax(a: ArrayLike, axis: CanIndex | None, out: _ArrayT, *, keepdims: _Option[bool] = ...) -> _ArrayT: ...
 @overload  # out=<given> (keyword)
-def argmax(
-    a: ArrayLike, axis: CanIndex | None = None, *, out: _ArrayT, keepdims: bool | _NoValueType = ...
-) -> _ArrayT: ...
+def argmax(a: ArrayLike, axis: CanIndex | None = None, *, out: _ArrayT, keepdims: _Option[bool] = ...) -> _ArrayT: ...
 @overload  # fallback
 def argmax(
-    a: ArrayLike, axis: CanIndex | None = None, out: _nt.Array | None = None, *, keepdims: bool | _NoValueType = ...
+    a: ArrayLike, axis: CanIndex | None = None, out: _nt.Array | None = None, *, keepdims: _Option[bool] = ...
 ) -> Incomplete: ...
 
 #
-@overload  # 0d or 1d , keepdims=False
+@overload  # workaround for microsoft/pyright#10232
 def argmin(
-    a: _nt.ToGeneric_0d | _nt.ToGeneric_1ds,
-    axis: CanIndex,
-    out: None = None,
-    *,
-    keepdims: L[False] | _NoValueType = ...,
+    a: _nt._ToArray_nnd[Any], axis: None = None, out: None = None, *, keepdims: _Option[L[False]] = ...
 ) -> np.intp: ...
-@overload  # axis=None, keepdims=False
+@overload  # workaround for microsoft/pyright#10232
 def argmin(
-    a: ArrayLike, axis: None = None, out: None = None, *, keepdims: L[False] | _NoValueType = ...
+    a: _nt._ToArray_nnd[Any], axis: CanIndex, out: None = None, *, keepdims: _Option[L[False]] = ...
+) -> Incomplete: ...
+@overload  # 0d or 1d , keepdims=False
+def argmin(
+    a: _nt.ToGeneric_0d | _nt.ToGeneric_1ds, axis: CanIndex, out: None = None, *, keepdims: _Option[L[False]] = ...
 ) -> np.intp: ...
+@overload  # axis=None, keepdims=False
+def argmin(a: ArrayLike, axis: None = None, out: None = None, *, keepdims: _Option[L[False]] = ...) -> np.intp: ...
 @overload  # keepdims=True
 def argmin(
     a: ArrayLike, axis: CanIndex | None = None, out: None = None, *, keepdims: L[True]
 ) -> _nt.Array[np.intp]: ...
 @overload  # out=<given> (positional)
-def argmin(a: ArrayLike, axis: CanIndex | None, out: _ArrayT, *, keepdims: bool | _NoValueType = ...) -> _ArrayT: ...
+def argmin(a: ArrayLike, axis: CanIndex | None, out: _ArrayT, *, keepdims: _Option[bool] = ...) -> _ArrayT: ...
 @overload  # out=<given> (keyword)
-def argmin(
-    a: ArrayLike, axis: CanIndex | None = None, *, out: _ArrayT, keepdims: bool | _NoValueType = ...
-) -> _ArrayT: ...
+def argmin(a: ArrayLike, axis: CanIndex | None = None, *, out: _ArrayT, keepdims: _Option[bool] = ...) -> _ArrayT: ...
 @overload  # fallback
 def argmin(
-    a: ArrayLike, axis: CanIndex | None = None, out: _nt.Array | None = None, *, keepdims: bool | _NoValueType = ...
+    a: ArrayLike, axis: CanIndex | None = None, out: _nt.Array | None = None, *, keepdims: _Option[bool] = ...
 ) -> Incomplete: ...
 
 #
@@ -416,8 +417,12 @@ def resize(a: ArrayLike, new_shape: _AnyShapeT) -> _nt.Array[Any, _AnyShapeT]: .
 def resize(a: ArrayLike, new_shape: Sequence[CanIndex]) -> _nt.Array[Incomplete]: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def squeeze(a: _ScalarT, axis: _ShapeLike | None = None) -> _nt.Array0D[_ScalarT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def squeeze(a: _nt._ToArray_nnd[_ScalarT], axis: _ShapeLike | None = None) -> _nt.Array[_ScalarT]: ...
 @overload
-def squeeze(a: _nt.CanArray0D[_ScalarT], axis: _ShapeLike | None = None) -> _nt.Array0D[_ScalarT]: ...  # type: ignore[overload-overlap]
+def squeeze(a: _nt.CanArray0D[_ScalarT], axis: _ShapeLike | None = None) -> _nt.Array0D[_ScalarT]: ...
 @overload
 def squeeze(a: _nt._ToArray_nd[_ScalarT], axis: _ShapeLike | None = None) -> _nt.Array[_ScalarT]: ...
 @overload
@@ -511,72 +516,72 @@ def compress(condition: _nt.ToBool_nd, a: ArrayLike, axis: CanIndex | None = Non
 @overload
 def clip(
     a: _ScalarT,
-    a_min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    a_max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    a_min: _Option[_nt.CoComplex_nd] | None = ...,
+    a_max: _Option[_nt.CoComplex_nd] | None = ...,
     out: None = None,
     *,
-    min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    min: _Option[_nt.CoComplex_nd] | None = ...,
+    max: _Option[_nt.CoComplex_nd] | None = ...,
     dtype: None = None,
     **kwargs: Unpack[UFuncKwargs],
 ) -> _ScalarT: ...
 @overload
 def clip(
     a: _nt._ToArray_1nd[_ScalarT],
-    a_min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    a_max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    a_min: _Option[_nt.CoComplex_nd] | None = ...,
+    a_max: _Option[_nt.CoComplex_nd] | None = ...,
     out: None = None,
     *,
-    min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    min: _Option[_nt.CoComplex_nd] | None = ...,
+    max: _Option[_nt.CoComplex_nd] | None = ...,
     dtype: None = None,
     **kwargs: Unpack[UFuncKwargs],
 ) -> _nt.Array[_ScalarT]: ...
 @overload
 def clip(
     a: _nt.ToGeneric_1nd,
-    a_min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    a_max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    a_min: _Option[_nt.CoComplex_nd] | None = ...,
+    a_max: _Option[_nt.CoComplex_nd] | None = ...,
     out: None = None,
     *,
-    min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    min: _Option[_nt.CoComplex_nd] | None = ...,
+    max: _Option[_nt.CoComplex_nd] | None = ...,
     dtype: None = None,
     **kwargs: Unpack[UFuncKwargs],
 ) -> _nt.Array[Incomplete]: ...
 @overload
 def clip(
     a: _nt.ToGeneric_0d,
-    a_min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    a_max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    a_min: _Option[_nt.CoComplex_nd] | None = ...,
+    a_max: _Option[_nt.CoComplex_nd] | None = ...,
     out: None = None,
     *,
-    min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    min: _Option[_nt.CoComplex_nd] | None = ...,
+    max: _Option[_nt.CoComplex_nd] | None = ...,
     dtype: None = None,
     **kwargs: Unpack[UFuncKwargs],
 ) -> Incomplete: ...
 @overload
 def clip(
     a: ArrayLike,
-    a_min: _nt.CoComplex_nd | _NoValueType | None,
-    a_max: _nt.CoComplex_nd | _NoValueType | None,
+    a_min: _Option[_nt.CoComplex_nd] | None,
+    a_max: _Option[_nt.CoComplex_nd] | None,
     out: _ArrayT,
     *,
-    min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    min: _Option[_nt.CoComplex_nd] | None = ...,
+    max: _Option[_nt.CoComplex_nd] | None = ...,
     dtype: DTypeLike | None = None,
     **kwargs: Unpack[UFuncKwargs],
 ) -> _ArrayT: ...
 @overload
 def clip(
     a: ArrayLike,
-    a_min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    a_max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    a_min: _Option[_nt.CoComplex_nd] | None = ...,
+    a_max: _Option[_nt.CoComplex_nd] | None = ...,
     *,
     out: _ArrayT,
-    min: _nt.CoComplex_nd | _NoValueType | None = ...,
-    max: _nt.CoComplex_nd | _NoValueType | None = ...,
+    min: _Option[_nt.CoComplex_nd] | None = ...,
+    max: _Option[_nt.CoComplex_nd] | None = ...,
     dtype: DTypeLike | None = None,
     **kwargs: Unpack[UFuncKwargs],
 ) -> _ArrayT: ...
@@ -588,9 +593,9 @@ def sum(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def sum(
@@ -598,9 +603,9 @@ def sum(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT | _nt.Array[_ScalarT]: ...
 @overload
 def sum(
@@ -608,9 +613,9 @@ def sum(
     axis: None,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def sum(
@@ -619,9 +624,9 @@ def sum(
     *,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def sum(
@@ -629,9 +634,9 @@ def sum(
     axis: _ShapeLike | None,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT | _nt.Array[_ScalarT]: ...
 @overload
 def sum(
@@ -640,9 +645,9 @@ def sum(
     *,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT | _nt.Array[_ScalarT]: ...
 @overload
 def sum(
@@ -650,9 +655,9 @@ def sum(
     axis: _ShapeLike | None = ...,
     dtype: DTypeLike | None = None,
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> Incomplete: ...
 @overload
 def sum(
@@ -661,29 +666,47 @@ def sum(
     dtype: DTypeLike | None = None,
     *,
     out: _ArrayT,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 
 #
-@overload
+@overload  # workaround for microsoft/pyright#10232
 def all(
-    a: _nt.ToGeneric_1ds,
-    axis: int | tuple[int, ...] | None = None,
+    a: _nt._ToArray_nnd[Any],
+    axis: None = None,
     out: None = None,
-    keepdims: L[False, 0] | _NoValueType = ...,
+    keepdims: _Option[L[False, 0]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.bool: ...
 @overload
 def all(
     a: ArrayLike,
     axis: None = None,
     out: None = None,
-    keepdims: L[False, 0] | _NoValueType = ...,
+    keepdims: _Option[L[False, 0]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+) -> np.bool: ...
+@overload  # workaround for microsoft/pyright#10232
+def all(
+    a: _nt._ToArray_nnd[Any],
+    axis: int | tuple[int, ...] | None = None,
+    out: None = None,
+    keepdims: _Option[L[False, 0]] = ...,
+    *,
+    where: _Option[_nt.ToBool_nd] = ...,
+) -> np.bool | _nt.Array[np.bool]: ...
+@overload
+def all(
+    a: _nt.ToGeneric_1ds,
+    axis: int | None = None,
+    out: None = None,
+    keepdims: _Option[L[False, 0]] = ...,
+    *,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.bool: ...
 @overload
 def all(
@@ -692,7 +715,7 @@ def all(
     out: None,
     keepdims: L[True, 1],
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _nt.Array[np.bool]: ...
 @overload
 def all(
@@ -701,25 +724,25 @@ def all(
     out: None = None,
     *,
     keepdims: L[True, 1],
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _nt.Array[np.bool]: ...
 @overload
 def all(
     a: ArrayLike,
     axis: int | tuple[int, ...] | None = None,
     out: None = None,
-    keepdims: _nt.ToBool_0d | _NoValueType = ...,
+    keepdims: _Option[_nt.ToBool_0d] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.bool | _nt.Array[np.bool]: ...
 @overload
 def all(
     a: ArrayLike,
     axis: int | tuple[int, ...] | None,
     out: _ArrayT,
-    keepdims: _nt.ToBool_0d | _NoValueType = ...,
+    keepdims: _Option[_nt.ToBool_0d] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 @overload
 def all(
@@ -727,28 +750,46 @@ def all(
     axis: int | tuple[int, ...] | None = None,
     *,
     out: _ArrayT,
-    keepdims: _nt.ToBool_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[_nt.ToBool_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 
 # keep in sync with `all`
-@overload
+@overload  # workaround for microsoft/pyright#10232
 def any(
-    a: _nt.ToGeneric_1ds,
-    axis: int | tuple[int, ...] | None = None,
+    a: _nt._ToArray_nnd[Any],
+    axis: None = None,
     out: None = None,
-    keepdims: L[False, 0] | _NoValueType = ...,
+    keepdims: _Option[L[False, 0]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.bool: ...
 @overload
 def any(
     a: ArrayLike,
     axis: None = None,
     out: None = None,
-    keepdims: L[False, 0] | _NoValueType = ...,
+    keepdims: _Option[L[False, 0]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+) -> np.bool: ...
+@overload  # workaround for microsoft/pyright#10232
+def any(
+    a: _nt._ToArray_nnd[Any],
+    axis: int | tuple[int, ...] | None = None,
+    out: None = None,
+    keepdims: _Option[L[False, 0]] = ...,
+    *,
+    where: _Option[_nt.ToBool_nd] = ...,
+) -> np.bool | _nt.Array[np.bool]: ...
+@overload
+def any(
+    a: _nt.ToGeneric_1ds,
+    axis: int | None = None,
+    out: None = None,
+    keepdims: _Option[L[False, 0]] = ...,
+    *,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.bool: ...
 @overload
 def any(
@@ -757,7 +798,7 @@ def any(
     out: None,
     keepdims: L[True, 1],
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _nt.Array[np.bool]: ...
 @overload
 def any(
@@ -766,25 +807,25 @@ def any(
     out: None = None,
     *,
     keepdims: L[True, 1],
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _nt.Array[np.bool]: ...
 @overload
 def any(
     a: ArrayLike,
     axis: int | tuple[int, ...] | None = None,
     out: None = None,
-    keepdims: _nt.ToBool_0d | _NoValueType = ...,
+    keepdims: _Option[_nt.ToBool_0d] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.bool | _nt.Array[np.bool]: ...
 @overload
 def any(
     a: ArrayLike,
     axis: int | tuple[int, ...] | None,
     out: _ArrayT,
-    keepdims: _nt.ToBool_0d | _NoValueType = ...,
+    keepdims: _Option[_nt.ToBool_0d] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 @overload
 def any(
@@ -792,8 +833,8 @@ def any(
     axis: int | tuple[int, ...] | None = None,
     *,
     out: _ArrayT,
-    keepdims: _nt.ToBool_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[_nt.ToBool_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 
 #
@@ -871,16 +912,14 @@ def cumulative_sum(
 #
 @overload
 def ptp(
-    a: _nt._ToArray_nd[_ScalarT], axis: None = None, out: None = None, keepdims: L[False] | _NoValueType = ...
+    a: _nt._ToArray_nd[_ScalarT], axis: None = None, out: None = None, keepdims: _Option[L[False]] = ...
 ) -> _ScalarT: ...
 @overload
 def ptp(
-    a: ArrayLike, axis: _ShapeLike | None = None, out: None = None, keepdims: bool | _NoValueType = ...
+    a: ArrayLike, axis: _ShapeLike | None = None, out: None = None, keepdims: _Option[bool] = ...
 ) -> Incomplete: ...
 @overload
-def ptp(
-    a: ArrayLike, axis: _ShapeLike | None = None, *, out: _ArrayT, keepdims: bool | _NoValueType = ...
-) -> _ArrayT: ...
+def ptp(a: ArrayLike, axis: _ShapeLike | None = None, *, out: _ArrayT, keepdims: _Option[bool] = ...) -> _ArrayT: ...
 
 #
 @overload
@@ -888,27 +927,27 @@ def amax(
     a: _nt._ToArray_nd[_ScalarT],
     axis: None = None,
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def amax(
     a: ArrayLike,
     axis: _ShapeLike | None = None,
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> Incomplete: ...
 @overload
 def amax(
     a: ArrayLike,
     axis: _ShapeLike | None,
     out: _ArrayT,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 @overload
 def amax(
@@ -916,9 +955,9 @@ def amax(
     axis: _ShapeLike | None = None,
     *,
     out: _ArrayT,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 
 #
@@ -927,27 +966,27 @@ def amin(
     a: _nt._ToArray_nd[_ScalarT],
     axis: None = None,
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def amin(
     a: ArrayLike,
     axis: _ShapeLike | None = None,
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> Incomplete: ...
 @overload
 def amin(
     a: ArrayLike,
     axis: _ShapeLike | None,
     out: _ArrayT,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 @overload
 def amin(
@@ -955,9 +994,9 @@ def amin(
     axis: _ShapeLike | None = None,
     *,
     out: _ArrayT,
-    keepdims: bool | _NoValueType = ...,
-    initial: _nt.CoComplex_0d | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 
 # TODO: `np.prod()``: For object arrays `initial` does not necessarily have to be a numerical scalar.
@@ -969,9 +1008,9 @@ def prod(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: _NoValueType | L[False] = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.int_: ...
 @overload
 def prod(
@@ -979,9 +1018,9 @@ def prod(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: _NoValueType | L[False] = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.uint64: ...
 @overload
 def prod(
@@ -989,9 +1028,9 @@ def prod(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: _NoValueType | L[False] = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.int64: ...
 @overload
 def prod(
@@ -999,9 +1038,9 @@ def prod(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: _NoValueType | L[False] = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.floating: ...
 @overload
 def prod(
@@ -1009,9 +1048,9 @@ def prod(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: _NoValueType | L[False] = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.complexfloating: ...
 @overload
 def prod(
@@ -1019,9 +1058,9 @@ def prod(
     axis: _ShapeLike | None = ...,
     dtype: None = None,
     out: None = None,
-    keepdims: _NoValueType | bool = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> Incomplete: ...
 @overload
 def prod(
@@ -1029,9 +1068,9 @@ def prod(
     axis: None,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: _NoValueType | L[False] = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def prod(
@@ -1040,9 +1079,9 @@ def prod(
     *,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: _NoValueType | L[False] = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[L[False]] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def prod(
@@ -1050,9 +1089,9 @@ def prod(
     axis: _ShapeLike | None = ...,
     dtype: DTypeLike | None = ...,
     out: None = None,
-    keepdims: _NoValueType | bool = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> Incomplete: ...
 @overload
 def prod(
@@ -1060,9 +1099,9 @@ def prod(
     axis: _ShapeLike | None,
     dtype: DTypeLike | None,
     out: _ArrayT,
-    keepdims: _NoValueType | bool = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 @overload
 def prod(
@@ -1071,9 +1110,9 @@ def prod(
     dtype: DTypeLike | None = ...,
     *,
     out: _ArrayT,
-    keepdims: _NoValueType | bool = ...,
-    initial: _NoValueType | _nt.CoComplex_0d = ...,
-    where: _NoValueType | _nt.ToBool_nd = ...,
+    keepdims: _Option[bool] = ...,
+    initial: _Option[_nt.CoComplex_0d] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 
 #
@@ -1227,11 +1266,11 @@ def size(a: ArrayLike, axis: int | None = None) -> int: ...
 
 #
 @overload
-def around(a: _nt.ToBool_0d, decimals: CanIndex = 0, out: None = None) -> np.float16: ...
+def around(a: np.bool_ | bool, decimals: CanIndex = 0, out: None = None) -> np.float16: ...
 @overload
 def around(a: _nt.ToBool_1nd, decimals: CanIndex = 0, out: None = None) -> _nt.Array[np.float16]: ...
 @overload
-def around(a: _nt.CanArray0D[_NumberT], decimals: CanIndex = 0, out: None = None) -> _NumberT: ...
+def around(a: _NumberT, decimals: CanIndex = 0, out: None = None) -> _NumberT: ...
 @overload
 def around(a: _nt._ToArray_1nd[_NumberT], decimals: CanIndex = 0, out: None = None) -> _nt.Array[_NumberT]: ...
 @overload
@@ -1254,9 +1293,9 @@ def mean(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.floating: ...
 @overload
 def mean(
@@ -1264,9 +1303,9 @@ def mean(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.complexfloating: ...
 @overload
 def mean(
@@ -1274,9 +1313,9 @@ def mean(
     axis: None = None,
     dtype: None = None,
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> np.timedelta64: ...
 @overload
 def mean(
@@ -1284,9 +1323,9 @@ def mean(
     axis: _ShapeLike | None = ...,
     dtype: None = None,
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> Any: ...
 @overload
 def mean(
@@ -1294,9 +1333,9 @@ def mean(
     axis: None,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def mean(
@@ -1305,8 +1344,8 @@ def mean(
     *,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: L[False] | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT: ...
 @overload
 def mean(
@@ -1314,9 +1353,9 @@ def mean(
     axis: None,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT | _nt.Array[_ScalarT]: ...
 @overload
 def mean(
@@ -1325,8 +1364,8 @@ def mean(
     *,
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
-    keepdims: bool | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ScalarT | _nt.Array[_ScalarT]: ...
 @overload
 def mean(
@@ -1334,9 +1373,9 @@ def mean(
     axis: _ShapeLike | None,
     dtype: DTypeLike | None,
     out: _ArrayT,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 @overload
 def mean(
@@ -1345,8 +1384,8 @@ def mean(
     dtype: DTypeLike | None = None,
     *,
     out: _ArrayT,
-    keepdims: bool | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> _ArrayT: ...
 @overload
 def mean(
@@ -1354,9 +1393,9 @@ def mean(
     axis: _ShapeLike | None = None,
     dtype: DTypeLike | None = None,
     out: _nt.Array | None = None,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
 ) -> Incomplete: ...
 
 #
@@ -1367,11 +1406,11 @@ def std(
     dtype: None = None,
     out: None = None,
     ddof: float = 0,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> np.floating: ...
 @overload
 def std(
@@ -1380,11 +1419,11 @@ def std(
     dtype: None = None,
     out: None = None,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> Any: ...
 @overload
 def std(
@@ -1393,11 +1432,11 @@ def std(
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
     ddof: float = 0,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ScalarT: ...
 @overload
 def std(
@@ -1407,10 +1446,10 @@ def std(
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
     ddof: float = 0,
-    keepdims: L[False] | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ScalarT: ...
 @overload
 def std(
@@ -1419,11 +1458,11 @@ def std(
     dtype: DTypeLike | None,
     out: _ArrayT,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ArrayT: ...
 @overload
 def std(
@@ -1433,10 +1472,10 @@ def std(
     *,
     out: _ArrayT,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ArrayT: ...
 @overload
 def std(
@@ -1445,11 +1484,11 @@ def std(
     dtype: DTypeLike | None = None,
     out: _nt.Array | None = None,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> Incomplete: ...
 
 #
@@ -1460,11 +1499,11 @@ def var(
     dtype: None = None,
     out: None = None,
     ddof: float = 0,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> np.floating: ...
 @overload
 def var(
@@ -1473,11 +1512,11 @@ def var(
     dtype: None = None,
     out: None = None,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> Any: ...
 @overload
 def var(
@@ -1486,11 +1525,11 @@ def var(
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
     ddof: float = 0,
-    keepdims: L[False] | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ScalarT: ...
 @overload
 def var(
@@ -1500,10 +1539,10 @@ def var(
     dtype: _DTypeLike[_ScalarT],
     out: None = None,
     ddof: float = 0,
-    keepdims: L[False] | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    keepdims: _Option[L[False]] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ScalarT: ...
 @overload
 def var(
@@ -1512,11 +1551,11 @@ def var(
     dtype: DTypeLike | None,
     out: _ArrayT,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ArrayT: ...
 @overload
 def var(
@@ -1526,10 +1565,10 @@ def var(
     *,
     out: _ArrayT,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> _ArrayT: ...
 @overload
 def var(
@@ -1538,11 +1577,11 @@ def var(
     dtype: DTypeLike | None = None,
     out: _nt.Array | None = None,
     ddof: float = 0,
-    keepdims: bool | _NoValueType = ...,
+    keepdims: _Option[bool] = ...,
     *,
-    where: _nt.ToBool_nd | _NoValueType = ...,
-    mean: _nt.CoComplex_nd | _nt.ToObject_nd | _NoValueType = ...,
-    correction: float | _NoValueType = ...,
+    where: _Option[_nt.ToBool_nd] = ...,
+    mean: _Option[_nt.CoComplex_nd | _nt.ToObject_nd] = ...,
+    correction: _Option[float] = ...,
 ) -> Incomplete: ...
 
 max = amax
diff --git a/src/numpy-stubs/_core/numeric.pyi b/src/numpy-stubs/_core/numeric.pyi
index 3c67d1a1..f81ef6af 100644
--- a/src/numpy-stubs/_core/numeric.pyi
+++ b/src/numpy-stubs/_core/numeric.pyi
@@ -714,7 +714,7 @@ def ones(
     *,
     device: _Device | None = None,
     like: _SupportsArrayFunc | None = None,
-) -> np.ndarray[Any, _DTypeT]: ...
+) -> np.ndarray[_nt.AnyShape, _DTypeT]: ...
 @overload  # unknown shape, known scalar-type
 def ones(
     shape: _ShapeLike,
@@ -976,7 +976,7 @@ def full(
     *,
     device: _Device | None = None,
     like: _SupportsArrayFunc | None = None,
-) -> np.ndarray[Any, _DTypeT]: ...
+) -> np.ndarray[_nt.AnyShape, _DTypeT]: ...
 @overload  # unknown shape, known scalar-type
 def full(
     shape: _ShapeLike,
@@ -1029,6 +1029,16 @@ def zeros_like(
     *,
     device: _Device | None = None,
 ) -> np.ndarray[_ShapeT, _DTypeT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def zeros_like(
+    a: _nt._ToArray_nnd[np.bool_],
+    dtype: _nt.ToDTypeBool | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.bool_]: ...
 @overload  # bool 0d array-like
 def zeros_like(  # type: ignore[overload-overlap]
     a: _nt.ToBool_0d,
@@ -1069,6 +1079,16 @@ def zeros_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.bool_]: ...
+@overload  # workaround for microsoft/pyright#10232
+def zeros_like(
+    a: _nt._ToArray_nnd[np.intp],
+    dtype: _nt.ToDTypeInt64 | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.intp]: ...
 @overload  # int 0d array-like
 def zeros_like(  # type: ignore[overload-overlap]
     a: _nt.ToInt_0d,
@@ -1109,6 +1129,16 @@ def zeros_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.intp]: ...
+@overload  # workaround for microsoft/pyright#10232
+def zeros_like(
+    a: _nt._ToArray_nnd[np.float64],
+    dtype: _nt.ToDTypeFloat64 | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.float64]: ...
 @overload  # float 0d array-like
 def zeros_like(  # type: ignore[overload-overlap]
     a: _nt.ToFloat64_0d,
@@ -1149,6 +1179,16 @@ def zeros_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.float64]: ...
+@overload  # workaround for microsoft/pyright#10232
+def zeros_like(
+    a: _nt._ToArray_nnd[np.complex128],
+    dtype: _nt.ToDTypeComplex128 | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.complex128]: ...
 @overload  # complex 0d array-like
 def zeros_like(  # type: ignore[overload-overlap]
     a: _nt.ToComplex128_0d,
@@ -1200,7 +1240,7 @@ def zeros_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT, _AnyShapeT]: ...
 @overload  # array-like with known scalar-type, unknown shape
-def zeros_like(  # type: ignore[overload-overlap]
+def zeros_like(
     a: _ArrayLike[_ScalarT],
     dtype: np.dtype[_ScalarT] | None = None,
     order: _OrderKACF = "K",
@@ -1228,7 +1268,7 @@ def zeros_like(
     shape: _ShapeLike | None = None,
     *,
     device: _Device | None = None,
-) -> np.ndarray[Any, _DTypeT]: ...
+) -> np.ndarray[_nt.AnyShape, _DTypeT]: ...
 @overload  # given shape, given scalar-type
 def zeros_like(
     a: object,
@@ -1250,7 +1290,7 @@ def zeros_like(
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT]: ...
 @overload  # bool array-like
-def zeros_like(  # type: ignore[overload-overlap]
+def zeros_like(
     a: _nt.ToBool_nd,
     dtype: _nt.ToDTypeBool | None = None,
     order: _OrderKACF = "K",
@@ -1260,7 +1300,7 @@ def zeros_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.bool_]: ...
 @overload  # int array-like
-def zeros_like(  # type: ignore[overload-overlap]
+def zeros_like(
     a: _nt.ToInt_nd,
     dtype: _nt.ToDTypeInt64 | None = None,
     order: _OrderKACF = "K",
@@ -1270,7 +1310,7 @@ def zeros_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.intp]: ...
 @overload  # float array-like
-def zeros_like(  # type: ignore[overload-overlap]
+def zeros_like(
     a: _nt.ToFloat64_nd,
     dtype: _nt.ToDTypeFloat64 | None = None,
     order: _OrderKACF = "K",
@@ -1280,7 +1320,7 @@ def zeros_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.float64]: ...
 @overload  # complex array-like
-def zeros_like(  # type: ignore[overload-overlap]
+def zeros_like(
     a: _nt.ToComplex128_nd,
     dtype: _nt.ToDTypeComplex128 | None = None,
     order: _OrderKACF = "K",
@@ -1331,6 +1371,16 @@ def ones_like(
     *,
     device: _Device | None = None,
 ) -> np.ndarray[_ShapeT, _DTypeT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def ones_like(
+    a: _nt._ToArray_nnd[np.bool_],
+    dtype: _nt.ToDTypeBool | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.bool_]: ...
 @overload  # bool 0d array-like
 def ones_like(  # type: ignore[overload-overlap]
     a: _nt.ToBool_0d,
@@ -1371,6 +1421,16 @@ def ones_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.bool_]: ...
+@overload  # workaround for microsoft/pyright#10232
+def ones_like(
+    a: _nt._ToArray_nnd[np.intp],
+    dtype: _nt.ToDTypeInt64 | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.intp]: ...
 @overload  # int 0d array-like
 def ones_like(  # type: ignore[overload-overlap]
     a: _nt.ToInt_0d,
@@ -1411,6 +1471,16 @@ def ones_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.intp]: ...
+@overload  # workaround for microsoft/pyright#10232
+def ones_like(
+    a: _nt._ToArray_nnd[np.float64],
+    dtype: _nt.ToDTypeFloat64 | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.float64]: ...
 @overload  # float 0d array-like
 def ones_like(  # type: ignore[overload-overlap]
     a: _nt.ToFloat64_0d,
@@ -1451,6 +1521,16 @@ def ones_like(
     *,
     device: _Device | None = None,
 ) -> _nt.Array3D[np.float64]: ...
+@overload  # workaround for microsoft/pyright#10232
+def ones_like(
+    a: _nt._ToArray_nnd[np.complex128],
+    dtype: _nt.ToDTypeComplex128 | None = None,
+    order: _OrderKACF = "K",
+    subok: py_bool = True,
+    shape: tuple[()] | None = None,
+    *,
+    device: _Device | None = None,
+) -> _nt.Array[np.complex128]: ...
 @overload  # complex 0d array-like
 def ones_like(  # type: ignore[overload-overlap]
     a: _nt.ToComplex128_0d,
@@ -1502,7 +1582,7 @@ def ones_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT, _AnyShapeT]: ...
 @overload  # array-like with known scalar-type, unknown shape
-def ones_like(  # type: ignore[overload-overlap]
+def ones_like(
     a: _ArrayLike[_ScalarT],
     dtype: np.dtype[_ScalarT] | None = None,
     order: _OrderKACF = "K",
@@ -1530,7 +1610,7 @@ def ones_like(
     shape: _ShapeLike | None = None,
     *,
     device: _Device | None = None,
-) -> np.ndarray[Any, _DTypeT]: ...
+) -> np.ndarray[_nt.AnyShape, _DTypeT]: ...
 @overload  # given shape, given scalar-type
 def ones_like(
     a: object,
@@ -1552,7 +1632,7 @@ def ones_like(
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT]: ...
 @overload  # bool array-like
-def ones_like(  # type: ignore[overload-overlap]
+def ones_like(
     a: _nt.ToBool_nd,
     dtype: _nt.ToDTypeBool | None = None,
     order: _OrderKACF = "K",
@@ -1562,7 +1642,7 @@ def ones_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.bool_]: ...
 @overload  # int array-like
-def ones_like(  # type: ignore[overload-overlap]
+def ones_like(
     a: _nt.ToInt_nd,
     dtype: _nt.ToDTypeInt64 | None = None,
     order: _OrderKACF = "K",
@@ -1572,7 +1652,7 @@ def ones_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.intp]: ...
 @overload  # float array-like
-def ones_like(  # type: ignore[overload-overlap]
+def ones_like(
     a: _nt.ToFloat64_nd,
     dtype: _nt.ToDTypeFloat64 | None = None,
     order: _OrderKACF = "K",
@@ -1582,7 +1662,7 @@ def ones_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.float64]: ...
 @overload  # complex array-like
-def ones_like(  # type: ignore[overload-overlap]
+def ones_like(
     a: _nt.ToComplex128_nd,
     dtype: _nt.ToDTypeComplex128 | None = None,
     order: _OrderKACF = "K",
@@ -1823,7 +1903,7 @@ def full_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT, _AnyShapeT]: ...
 @overload  # array-like with known scalar-type, unknown shape
-def full_like(  # type: ignore[overload-overlap]
+def full_like(
     a: _ArrayLike[_ScalarT],
     fill_value: object,
     dtype: np.dtype[_ScalarT] | None = None,
@@ -1854,7 +1934,7 @@ def full_like(
     shape: _ShapeLike | None = None,
     *,
     device: _Device | None = None,
-) -> np.ndarray[Any, _DTypeT]: ...
+) -> np.ndarray[_nt.AnyShape, _DTypeT]: ...
 @overload  # given shape, given scalar-type
 def full_like(
     a: object,
@@ -1878,7 +1958,7 @@ def full_like(
     device: _Device | None = None,
 ) -> _nt.Array[_ScalarT]: ...
 @overload  # bool array-like
-def full_like(  # type: ignore[overload-overlap]
+def full_like(
     a: _nt.ToBool_nd,
     fill_value: object,
     dtype: _nt.ToDTypeBool | None = None,
@@ -1889,7 +1969,7 @@ def full_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.bool_]: ...
 @overload  # int array-like
-def full_like(  # type: ignore[overload-overlap]
+def full_like(
     a: _nt.ToInt_nd,
     fill_value: object,
     dtype: _nt.ToDTypeInt64 | None = None,
@@ -1900,7 +1980,7 @@ def full_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.intp]: ...
 @overload  # float array-like
-def full_like(  # type: ignore[overload-overlap]
+def full_like(
     a: _nt.ToFloat64_nd,
     fill_value: object,
     dtype: _nt.ToDTypeFloat64 | None = None,
@@ -1911,7 +1991,7 @@ def full_like(  # type: ignore[overload-overlap]
     device: _Device | None = None,
 ) -> _nt.Array[np.float64]: ...
 @overload  # complex array-like
-def full_like(  # type: ignore[overload-overlap]
+def full_like(
     a: _nt.ToComplex128_nd,
     fill_value: object,
     dtype: _nt.ToDTypeComplex128 | None = None,
@@ -2247,7 +2327,11 @@ def allclose(
 #
 @overload
 def isclose(
-    a: _nt.ToGeneric_0d, b: _nt.ToGeneric_0d, rtol: ArrayLike = 1e-5, atol: ArrayLike = 1e-8, equal_nan: py_bool = False
+    a: np.generic | _nt._PyScalar,
+    b: np.generic | _nt._PyScalar,
+    rtol: ArrayLike = 1e-5,
+    atol: ArrayLike = 1e-8,
+    equal_nan: py_bool = False,
 ) -> np.bool: ...
 @overload
 def isclose(
diff --git a/src/numpy-stubs/lib/_arrayterator_impl.pyi b/src/numpy-stubs/lib/_arrayterator_impl.pyi
index 71bcfbaf..ca2d5f70 100644
--- a/src/numpy-stubs/lib/_arrayterator_impl.pyi
+++ b/src/numpy-stubs/lib/_arrayterator_impl.pyi
@@ -7,7 +7,6 @@ from typing_extensions import TypeVar, override
 
 import _numtype as _nt
 import numpy as np
-from numpy import _AnyShapeT  # noqa: ICN003
 
 __all__ = ["Arrayterator"]
 
@@ -37,7 +36,7 @@ class Arrayterator(np.ndarray[_ShapeT_co, _DTypeT_co], Generic[_ShapeT_co, _DTyp
     @override
     # NOTE: This constrained typevar use is a workaround for a mypy bug
     # def shape(self: _nt.HasInnerShape[_ShapeT] | ndarray[_ShapeT2]) -> _ShapeT | _ShapeT2: ...  # noqa: ERA001
-    def shape(self: Arrayterator[_AnyShapeT]) -> _AnyShapeT: ...
+    def shape(self) -> _ShapeT_co: ...
 
     #
     @property
@@ -47,9 +46,9 @@ class Arrayterator(np.ndarray[_ShapeT_co, _DTypeT_co], Generic[_ShapeT_co, _DTyp
     #
     def __init__(self, /, var: np.ndarray[_ShapeT_co, _DTypeT_co], buf_size: int | None = None) -> None: ...  # pyright: ignore[reportInconsistentConstructor]
     @override
-    def __getitem__(self, index: _AnyIndex, /) -> Arrayterator[_nt.Shape, _DTypeT_co]: ...  # type: ignore[override]
+    def __getitem__(self, index: _AnyIndex, /) -> Arrayterator[_nt.AnyShape, _DTypeT_co]: ...  # type: ignore[override]
     @override
-    def __iter__(self) -> Generator[np.ndarray[_nt.Shape, _DTypeT_co]]: ...
+    def __iter__(self) -> Generator[np.ndarray[_nt.AnyShape, _DTypeT_co]]: ...
 
     #
     @overload  # type: ignore[override]
diff --git a/src/numpy-stubs/lib/_function_base_impl.pyi b/src/numpy-stubs/lib/_function_base_impl.pyi
index 49d4c30b..d0cf5014 100644
--- a/src/numpy-stubs/lib/_function_base_impl.pyi
+++ b/src/numpy-stubs/lib/_function_base_impl.pyi
@@ -75,6 +75,7 @@ _ScalarT = TypeVar("_ScalarT", bound=np.generic)
 _ScalarT1 = TypeVar("_ScalarT1", bound=np.generic)
 _ScalarT2 = TypeVar("_ScalarT2", bound=np.generic)
 _NumberT = TypeVar("_NumberT", bound=np.number)
+_TrapezoidScalarT = TypeVar("_TrapezoidScalarT", bound=np.inexact | np.timedelta64)
 
 _Tuple2: TypeAlias = tuple[_T, _T]
 _ToInt: TypeAlias = CanIndex | SupportsInt
@@ -367,11 +368,6 @@ def copy(a: _ArrayLike[_ScalarT], order: _Order = "K", subok: L[False] = False)
 def copy(a: ArrayLike, order: _Order = "K", subok: L[False] = False) -> _nt.Array[Incomplete]: ...
 
 #
-@overload
-def gradient(
-    f: _nt.ToGeneric_0d, *varargs: ArrayLike, axis: _ShapeLike | None = None, edge_order: L[1, 2] = 1
-) -> tuple[()]: ...
-@overload
 def gradient(
     f: ArrayLike, *varargs: ArrayLike, axis: _ShapeLike | None = None, edge_order: L[1, 2] = 1
 ) -> Incomplete: ...
@@ -483,13 +479,13 @@ def interp(
 
 #
 @overload
-def angle(z: _nt.CoComplex_0d, deg: bool = False) -> np.floating: ...
-@overload
 def angle(z: _nt.CoComplex_1nd, deg: bool = False) -> _nt.Array[np.floating]: ...
 @overload
-def angle(z: np.object_, deg: bool = False) -> Incomplete: ...
+def angle(z: _nt.co_complex | complex, deg: bool = False) -> np.floating: ...
 @overload
 def angle(z: _nt.ToObject_1nd, deg: bool = False) -> _nt.Array[np.object_]: ...
+@overload
+def angle(z: _nt.ToObject_nd, deg: bool = False) -> Incomplete: ...
 
 #
 @overload
@@ -733,9 +729,9 @@ def i0(x: _nt.CoFloating_nd) -> _nt.Array[np.floating]: ...
 
 #
 @overload
-def sinc(x: _nt.CoFloating_0d) -> np.floating: ...
+def sinc(x: _nt.co_float | float) -> np.floating: ...
 @overload
-def sinc(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def sinc(x: np.complexfloating | _nt.JustComplex) -> np.complexfloating: ...
 @overload
 def sinc(x: _nt.CoFloating_1nd) -> _nt.Array[np.floating]: ...
 @overload
@@ -964,6 +960,27 @@ def percentile(
 # NOTE: Not an alias, but they do have identical signatures (that we can reuse)
 quantile = percentile
 
+@overload  # workaround for microsoft/pyright#10232
+def trapezoid(
+    y: _nt._ToArray_nnd[np.float64 | _nt.co_integer],
+    x: _nt._ToArray_nnd[np.float64 | _nt.co_integer] | None = None,
+    dx: _nt.CoFloat64_0d = 1.0,
+    axis: CanIndex = -1,
+) -> np.float64 | _nt.Array[np.float64]: ...
+@overload  # workaround for microsoft/pyright#10232
+def trapezoid(
+    y: _nt._ToArray_nnd[_TrapezoidScalarT],
+    x: _nt.Casts[_TrapezoidScalarT, _nt.NeitherShape] | None = None,
+    dx: _nt.CastsScalar[_TrapezoidScalarT] | float = 1.0,
+    axis: CanIndex = -1,
+) -> _TrapezoidScalarT | _nt.Array[_TrapezoidScalarT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def trapezoid(
+    y: _nt.Casts[_TrapezoidScalarT, _nt.NeitherShape],
+    x: _nt._ToArray_nnd[_TrapezoidScalarT],
+    dx: _nt.CastsScalar[_TrapezoidScalarT] | float = 1.0,
+    axis: CanIndex = -1,
+) -> _TrapezoidScalarT | _nt.Array[_TrapezoidScalarT]: ...
 @overload
 def trapezoid(
     y: _nt._ToArray2_1ds[np.float64 | _nt.co_integer, float],
@@ -972,6 +989,33 @@ def trapezoid(
     axis: CanIndex = -1,
 ) -> np.float64: ...
 @overload
+def trapezoid(
+    y: _nt.CoFloating_1ds, x: _nt.CoFloating_1ds | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+) -> np.floating: ...
+@overload
+def trapezoid(
+    y: _nt.ToComplex_1ds, x: _nt.CoComplex_1ds | None = None, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
+) -> np.complexfloating: ...
+@overload
+def trapezoid(
+    y: _nt.CoComplex_1ds, x: _nt.ToComplex_1ds, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
+) -> np.complexfloating: ...
+@overload
+def trapezoid(
+    y: _nt.ToTimeDelta_1ds, x: _nt.CoTimeDelta_1ds | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+) -> np.timedelta64: ...
+@overload
+def trapezoid(
+    y: _nt.CoTimeDelta_1ds, x: _nt.ToTimeDelta_1ds, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+) -> np.timedelta64: ...
+@overload
+def trapezoid(
+    y: Sequence[dt.timedelta],
+    x: Sequence[dt.timedelta] | _nt.CoFloating_1ds | None = None,
+    dx: _nt.CoComplex_0d = 1.0,
+    axis: CanIndex = -1,
+) -> dt.timedelta: ...
+@overload
 def trapezoid(
     y: _nt._ToArray2_2nd[np.float64 | _nt.co_integer, float],
     x: _nt._ToArray2_1nd[np.float64 | _nt.co_integer, float] | None = None,
@@ -986,10 +1030,6 @@ def trapezoid(
     axis: CanIndex = -1,
 ) -> _nt.Array[np.float64]: ...
 @overload
-def trapezoid(
-    y: _nt.CoFloating_1ds, x: _nt.CoFloating_1ds | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
-) -> np.floating: ...
-@overload
 def trapezoid(
     y: _nt.CoFloating_2nd, x: _nt.CoFloating_1nd | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
 ) -> _nt.Array[np.floating]: ...
@@ -998,14 +1038,6 @@ def trapezoid(
     y: _nt.CoFloating_1nd, x: _nt.CoFloating_2nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
 ) -> _nt.Array[np.floating]: ...
 @overload
-def trapezoid(
-    y: _nt.CoFloating_1nd, x: _nt.CoFloating_1nd | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
-) -> np.floating | _nt.Array[np.floating]: ...
-@overload
-def trapezoid(
-    y: _nt.ToComplex_1ds, x: _nt.CoComplex_1ds | None = None, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
-) -> np.complexfloating: ...
-@overload
 def trapezoid(
     y: _nt.ToComplex_2nd, x: _nt.CoComplex_1nd | None = None, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
 ) -> _nt.Array[np.complexfloating]: ...
@@ -1014,14 +1046,6 @@ def trapezoid(
     y: _nt.ToComplex_1nd, x: _nt.CoComplex_2nd, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
 ) -> _nt.Array[np.complexfloating]: ...
 @overload
-def trapezoid(
-    y: _nt.ToComplex_1nd, x: _nt.CoComplex_1nd | None = None, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
-) -> np.complexfloating | _nt.Array[np.complexfloating]: ...
-@overload
-def trapezoid(
-    y: _nt.CoComplex_1ds, x: _nt.ToComplex_1ds, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
-) -> np.complexfloating: ...
-@overload
 def trapezoid(
     y: _nt.CoComplex_2nd, x: _nt.ToComplex_1nd, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
 ) -> _nt.Array[np.complexfloating]: ...
@@ -1031,48 +1055,41 @@ def trapezoid(
 ) -> _nt.Array[np.complexfloating]: ...
 @overload
 def trapezoid(
-    y: _nt.CoComplex_1nd, x: _nt.ToComplex_1nd, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
-) -> np.complexfloating | _nt.Array[np.complexfloating]: ...
+    y: _nt.ToTimeDelta_2nd, x: _nt.CoTimeDelta_1nd | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+) -> _nt.Array[np.timedelta64]: ...
 @overload
 def trapezoid(
-    y: _nt.ToTimeDelta_1ds, x: _nt.CoTimeDelta_1ds | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
-) -> np.timedelta64: ...
+    y: _nt.ToTimeDelta_1nd, x: _nt.CoTimeDelta_2nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+) -> _nt.Array[np.timedelta64]: ...
 @overload
 def trapezoid(
-    y: _nt.ToTimeDelta_2nd, x: _nt.CoTimeDelta_1nd | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+    y: _nt.CoTimeDelta_2nd, x: _nt.ToTimeDelta_1nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
 ) -> _nt.Array[np.timedelta64]: ...
 @overload
 def trapezoid(
-    y: _nt.ToTimeDelta_1nd, x: _nt.CoTimeDelta_2nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+    y: _nt.CoTimeDelta_1nd, x: _nt.ToTimeDelta_2nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
 ) -> _nt.Array[np.timedelta64]: ...
 @overload
 def trapezoid(
-    y: _nt.ToTimeDelta_1nd, x: _nt.CoTimeDelta_1nd | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
-) -> np.timedelta64 | _nt.Array[np.timedelta64]: ...
+    y: _nt.CoFloating_1nd, x: _nt.CoFloating_1nd | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+) -> np.floating | _nt.Array[np.floating]: ...
 @overload
 def trapezoid(
-    y: _nt.CoTimeDelta_1ds, x: _nt.ToTimeDelta_1ds, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
-) -> np.timedelta64: ...
+    y: _nt.ToComplex_1nd, x: _nt.CoComplex_1nd | None = None, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
+) -> np.complexfloating | _nt.Array[np.complexfloating]: ...
 @overload
 def trapezoid(
-    y: _nt.CoTimeDelta_2nd, x: _nt.ToTimeDelta_1nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
-) -> _nt.Array[np.timedelta64]: ...
+    y: _nt.CoComplex_1nd, x: _nt.ToComplex_1nd, dx: _nt.CoComplex_0d = 1.0, axis: CanIndex = -1
+) -> np.complexfloating | _nt.Array[np.complexfloating]: ...
 @overload
 def trapezoid(
-    y: _nt.CoTimeDelta_1nd, x: _nt.ToTimeDelta_2nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
-) -> _nt.Array[np.timedelta64]: ...
+    y: _nt.ToTimeDelta_1nd, x: _nt.CoTimeDelta_1nd | None = None, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
+) -> np.timedelta64 | _nt.Array[np.timedelta64]: ...
 @overload
 def trapezoid(
     y: _nt.CoTimeDelta_1nd, x: _nt.ToTimeDelta_1nd, dx: _nt.CoFloating_0d = 1.0, axis: CanIndex = -1
 ) -> np.timedelta64 | _nt.Array[np.timedelta64]: ...
 @overload
-def trapezoid(
-    y: Sequence[dt.timedelta],
-    x: Sequence[dt.timedelta] | _nt.CoFloating_1ds | None = None,
-    dx: _nt.CoComplex_0d = 1.0,
-    axis: CanIndex = -1,
-) -> dt.timedelta: ...
-@overload
 def trapezoid(
     y: Sequence[_CanRMulFloat[_T]],
     x: Sequence[_CanRMulFloat[_T]] | Sequence[_T] | None = None,
@@ -1174,6 +1191,8 @@ def insert(
 def append(arr: ArrayLike, values: ArrayLike, axis: CanIndex | None = ...) -> _nt.Array[Incomplete]: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def digitize(x: _nt._ToArray_nnd[_nt.co_float], bins: _nt.CoFloating_1d, right: bool = False) -> _nt.Array[np.intp]: ...
 @overload
 def digitize(x: _nt.CoFloating_0d, bins: _nt.CoFloating_1d, right: bool = False) -> np.intp: ...
 @overload
diff --git a/src/numpy-stubs/lib/_index_tricks_impl.pyi b/src/numpy-stubs/lib/_index_tricks_impl.pyi
index 1bc3be46..dface2d3 100644
--- a/src/numpy-stubs/lib/_index_tricks_impl.pyi
+++ b/src/numpy-stubs/lib/_index_tricks_impl.pyi
@@ -167,7 +167,7 @@ class IndexExpression(Generic[_BoolT_co]):
     def __getitem__(self, item: _T, /) -> _T | tuple[_T]: ...
 
 @overload
-def ix_(*args: _nt.SequenceND[_HasDType[_DTypeT]]) -> tuple[np.ndarray[_nt.Shape, _DTypeT], ...]: ...
+def ix_(*args: _nt.SequenceND[_HasDType[_DTypeT]]) -> tuple[np.ndarray[_nt.AnyShape, _DTypeT], ...]: ...
 @overload
 def ix_(*args: _nt.SequenceND[bool]) -> _Arrays[np.bool]: ...
 @overload
diff --git a/src/numpy-stubs/lib/_polynomial_impl.pyi b/src/numpy-stubs/lib/_polynomial_impl.pyi
index 90179aec..23947213 100644
--- a/src/numpy-stubs/lib/_polynomial_impl.pyi
+++ b/src/numpy-stubs/lib/_polynomial_impl.pyi
@@ -410,6 +410,18 @@ def polyfit(
 ) -> _Tuple_didd[_nt.Array[np.complex128]]: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def polyval(p: _nt.Casts[_ScalarT, _nt.NeitherShape], x: _nt._ToArray_nnd[_ScalarT]) -> _nt.Array[_ScalarT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def polyval(
+    p: _nt.CastsWith[_ScalarT, _NumberT, _nt.NeitherShape], x: _nt._ToArray_nnd[_ScalarT]
+) -> _nt.Array[_NumberT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def polyval(p: _nt._ToArray_nnd[_ScalarT], x: _nt.Casts[_ScalarT, _nt.NeitherShape]) -> _nt.Array[_ScalarT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def polyval(
+    p: _nt._ToArray_nnd[_ScalarT], x: _nt.CastsWith[_ScalarT, _NumberT, _nt.NeitherShape]
+) -> _nt.Array[_NumberT]: ...
 @overload
 def polyval(p: _nt.ToBool_1d, x: _nt.ToBool_0d) -> np.bool: ...
 @overload
diff --git a/src/numpy-stubs/lib/_scimath_impl.pyi b/src/numpy-stubs/lib/_scimath_impl.pyi
index caec8554..b68c8d9a 100644
--- a/src/numpy-stubs/lib/_scimath_impl.pyi
+++ b/src/numpy-stubs/lib/_scimath_impl.pyi
@@ -7,11 +7,9 @@ __all__ = ["arccos", "arcsin", "arctanh", "log", "log2", "log10", "logn", "power
 
 ###
 
-_ToScalar_iu1: TypeAlias = _nt.CanArray0D[_nt.integer8]
-_ToScalar_iu2: TypeAlias = _nt.CanArray0D[_nt.integer16]
-_ToScalar_iu4_iu8: TypeAlias = _nt.CanArray0D[_nt.integer32 | _nt.integer64] | _nt.JustInt
-_ToScalar_i4_i8: TypeAlias = _nt.CanArray0D[np.int32 | np.int64] | _nt.JustInt
-_ToScalar_u4_u8: TypeAlias = _nt.CanArray0D[np.uint32 | np.uint64]
+_ToScalar_iu4_iu8: TypeAlias = _nt.integer32 | _nt.integer64 | _nt.JustInt
+_ToScalar_i4_i8: TypeAlias = np.int32 | np.int64 | _nt.JustInt
+_ToScalar_u4_u8: TypeAlias = np.uint32 | np.uint64
 
 _ToArray_iu1: TypeAlias = _nt._ToArray_1nd[_nt.integer8]
 _ToArray_iu2: TypeAlias = _nt._ToArray_1nd[_nt.integer16]
@@ -28,39 +26,39 @@ _ToArray_u4_u8: TypeAlias = _nt._ToArray_1nd[np.uint32 | np.uint64]
 
 #
 @overload
-def sqrt(x: _nt.ToBool_0d) -> np.float16: ...
+def sqrt(x: bool | np.bool_) -> np.float16: ...
 @overload
 def sqrt(x: _ToScalar_u4_u8) -> np.float64: ...
 @overload
-def sqrt(x: _nt.ToUInt16_0d) -> np.float32: ...
+def sqrt(x: np.uint16) -> np.float32: ...
 @overload
-def sqrt(x: _nt.ToUInt8_0d) -> np.float16: ...
+def sqrt(x: np.uint8) -> np.float16: ...
 @overload
-def sqrt(x: _nt.CoUInt64_0d) -> np.floating: ...
+def sqrt(x: _nt.co_uint64) -> np.floating: ...
 @overload
 def sqrt(x: _ToScalar_i4_i8) -> _nt.inexact64: ...
 @overload
-def sqrt(x: _nt.ToInt16_0d) -> _nt.inexact32: ...
+def sqrt(x: np.int16) -> _nt.inexact32: ...
 @overload
-def sqrt(x: _nt.ToInt8_0d) -> np.float16 | np.complex64: ...
+def sqrt(x: np.int8) -> np.float16 | np.complex64: ...
 @overload
-def sqrt(x: _nt.ToFloat64_0d) -> _nt.inexact64: ...
+def sqrt(x: _nt.JustFloat | np.float64) -> _nt.inexact64: ...
 @overload
-def sqrt(x: _nt.ToLongDouble_0d) -> np.longdouble | np.complex128: ...
+def sqrt(x: np.longdouble) -> np.longdouble | np.complex128: ...
 @overload
-def sqrt(x: _nt.ToFloat32_0d) -> _nt.inexact32: ...
+def sqrt(x: np.float32) -> _nt.inexact32: ...
 @overload
-def sqrt(x: _nt.ToFloat16_0d) -> np.float16 | np.complex128: ...
+def sqrt(x: np.float16) -> np.float16 | np.complex128: ...
 @overload
-def sqrt(x: _nt.ToComplex128_0d) -> np.complex128: ...
+def sqrt(x: _nt.JustComplex | np.complex128) -> np.complex128: ...
 @overload
-def sqrt(x: _nt.ToCLongDouble_0d) -> np.complex128 | np.clongdouble: ...
+def sqrt(x: np.clongdouble) -> np.complex128 | np.clongdouble: ...
 @overload
-def sqrt(x: _nt.ToComplex64_0d) -> np.complex64: ...
+def sqrt(x: np.complex64) -> np.complex64: ...
 @overload
-def sqrt(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def sqrt(x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def sqrt(x: _nt.CoComplex_0d) -> np.inexact: ...
+def sqrt(x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def sqrt(x: _nt.ToBool_1nd) -> _nt.Array[np.float16]: ...
 @overload
@@ -98,39 +96,39 @@ def sqrt(x: _nt.CoComplex_1nd) -> _nt.Array[np.inexact]: ...
 
 # signature is equivalent to `sqrt`
 @overload
-def log(x: _nt.ToBool_0d) -> np.float16: ...
+def log(x: bool | np.bool_) -> np.float16: ...
 @overload
 def log(x: _ToScalar_u4_u8) -> np.float64: ...
 @overload
-def log(x: _nt.ToUInt16_0d) -> np.float32: ...
+def log(x: np.uint16) -> np.float32: ...
 @overload
-def log(x: _nt.ToUInt8_0d) -> np.float16: ...
+def log(x: np.uint8) -> np.float16: ...
 @overload
-def log(x: _nt.CoUInt64_0d) -> np.floating: ...
+def log(x: _nt.co_uint64) -> np.floating: ...
 @overload
 def log(x: _ToScalar_i4_i8) -> _nt.inexact64: ...
 @overload
-def log(x: _nt.ToInt16_0d) -> _nt.inexact32: ...
+def log(x: np.int16) -> _nt.inexact32: ...
 @overload
-def log(x: _nt.ToInt8_0d) -> np.float16 | np.complex64: ...
+def log(x: np.int8) -> np.float16 | np.complex64: ...
 @overload
-def log(x: _nt.ToFloat64_0d) -> _nt.inexact64: ...
+def log(x: _nt.JustFloat | np.float64) -> _nt.inexact64: ...
 @overload
-def log(x: _nt.ToLongDouble_0d) -> np.longdouble | np.complex128: ...
+def log(x: np.longdouble) -> np.longdouble | np.complex128: ...
 @overload
-def log(x: _nt.ToFloat32_0d) -> _nt.inexact32: ...
+def log(x: np.float32) -> _nt.inexact32: ...
 @overload
-def log(x: _nt.ToFloat16_0d) -> np.float16 | np.complex128: ...
+def log(x: np.float16) -> np.float16 | np.complex128: ...
 @overload
-def log(x: _nt.ToComplex128_0d) -> np.complex128: ...
+def log(x: _nt.JustComplex | np.complex128) -> np.complex128: ...
 @overload
-def log(x: _nt.ToCLongDouble_0d) -> np.complex128 | np.clongdouble: ...
+def log(x: np.clongdouble) -> np.complex128 | np.clongdouble: ...
 @overload
-def log(x: _nt.ToComplex64_0d) -> np.complex64: ...
+def log(x: np.complex64) -> np.complex64: ...
 @overload
-def log(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def log(x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def log(x: _nt.CoComplex_0d) -> np.inexact: ...
+def log(x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def log(x: _nt.ToBool_1nd) -> _nt.Array[np.float16]: ...
 @overload
@@ -168,39 +166,39 @@ def log(x: _nt.CoComplex_1nd) -> _nt.Array[np.inexact]: ...
 
 # signature is equivalent to `sqrt`
 @overload
-def log10(x: _nt.ToBool_0d) -> np.float16: ...
+def log10(x: bool | np.bool_) -> np.float16: ...
 @overload
 def log10(x: _ToScalar_u4_u8) -> np.float64: ...
 @overload
-def log10(x: _nt.ToUInt16_0d) -> np.float32: ...
+def log10(x: np.uint16) -> np.float32: ...
 @overload
-def log10(x: _nt.ToUInt8_0d) -> np.float16: ...
+def log10(x: np.uint8) -> np.float16: ...
 @overload
-def log10(x: _nt.CoUInt64_0d) -> np.floating: ...
+def log10(x: _nt.co_uint64) -> np.floating: ...
 @overload
 def log10(x: _ToScalar_i4_i8) -> _nt.inexact64: ...
 @overload
-def log10(x: _nt.ToInt16_0d) -> _nt.inexact32: ...
+def log10(x: np.int16) -> _nt.inexact32: ...
 @overload
-def log10(x: _nt.ToInt8_0d) -> np.float16 | np.complex64: ...
+def log10(x: np.int8) -> np.float16 | np.complex64: ...
 @overload
-def log10(x: _nt.ToFloat64_0d) -> _nt.inexact64: ...
+def log10(x: _nt.JustFloat | np.float64) -> _nt.inexact64: ...
 @overload
-def log10(x: _nt.ToLongDouble_0d) -> np.longdouble | np.complex128: ...
+def log10(x: np.longdouble) -> np.longdouble | np.complex128: ...
 @overload
-def log10(x: _nt.ToFloat32_0d) -> _nt.inexact32: ...
+def log10(x: np.float32) -> _nt.inexact32: ...
 @overload
-def log10(x: _nt.ToFloat16_0d) -> np.float16 | np.complex128: ...
+def log10(x: np.float16) -> np.float16 | np.complex128: ...
 @overload
-def log10(x: _nt.ToComplex128_0d) -> np.complex128: ...
+def log10(x: _nt.JustComplex | np.complex128) -> np.complex128: ...
 @overload
-def log10(x: _nt.ToCLongDouble_0d) -> np.complex128 | np.clongdouble: ...
+def log10(x: np.clongdouble) -> np.complex128 | np.clongdouble: ...
 @overload
-def log10(x: _nt.ToComplex64_0d) -> np.complex64: ...
+def log10(x: np.complex64) -> np.complex64: ...
 @overload
-def log10(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def log10(x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def log10(x: _nt.CoComplex_0d) -> np.inexact: ...
+def log10(x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def log10(x: _nt.ToBool_1nd) -> _nt.Array[np.float16]: ...
 @overload
@@ -238,39 +236,39 @@ def log10(x: _nt.CoComplex_1nd) -> _nt.Array[np.inexact]: ...
 
 # signature is equivalent to `sqrt`
 @overload
-def log2(x: _nt.ToBool_0d) -> np.float16: ...
+def log2(x: bool | np.bool_) -> np.float16: ...
 @overload
 def log2(x: _ToScalar_u4_u8) -> np.float64: ...
 @overload
-def log2(x: _nt.ToUInt16_0d) -> np.float32: ...
+def log2(x: np.uint16) -> np.float32: ...
 @overload
-def log2(x: _nt.ToUInt8_0d) -> np.float16: ...
+def log2(x: np.uint8) -> np.float16: ...
 @overload
-def log2(x: _nt.CoUInt64_0d) -> np.floating: ...
+def log2(x: _nt.co_uint64) -> np.floating: ...
 @overload
 def log2(x: _ToScalar_i4_i8) -> _nt.inexact64: ...
 @overload
-def log2(x: _nt.ToInt16_0d) -> _nt.inexact32: ...
+def log2(x: np.int16) -> _nt.inexact32: ...
 @overload
-def log2(x: _nt.ToInt8_0d) -> np.float16 | np.complex64: ...
+def log2(x: np.int8) -> np.float16 | np.complex64: ...
 @overload
-def log2(x: _nt.ToFloat64_0d) -> _nt.inexact64: ...
+def log2(x: _nt.JustFloat | np.float64) -> _nt.inexact64: ...
 @overload
-def log2(x: _nt.ToLongDouble_0d) -> np.longdouble | np.complex128: ...
+def log2(x: np.longdouble) -> np.longdouble | np.complex128: ...
 @overload
-def log2(x: _nt.ToFloat32_0d) -> _nt.inexact32: ...
+def log2(x: np.float32) -> _nt.inexact32: ...
 @overload
-def log2(x: _nt.ToFloat16_0d) -> np.float16 | np.complex128: ...
+def log2(x: np.float16) -> np.float16 | np.complex128: ...
 @overload
-def log2(x: _nt.ToComplex128_0d) -> np.complex128: ...
+def log2(x: _nt.JustComplex | np.complex128) -> np.complex128: ...
 @overload
-def log2(x: _nt.ToCLongDouble_0d) -> np.complex128 | np.clongdouble: ...
+def log2(x: np.clongdouble) -> np.complex128 | np.clongdouble: ...
 @overload
-def log2(x: _nt.ToComplex64_0d) -> np.complex64: ...
+def log2(x: np.complex64) -> np.complex64: ...
 @overload
-def log2(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def log2(x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def log2(x: _nt.CoComplex_0d) -> np.inexact: ...
+def log2(x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def log2(x: _nt.ToBool_1nd) -> _nt.Array[np.float16]: ...
 @overload
@@ -310,31 +308,31 @@ def log2(x: _nt.CoComplex_1nd) -> _nt.Array[np.inexact]: ...
 
 #
 @overload
-def arccos(x: _nt.ToBool_0d) -> np.float16 | np.complex64: ...
+def arccos(x: bool | np.bool_) -> np.float16 | np.complex64: ...
 @overload
 def arccos(x: _ToScalar_iu4_iu8) -> _nt.inexact64: ...
 @overload
-def arccos(x: _ToScalar_iu2) -> _nt.inexact32: ...
+def arccos(x: _nt.integer16) -> _nt.inexact32: ...
 @overload
-def arccos(x: _ToScalar_iu1) -> np.float16 | np.complex64: ...
+def arccos(x: _nt.integer8) -> np.float16 | np.complex64: ...
 @overload
-def arccos(x: _nt.ToFloat64_0d) -> _nt.inexact64: ...
+def arccos(x: _nt.JustFloat | np.float64) -> _nt.inexact64: ...
 @overload
-def arccos(x: _nt.ToLongDouble_0d) -> np.longdouble | np.complex128: ...
+def arccos(x: np.longdouble) -> np.longdouble | np.complex128: ...
 @overload
-def arccos(x: _nt.ToFloat32_0d) -> _nt.inexact32: ...
+def arccos(x: np.float32) -> _nt.inexact32: ...
 @overload
-def arccos(x: _nt.ToFloat16_0d) -> np.float16 | np.complex128: ...
+def arccos(x: np.float16) -> np.float16 | np.complex128: ...
 @overload
-def arccos(x: _nt.ToComplex128_0d) -> np.complex128: ...
+def arccos(x: _nt.JustComplex | np.complex128) -> np.complex128: ...
 @overload
-def arccos(x: _nt.ToCLongDouble_0d) -> np.complex128 | np.clongdouble: ...
+def arccos(x: np.clongdouble) -> np.complex128 | np.clongdouble: ...
 @overload
-def arccos(x: _nt.ToComplex64_0d) -> np.complex64: ...
+def arccos(x: np.complex64) -> np.complex64: ...
 @overload
-def arccos(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def arccos(x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def arccos(x: _nt.CoComplex_0d) -> np.inexact: ...
+def arccos(x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def arccos(x: _nt.ToBool_1nd) -> _nt.Array[np.float16 | np.complex64]: ...
 @overload
@@ -364,31 +362,31 @@ def arccos(x: _nt.CoComplex_1nd) -> _nt.Array[np.inexact]: ...
 
 # signature is equivalent to `arccos`
 @overload
-def arcsin(x: _nt.ToBool_0d) -> np.float16 | np.complex64: ...
+def arcsin(x: bool | np.bool_) -> np.float16 | np.complex64: ...
 @overload
 def arcsin(x: _ToScalar_iu4_iu8) -> _nt.inexact64: ...
 @overload
-def arcsin(x: _ToScalar_iu2) -> _nt.inexact32: ...
+def arcsin(x: _nt.integer16) -> _nt.inexact32: ...
 @overload
-def arcsin(x: _ToScalar_iu1) -> np.float16 | np.complex64: ...
+def arcsin(x: _nt.integer8) -> np.float16 | np.complex64: ...
 @overload
-def arcsin(x: _nt.ToFloat64_0d) -> _nt.inexact64: ...
+def arcsin(x: _nt.JustFloat | np.float64) -> _nt.inexact64: ...
 @overload
-def arcsin(x: _nt.ToLongDouble_0d) -> np.longdouble | np.complex128: ...
+def arcsin(x: np.longdouble) -> np.longdouble | np.complex128: ...
 @overload
-def arcsin(x: _nt.ToFloat32_0d) -> _nt.inexact32: ...
+def arcsin(x: np.float32) -> _nt.inexact32: ...
 @overload
-def arcsin(x: _nt.ToFloat16_0d) -> np.float16 | np.complex128: ...
+def arcsin(x: np.float16) -> np.float16 | np.complex128: ...
 @overload
-def arcsin(x: _nt.ToComplex128_0d) -> np.complex128: ...
+def arcsin(x: _nt.JustComplex | np.complex128) -> np.complex128: ...
 @overload
-def arcsin(x: _nt.ToCLongDouble_0d) -> np.complex128 | np.clongdouble: ...
+def arcsin(x: np.clongdouble) -> np.complex128 | np.clongdouble: ...
 @overload
-def arcsin(x: _nt.ToComplex64_0d) -> np.complex64: ...
+def arcsin(x: np.complex64) -> np.complex64: ...
 @overload
-def arcsin(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def arcsin(x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def arcsin(x: _nt.CoComplex_0d) -> np.inexact: ...
+def arcsin(x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def arcsin(x: _nt.ToBool_1nd) -> _nt.Array[np.float16 | np.complex64]: ...
 @overload
@@ -418,31 +416,31 @@ def arcsin(x: _nt.CoComplex_1nd) -> _nt.Array[np.inexact]: ...
 
 # signature is equivalent to `arccos`
 @overload
-def arctanh(x: _nt.ToBool_0d) -> np.float16 | np.complex64: ...
+def arctanh(x: bool | np.bool_) -> np.float16 | np.complex64: ...
 @overload
 def arctanh(x: _ToScalar_iu4_iu8) -> _nt.inexact64: ...
 @overload
-def arctanh(x: _ToScalar_iu2) -> _nt.inexact32: ...
+def arctanh(x: _nt.integer16) -> _nt.inexact32: ...
 @overload
-def arctanh(x: _ToScalar_iu1) -> np.float16 | np.complex64: ...
+def arctanh(x: _nt.integer8) -> np.float16 | np.complex64: ...
 @overload
-def arctanh(x: _nt.ToFloat64_0d) -> _nt.inexact64: ...
+def arctanh(x: _nt.JustFloat | np.float64) -> _nt.inexact64: ...
 @overload
-def arctanh(x: _nt.ToLongDouble_0d) -> np.longdouble | np.complex128: ...
+def arctanh(x: np.longdouble) -> np.longdouble | np.complex128: ...
 @overload
-def arctanh(x: _nt.ToFloat32_0d) -> _nt.inexact32: ...
+def arctanh(x: np.float32) -> _nt.inexact32: ...
 @overload
-def arctanh(x: _nt.ToFloat16_0d) -> np.float16 | np.complex128: ...
+def arctanh(x: np.float16) -> np.float16 | np.complex128: ...
 @overload
-def arctanh(x: _nt.ToComplex128_0d) -> np.complex128: ...
+def arctanh(x: _nt.JustComplex | np.complex128) -> np.complex128: ...
 @overload
-def arctanh(x: _nt.ToCLongDouble_0d) -> np.complex128 | np.clongdouble: ...
+def arctanh(x: np.clongdouble) -> np.complex128 | np.clongdouble: ...
 @overload
-def arctanh(x: _nt.ToComplex64_0d) -> np.complex64: ...
+def arctanh(x: np.complex64) -> np.complex64: ...
 @overload
-def arctanh(x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def arctanh(x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def arctanh(x: _nt.CoComplex_0d) -> np.inexact: ...
+def arctanh(x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def arctanh(x: _nt.ToBool_1nd) -> _nt.Array[np.float16 | np.complex64]: ...
 @overload
@@ -472,15 +470,15 @@ def arctanh(x: _nt.CoComplex_1nd) -> _nt.Array[np.inexact]: ...
 
 #
 @overload
-def logn(n: _nt.CoUInt8_0d, x: _nt.CoUInt8_0d) -> np.float16: ...
+def logn(n: _nt.co_uint8, x: _nt.co_uint8) -> np.float16: ...
 @overload
-def logn(n: _nt.CoUInt64_0d, x: _nt.CoUInt64_0d) -> np.floating: ...
+def logn(n: np.uint64, x: _nt.co_uint64) -> np.floating: ...
 @overload
-def logn(n: _nt.ToComplex_0d, x: _nt.CoComplex_0d) -> np.complexfloating: ...
+def logn(n: _nt.JustComplex | np.complexfloating, x: complex | _nt.co_complex) -> np.complexfloating: ...
 @overload
-def logn(n: _nt.CoComplex_0d, x: _nt.ToComplex_0d) -> np.complexfloating: ...
+def logn(n: complex | _nt.co_complex, x: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
-def logn(n: _nt.CoComplex_0d, x: _nt.CoComplex_0d) -> np.inexact: ...
+def logn(n: complex | _nt.co_complex, x: complex | _nt.co_complex) -> np.inexact: ...
 @overload
 def logn(n: _nt.CoUInt8_nd, x: _nt.CoUInt8_1nd) -> _nt.Array[np.float16]: ...
 @overload
@@ -504,27 +502,27 @@ def logn(n: _nt.CoComplex_1nd, x: _nt.CoComplex_nd) -> _nt.Array[np.inexact]: ..
 
 #
 @overload
-def power(x: _nt.CoInt8_0d, p: _nt.CoInt8_0d) -> np.int8: ...
+def power(x: _nt.co_int8, p: _nt.co_int8) -> np.int8: ...
 @overload
-def power(x: _nt.ToUInteger_0d, p: _nt.CoUInt64_0d) -> np.unsignedinteger: ...
+def power(x: np.unsignedinteger, p: np.uint64) -> np.unsignedinteger: ...
 @overload
-def power(x: _nt.CoUInt64_0d, p: _nt.ToUInteger_0d) -> np.unsignedinteger: ...
+def power(x: np.uint64, p: np.unsignedinteger) -> np.unsignedinteger: ...
 @overload
-def power(x: _nt.CoUInt64_0d, p: _nt.ToSInteger_0d) -> np.signedinteger | np.float64: ...
+def power(x: np.uint64, p: _nt.JustInt | np.signedinteger) -> np.signedinteger | np.float64: ...
 @overload
-def power(x: _nt.CoUInt64_0d, p: _nt.ToFloating_0d) -> np.floating: ...
+def power(x: np.uint64, p: _nt.JustFloat | np.floating) -> np.floating: ...
 @overload
-def power(x: _nt.ToSInteger_0d, p: _nt.CoUInt64_0d) -> np.signedinteger | np.complexfloating: ...
+def power(x: _nt.JustInt | np.signedinteger, p: np.uint64) -> np.signedinteger | np.complexfloating: ...
 @overload
-def power(x: _nt.ToSInteger_0d, p: _nt.CoInteger_0d) -> np.signedinteger | np.inexact: ...
+def power(x: _nt.JustInt | np.signedinteger, p: int | _nt.co_integer) -> np.signedinteger | np.inexact: ...
 @overload
-def power(x: _nt.ToFloating_0d, p: _nt.CoFloating_0d) -> np.inexact: ...
+def power(x: _nt.JustFloat | np.floating, p: float | _nt.co_float) -> np.inexact: ...
 @overload
-def power(x: _nt.CoFloating_0d, p: _nt.ToFloating_0d) -> np.inexact: ...
+def power(x: float | _nt.co_float, p: _nt.JustFloat | np.floating) -> np.inexact: ...
 @overload
-def power(x: _nt.ToComplex_0d, p: _nt.CoComplex_0d) -> np.complexfloating: ...
+def power(x: _nt.JustComplex | np.complexfloating, p: complex | _nt.co_complex) -> np.complexfloating: ...
 @overload
-def power(x: _nt.CoComplex_0d, p: _nt.ToComplex_0d) -> np.complexfloating: ...
+def power(x: complex | _nt.co_complex, p: _nt.JustComplex | np.complexfloating) -> np.complexfloating: ...
 @overload
 def power(x: _nt.CoInt8_nd, p: _nt.CoInt8_1nd) -> _nt.Array[np.int8]: ...
 @overload
diff --git a/src/numpy-stubs/lib/_type_check_impl.pyi b/src/numpy-stubs/lib/_type_check_impl.pyi
index 773d157f..fb957ceb 100644
--- a/src/numpy-stubs/lib/_type_check_impl.pyi
+++ b/src/numpy-stubs/lib/_type_check_impl.pyi
@@ -92,15 +92,15 @@ def imag(val: _nt.ToGeneric_nd) -> _nt.Array: ...
 
 #
 @overload
-def iscomplex(x: _nt.ToGeneric_0d) -> np.bool: ...
-@overload
 def iscomplex(x: _nt.ToGeneric_1nd) -> _nt.Array[np.bool]: ...
+@overload
+def iscomplex(x: np.generic | _nt._PyScalar) -> np.bool: ...
 
 #
 @overload
-def isreal(x: _nt.ToGeneric_0d) -> np.bool: ...
-@overload
 def isreal(x: _nt.ToGeneric_1nd) -> _nt.Array[np.bool]: ...
+@overload
+def isreal(x: np.generic | _nt._PyScalar) -> np.bool: ...
 
 #
 def iscomplexobj(x: _HasDType[Any] | _nt.ToGeneric_nd) -> bool: ...
@@ -131,13 +131,13 @@ def nan_to_num(
 # If one passes a complex array to `real_if_close`, then one is reasonably
 # expected to verify the output dtype (so we can return an unsafe union here)
 
-@overload
-def real_if_close(a: _nt.ToCLongDouble_nd, tol: float = 100) -> _nt.Array[_nt.inexact64l]: ...
 @overload
 def real_if_close(a: _nt.ToComplex128_nd, tol: float = 100) -> _nt.Array[_nt.inexact64]: ...
 @overload
 def real_if_close(a: _nt.ToComplex64_nd, tol: float = 100) -> _nt.Array[_nt.inexact32]: ...
 @overload
+def real_if_close(a: _nt.ToCLongDouble_nd, tol: float = 100) -> _nt.Array[_nt.inexact64l]: ...
+@overload
 def real_if_close(a: _nt._ToArray_nd[_RealT], tol: float = 100) -> _nt.Array[_RealT]: ...
 @overload
 def real_if_close(a: _nt.ToGeneric_nd, tol: float = 100) -> _nt.Array: ...
diff --git a/src/numpy-stubs/lib/_ufunclike_impl.pyi b/src/numpy-stubs/lib/_ufunclike_impl.pyi
index 677c9ea5..5a3018f8 100644
--- a/src/numpy-stubs/lib/_ufunclike_impl.pyi
+++ b/src/numpy-stubs/lib/_ufunclike_impl.pyi
@@ -16,9 +16,7 @@ _RealT = TypeVar("_RealT", bound=np.integer | np.floating | np.object_)
 
 #
 @overload
-def fix(x: _nt.CoFloating_nd, out: _ArrayT) -> _ArrayT: ...
-@overload
-def fix(x: _ArrayT, out: None) -> _ArrayT: ...
+def fix(x: _nt.Array[_RealT, _ShapeT], out: None = None) -> _nt.Array[_RealT, _ShapeT]: ...
 @overload
 def fix(x: _nt.ToBool_0d, out: None = None) -> np.bool: ...
 @overload
@@ -28,26 +26,28 @@ def fix(x: _nt.ToFloat64_0d, out: None = None) -> np.float64: ...
 @overload
 def fix(x: _nt.CanArray0D[_RealT], out: None = None) -> _RealT: ...
 @overload
-def fix(x: _nt._ToArray_1ds[_RealT], out: None = None) -> _nt.Array1D[_RealT]: ...
-@overload
-def fix(x: _nt._ToArray_2ds[_RealT], out: None = None) -> _nt.Array2D[_RealT]: ...
-@overload
-def fix(x: _nt._ToArray_3ds[_RealT], out: None = None) -> _nt.Array3D[_RealT]: ...
-@overload
 def fix(x: _nt.ToBool_1nd, out: None = None) -> _nt.Array[np.bool]: ...
 @overload
 def fix(x: _nt.ToInt_1nd, out: None = None) -> _nt.Array[np.intp]: ...
 @overload
 def fix(x: _nt.ToFloat64_1nd, out: None = None) -> _nt.Array[np.float64]: ...
 @overload
+def fix(x: _nt._ToArray_1ds[_RealT], out: None = None) -> _nt.Array1D[_RealT]: ...
+@overload
+def fix(x: _nt._ToArray_2ds[_RealT], out: None = None) -> _nt.Array2D[_RealT]: ...
+@overload
+def fix(x: _nt._ToArray_3ds[_RealT], out: None = None) -> _nt.Array3D[_RealT]: ...
+@overload
 def fix(x: _nt._ToArray_1nd[_RealT], out: None = None) -> _nt.Array[_RealT]: ...
+@overload
+def fix(x: _nt.CoFloating_nd, out: _ArrayT) -> _ArrayT: ...
 
 #
 @overload
-def isposinf(x: _nt.CoFloating_0d, out: None = None) -> np.bool: ...
-@overload
 def isposinf(x: _nt.CanLenArray[_nt.co_float, _ShapeT], out: None = None) -> _nt.Array[np.bool, _ShapeT]: ...
 @overload
+def isposinf(x: _nt.CoFloating_0d, out: None = None) -> np.bool: ...
+@overload
 def isposinf(x: _nt.CoFloating_1ds, out: None = None) -> _nt.Array1D[np.bool]: ...
 @overload
 def isposinf(x: _nt.CoFloating_2ds, out: None = None) -> _nt.Array2D[np.bool]: ...
@@ -60,10 +60,10 @@ def isposinf(x: _nt.CoFloating_nd, out: _ArrayT) -> _ArrayT: ...
 
 #
 @overload
-def isneginf(x: _nt.CoFloating_0d, out: None = None) -> np.bool: ...
-@overload
 def isneginf(x: _nt.CanLenArray[_nt.co_float, _ShapeT], out: None = None) -> _nt.Array[np.bool, _ShapeT]: ...
 @overload
+def isneginf(x: _nt.CoFloating_0d, out: None = None) -> np.bool: ...
+@overload
 def isneginf(x: _nt.CoFloating_1ds, out: None = None) -> _nt.Array1D[np.bool]: ...
 @overload
 def isneginf(x: _nt.CoFloating_2ds, out: None = None) -> _nt.Array2D[np.bool]: ...
diff --git a/src/numpy-stubs/linalg/_linalg.pyi b/src/numpy-stubs/linalg/_linalg.pyi
index 52347e5a..f7a876a1 100644
--- a/src/numpy-stubs/linalg/_linalg.pyi
+++ b/src/numpy-stubs/linalg/_linalg.pyi
@@ -122,15 +122,10 @@ _Toinexact64l_1nd: TypeAlias = _nt._ToArray_1nd[_nt.inexact64l]
 _Toinexact64l_2ds: TypeAlias = _nt._ToArray_2ds[_nt.inexact64l]
 _Toinexact64l_3nd: TypeAlias = _nt._ToArray_3nd[_nt.inexact64l]
 
-_ToUnsafe64_1nd: TypeAlias = _nt._ToArray2_1nd[
-    _nt.inexact64 | _nt.co_integer | np.character[Any], complex | _nt._PyCharacter
-]
-_ToUnsafe64_2ds: TypeAlias = _nt._ToArray2_2ds[
-    _nt.inexact64 | _nt.co_integer | np.character[Any], complex | _nt._PyCharacter
-]
-_ToUnsafe64_3nd: TypeAlias = _nt._ToArray2_3nd[
-    _nt.inexact64 | _nt.co_integer | np.character[Any], complex | _nt._PyCharacter
-]
+_Unsafe64: TypeAlias = _nt.inexact64 | _nt.co_integer | np.character[Any]
+_ToUnsafe64_1nd: TypeAlias = _nt._ToArray2_1nd[_Unsafe64, complex | _nt._PyCharacter]
+_ToUnsafe64_2ds: TypeAlias = _nt._ToArray2_2ds[_Unsafe64, complex | _nt._PyCharacter]
+_ToUnsafe64_3nd: TypeAlias = _nt._ToArray2_3nd[_Unsafe64, complex | _nt._PyCharacter]
 
 _Array2ND: TypeAlias = _nt.Array[_ScalarT, _nt.Shape2N]
 
@@ -324,6 +319,10 @@ _PosInt: TypeAlias = L[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
 _NegInt: TypeAlias = L[-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16]
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def matrix_power(a: _nt.CastsArray[np.float64, _nt.NeitherShape], n: CanIndex) -> _Array2ND[np.float64]: ...
+@overload  # workaround for microsoft/pyright#10232
+def matrix_power(a: _nt.CastsWithArray[np.float64, _NumberT, _nt.NeitherShape], n: CanIndex) -> _Array2ND[_NumberT]: ...
 @overload
 def matrix_power(a: _nt.CanLenArray[_NumberT, _Shape2NDT], n: _PosInt) -> _nt.Array[_NumberT, _Shape2NDT]: ...
 @overload
@@ -392,6 +391,8 @@ def outer(x1: _nt.CoInteger_1d, x2: _nt.ToInteger_1d, /) -> _nt.Array2D[np.integ
 def outer(x1: _nt.ToNumber_1d, x2: _nt.ToNumber_1d, /) -> _nt.Array2D[Any]: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def multi_dot(arrays: Iterable[_nt._ToArray_nnd[_nt.co_number]], *, out: None = None) -> Any: ...
 @overload
 def multi_dot(arrays: Iterable[_nt._ToArray_1ds[_AnyNumberT]], *, out: None = None) -> _AnyNumberT: ...
 @overload
@@ -454,6 +455,8 @@ def cross(x1: _nt.CoComplex_1nd, x2: _nt.ToComplex_1nd, /, *, axis: int = -1) ->
 def cross(x1: _nt.CoComplex_1nd, x2: _nt.CoComplex_1nd, /, *, axis: int = -1) -> _nt.Array[Any]: ...
 
 # pyright false positive in case of typevar constraints
+@overload  # workaround for microsoft/pyright#10232
+def matmul(x1: _nt._ToArray_nnd[_nt.co_number], x2: _nt._ToArray_nnd[_nt.co_number], /) -> Any: ...
 @overload
 def matmul(x1: _nt._ToArray_1ds[_AnyNumberT], x2: _nt._ToArray_1ds[_AnyNumberT], /) -> _AnyNumberT: ...  # pyright: ignore[reportOverlappingOverload]
 @overload
@@ -640,6 +643,14 @@ def svdvals(x: _Toinexact32_1nd, /) -> _nt.Array[np.float32]: ...
 def svdvals(x: _nt.CoComplex128_1nd, /) -> _nt.Array[np.floating]: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def matrix_rank(
+    A: _nt._ToArray_nnd[_nt.co_complex128],
+    tol: _nt.ToFloating_nd | None = None,
+    hermitian: bool = False,
+    *,
+    rtol: _nt.ToFloating_nd | None = None,
+) -> Any: ...
 @overload  # <2d +complex128
 def matrix_rank(
     A: _nt.CoComplex128_0d | _nt.CoComplex128_1ds,
@@ -674,6 +685,8 @@ def matrix_rank(
 ) -> Any: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def cond(x: _nt._ToArray_nnd[_nt.co_complex128], p: _Ord | None = None) -> Any: ...
 @overload  # 2d float64 | complex128
 def cond(x: _Toinexact64_2ds, p: _Ord | None = None) -> np.float64: ...
 @overload  # 2d float32 | complex64
@@ -690,6 +703,8 @@ def cond(x: _nt.CoComplex128_3nd, p: _Ord | None = None) -> _nt.Array[np.floatin
 def cond(x: _nt.CoComplex128_1nd, p: _Ord | None = None) -> Any: ...
 
 # keep in sync with `det`
+@overload  # # workaround for microsoft/pyright#10232
+def slogdet(a: _nt._ToArray_nnd[_nt.co_complex128]) -> SlogdetResult: ...
 @overload  # 2d float64
 def slogdet(a: _ToFloat64_2ds) -> SlogdetResult[np.float64, np.float64]: ...
 @overload  # 2d float32 + complex64
@@ -703,9 +718,11 @@ def slogdet(a: _nt._ToArray_3nd[_Inexact32T]) -> SlogdetResult[_nt.Array[np.floa
 @overload  # >2d complex128
 def slogdet(a: _nt.ToComplex128_3nd) -> SlogdetResult[_nt.Array[np.float64], _nt.Array[np.complex128]]: ...
 @overload  # +complex128
-def slogdet(a: _nt.CoComplex128_1nd) -> SlogdetResult[Any, Any]: ...
+def slogdet(a: _nt.CoComplex128_1nd) -> SlogdetResult: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def det(a: _nt._ToArray_nnd[_nt.co_complex128]) -> Any: ...
 @overload  # 2d float64
 def det(a: _ToFloat64_2ds) -> np.float64: ...
 @overload  # 2d float32 + complex64
@@ -763,9 +780,9 @@ def norm(
     x: _ToUnsafe64_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, *, keepdims: _True
 ) -> _Array2ND[np.float64]: ...
 @overload  # float64 | complex128 | character, axis=<given> (positional)
-def norm(x: _ToUnsafe64_1nd, ord: _Ord | None, axis: _Ax2, keepdims: bool = False) -> _nt.Array[np.float64]: ...  # type: ignore[overload-overlap]
+def norm(x: _ToUnsafe64_1nd, ord: _Ord | None, axis: _Ax2, keepdims: bool = False) -> _nt.Array[np.float64]: ...
 @overload  # float64 | complex128 | character, axis=<given> (keyword)
-def norm(  # type: ignore[overload-overlap]
+def norm(
     x: _ToUnsafe64_1nd, ord: _Ord | None = None, *, axis: _Ax2, keepdims: bool = False
 ) -> _nt.Array[np.float64]: ...
 @overload  # float16, axis=None, keepdims=False
@@ -820,34 +837,38 @@ def norm(
 def norm(x: _nt.CoComplex_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, keepdims: bool = False) -> Any: ...
 
 #
-@overload  # 2d float64 | complex128 | character
-def matrix_norm(x: _ToUnsafe64_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.float64: ...  # type: ignore[overload-overlap]
-@overload  # nd float64 | complex128 | character, keepdims=True
-def matrix_norm(x: _ToUnsafe64_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.float64]: ...
-@overload  # >2d float64 | complex128 | character
-def matrix_norm(x: _ToUnsafe64_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.float64]: ...
+@overload  # workaround for microsoft/pyright#10232
+def matrix_norm(
+    x: _nt._ToArray_nnd[_nt.co_number | np.character[Any]], /, *, keepdims: bool = False, ord: _Ord = "fro"
+) -> Any: ...
 @overload  # 2d float16
 def matrix_norm(x: _nt.ToFloat16_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.float16: ...  # type: ignore[overload-overlap]
-@overload  # nd float16, keepdims=True
-def matrix_norm(x: _nt.ToFloat16_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.float16]: ...
-@overload  # >2d float16
-def matrix_norm(x: _nt.ToFloat16_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.float16]: ...
 @overload  # 2d float32 | complex64, keepdims=True
 def matrix_norm(x: _Toinexact32_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.float32: ...  # type: ignore[overload-overlap]
-@overload  # nd float32 | complex64, keepdims=True
-def matrix_norm(x: _Toinexact32_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.float32]: ...
-@overload  # >2d float32 | complex64
-def matrix_norm(x: _Toinexact32_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.float32]: ...
+@overload  # 2d float64 | complex128 | character
+def matrix_norm(x: _ToUnsafe64_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.float64: ...  # type: ignore[overload-overlap]
 @overload  # 2d longdouble | clongdouble
 def matrix_norm(x: _Toinexact64l_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.longdouble: ...  # type: ignore[overload-overlap]
-@overload  # nd longdouble | clongdouble, keepdims=True
-def matrix_norm(x: _Toinexact64l_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.longdouble]: ...
-@overload  # >2d longdouble | clongdouble
-def matrix_norm(x: _Toinexact64l_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.longdouble]: ...
 @overload  # 2d +number
 def matrix_norm(x: _nt.CoComplex_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.floating: ...  # type: ignore[overload-overlap]
+@overload  # nd float16, keepdims=True
+def matrix_norm(x: _nt.ToFloat16_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.float16]: ...
+@overload  # nd float32 | complex64, keepdims=True
+def matrix_norm(x: _Toinexact32_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.float32]: ...
+@overload  # nd float64 | complex128 | character, keepdims=True
+def matrix_norm(x: _ToUnsafe64_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.float64]: ...
+@overload  # nd longdouble | clongdouble, keepdims=True
+def matrix_norm(x: _Toinexact64l_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.longdouble]: ...
 @overload  # nd +number, keepdims=True
 def matrix_norm(x: _nt.CoComplex_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array2ND[np.floating]: ...
+@overload  # >2d float16
+def matrix_norm(x: _nt.ToFloat16_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.float16]: ...
+@overload  # >2d float32 | complex64
+def matrix_norm(x: _Toinexact32_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.float32]: ...
+@overload  # >2d float64 | complex128 | character
+def matrix_norm(x: _ToUnsafe64_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.float64]: ...
+@overload  # >2d longdouble | clongdouble
+def matrix_norm(x: _Toinexact64l_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.longdouble]: ...
 @overload  # >2d +number
 def matrix_norm(x: _nt.CoComplex_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> _nt.Array[np.floating]: ...
 @overload  # nd +number
diff --git a/src/numpy-stubs/polynomial/_polybase.pyi b/src/numpy-stubs/polynomial/_polybase.pyi
index 50d1f6b9..2fec926f 100644
--- a/src/numpy-stubs/polynomial/_polybase.pyi
+++ b/src/numpy-stubs/polynomial/_polybase.pyi
@@ -60,14 +60,16 @@ class ABCPolyBase(abc.ABC):
     #
     @overload
     def __call__(self, /, arg: _PolyT) -> _PolyT: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def __call__(self, /, arg: _nt._ToArray_nnd[_nt.co_complex]) -> _nt.Array[_nt.inexact64]: ...
     @overload
     def __call__(self, /, arg: _nt.CoComplex_0d) -> _nt.inexact64: ...
     @overload
     def __call__(self, /, arg: _nt.CoComplex_1nd) -> _nt.Array[_nt.inexact64]: ...
     @overload
-    def __call__(self, /, arg: _nt.ToObject_0d) -> Any: ...
-    @overload
     def __call__(self, /, arg: _nt.ToObject_1nd) -> _nt.Array[np.object_]: ...
+    @overload
+    def __call__(self, /, arg: _nt.ToObject_nd) -> Any: ...
 
     #
     @override
diff --git a/src/numpy-stubs/polynomial/polynomial.pyi b/src/numpy-stubs/polynomial/polynomial.pyi
index 42ded562..f58ba30e 100644
--- a/src/numpy-stubs/polynomial/polynomial.pyi
+++ b/src/numpy-stubs/polynomial/polynomial.pyi
@@ -52,14 +52,22 @@ __all__ = [
 ###
 
 _ScalarT = TypeVar("_ScalarT", bound=np.generic)
+_InexactT = TypeVar("_InexactT", bound=np.inexact)
 
 _Indices: TypeAlias = Sequence[_Index]
 _ArrayAndFitResult: TypeAlias = tuple[_nt.Array[_ScalarT], Sequence[np.inexact | np.int32]]
 
-_ToNumeric_0d: TypeAlias = _nt.ToComplex_0d | _nt.ToObject_0d | _SupportsCoefOps
+_ToNumeric_0d: TypeAlias = _ToComplex | _nt.ToObject_0d | _SupportsCoefOps
 _ToNumeric_1d: TypeAlias = _nt._ToArray2_1d[np.number | np.bool | np.object_, complex | _SupportsCoefOps]
 _ToNumeric_nd: TypeAlias = _nt._ToArray2_nd[np.number | np.bool | np.object_, complex | _SupportsCoefOps]
 
+_ToF64: TypeAlias = np.float64 | _nt.JustFloat
+_ToComplex: TypeAlias = np.complexfloating | _nt.JustComplex
+_CoInt: TypeAlias = _nt.co_integer | int
+_CoF64: TypeAlias = _nt.co_float64 | float
+_CoFloat: TypeAlias = _nt.co_float | float
+_CoComplex: TypeAlias = _nt.co_complex | complex
+
 _I64_1d: TypeAlias = _nt.Array1D[np.int64]
 _F64_1d: TypeAlias = _nt.Array1D[np.float64]
 _C128_1d: TypeAlias = _nt.Array1D[np.complex128]
@@ -114,25 +122,25 @@ def polyline(off: _nt.ToInt_0d, scl: _nt.CoInt64_0d) -> _I64_1d: ...
 @overload
 def polyline(off: _nt.CoInt64_0d, scl: _nt.ToInt_0d) -> _I64_1d: ...
 @overload
-def polyline(off: _nt.CoInteger_0d, scl: _nt.CoInteger_0d) -> _nt.Array1D[np.integer]: ...
+def polyline(off: _CoInt, scl: _CoInt) -> _nt.Array1D[np.integer]: ...
 @overload
-def polyline(off: _nt.ToFloat64_0d, scl: _nt.CoFloat64_0d) -> _F64_1d: ...
+def polyline(off: _ToF64, scl: _CoF64) -> _F64_1d: ...
 @overload
-def polyline(off: _nt.CoFloat64_0d, scl: _nt.ToFloat64_0d) -> _F64_1d: ...
+def polyline(off: _CoF64, scl: _ToF64) -> _F64_1d: ...
 @overload
-def polyline(off: _nt.ToFloating_0d, scl: _nt.CoFloating_0d) -> _Float_1d: ...
+def polyline(off: _nt.ToFloating_0d, scl: _CoFloat) -> _Float_1d: ...
 @overload
-def polyline(off: _nt.CoFloating_0d, scl: _nt.ToFloating_0d) -> _Float_1d: ...
+def polyline(off: _CoFloat, scl: _nt.ToFloating_0d) -> _Float_1d: ...
 @overload
 def polyline(off: _nt.ToComplex128_0d, scl: _nt.CoComplex128_0d) -> _C128_1d: ...
 @overload
 def polyline(off: _nt.CoComplex128_0d, scl: _nt.ToComplex128_0d) -> _C128_1d: ...
 @overload
-def polyline(off: _nt.ToComplex_0d, scl: _nt.CoComplex_0d) -> _Complex_1d: ...
+def polyline(off: _ToComplex, scl: _CoComplex) -> _Complex_1d: ...
 @overload
-def polyline(off: _nt.CoComplex_0d, scl: _nt.ToComplex_0d) -> _Complex_1d: ...
+def polyline(off: _CoComplex, scl: _ToComplex) -> _Complex_1d: ...
 @overload
-def polyline(off: _nt.CoComplex_0d, scl: _nt.CoComplex_0d) -> _nt.Array1D[np.number]: ...
+def polyline(off: _CoComplex, scl: _CoComplex) -> _nt.Array1D[np.number]: ...
 @overload
 def polyline(off: _nt.ToObject_0d, scl: _nt.ToObject_0d) -> _Object_1d: ...
 
@@ -262,33 +270,33 @@ def polydiv(c1: _ToNumeric_1d, c2: _nt.ToObject_1d) -> _Object_1d: ...
 
 #
 @overload
-def polypow(c: _nt.CoInteger_nd, pow: _nt.CoInteger_0d, maxpower: _nt.CoInteger_0d | None = None) -> _F64_1d: ...
+def polypow(c: _nt.CoInteger_nd, pow: _CoInt, maxpower: _CoInt | None = None) -> _F64_1d: ...
 @overload
-def polypow(c: _nt.ToFloat64_1d, pow: _nt.CoInteger_0d, maxpower: _nt.CoInteger_0d | None = None) -> _F64_1d: ...
+def polypow(c: _nt.ToFloat64_1d, pow: _CoInt, maxpower: _CoInt | None = None) -> _F64_1d: ...
 @overload
-def polypow(c: _nt.CoFloating_1d, pow: _nt.CoInteger_0d, maxpower: _nt.CoInteger_0d | None = None) -> _Float_1d: ...
+def polypow(c: _nt.CoFloating_1d, pow: _CoInt, maxpower: _CoInt | None = None) -> _Float_1d: ...
 @overload
-def polypow(c: _nt.ToComplex128_1d, pow: _nt.CoInteger_0d, maxpower: _nt.CoInteger_0d | None = None) -> _C128_1d: ...
+def polypow(c: _nt.ToComplex128_1d, pow: _CoInt, maxpower: _CoInt | None = None) -> _C128_1d: ...
 @overload
-def polypow(c: _nt.ToComplex_1d, pow: _nt.CoInteger_0d, maxpower: _nt.CoInteger_0d | None = None) -> _Complex_1d: ...
+def polypow(c: _nt.ToComplex_1d, pow: _CoInt, maxpower: _CoInt | None = None) -> _Complex_1d: ...
 @overload
-def polypow(c: _nt.CoComplex_1d, pow: _nt.CoInteger_0d, maxpower: _nt.CoInteger_0d | None = None) -> _Inexact_1d: ...
+def polypow(c: _nt.CoComplex_1d, pow: _CoInt, maxpower: _CoInt | None = None) -> _Inexact_1d: ...
 @overload
-def polypow(c: _nt.ToObject_1d, pow: _nt.CoInteger_0d, maxpower: _nt.CoInteger_0d | None = None) -> _Object_1d: ...
+def polypow(c: _nt.ToObject_1d, pow: _CoInt, maxpower: _CoInt | None = None) -> _Object_1d: ...
 
 #
 @overload
-def polyder(c: _nt.CoInteger_nd, m: _Index = 1, scl: _nt.CoFloating_0d = 1, axis: _Index = 0) -> _F64_nd: ...
+def polyder(c: _nt.CoInteger_nd, m: _Index = 1, scl: _CoFloat = 1, axis: _Index = 0) -> _F64_nd: ...
 @overload
-def polyder(c: _nt.ToFloat64_nd, m: _Index = 1, scl: _nt.CoFloating_0d = 1, axis: _Index = 0) -> _F64_nd: ...
+def polyder(c: _nt.ToFloat64_nd, m: _Index = 1, scl: _CoFloat = 1, axis: _Index = 0) -> _F64_nd: ...
 @overload
-def polyder(c: _nt.ToFloating_nd, m: _Index = 1, scl: _nt.CoFloating_0d = 1, axis: _Index = 0) -> _Float_nd: ...
+def polyder(c: _nt.ToFloating_nd, m: _Index = 1, scl: _CoFloat = 1, axis: _Index = 0) -> _Float_nd: ...
 @overload
-def polyder(c: _nt.ToComplex128_nd, m: _Index = 1, scl: _nt.CoComplex_0d = 1, axis: _Index = 0) -> _C128_nd: ...
+def polyder(c: _nt.ToComplex128_nd, m: _Index = 1, scl: _CoComplex = 1, axis: _Index = 0) -> _C128_nd: ...
 @overload
-def polyder(c: _nt.ToComplex_nd, m: _Index = 1, scl: _nt.CoComplex_0d = 1, axis: _Index = 0) -> _Complex_nd: ...
+def polyder(c: _nt.ToComplex_nd, m: _Index = 1, scl: _CoComplex = 1, axis: _Index = 0) -> _Complex_nd: ...
 @overload
-def polyder(c: _nt.CoComplex_nd, m: _Index = 1, scl: _nt.CoComplex_0d = 1, axis: _Index = 0) -> _Inexact_nd: ...
+def polyder(c: _nt.CoComplex_nd, m: _Index = 1, scl: _CoComplex = 1, axis: _Index = 0) -> _Inexact_nd: ...
 @overload
 def polyder(c: _nt.ToObject_nd, m: _Index = 1, scl: _ToNumeric_0d = 1, axis: _Index = 0) -> _Object_nd: ...
 
@@ -297,45 +305,45 @@ def polyder(c: _nt.ToObject_nd, m: _Index = 1, scl: _ToNumeric_0d = 1, axis: _In
 def polyint(
     c: _nt.CoInteger_nd,
     m: _Index = 1,
-    k: _nt.CoFloat64_0d | _nt.CoFloat64_1d = [],
-    lbnd: _nt.CoFloating_0d = 0,
-    scl: _nt.CoFloating_0d = 1,
+    k: _CoF64 | _nt.CoFloat64_1d = [],
+    lbnd: _CoFloat = 0,
+    scl: _CoFloat = 1,
     axis: _Index = 0,
 ) -> _F64_nd: ...
 @overload
 def polyint(
     c: _nt.ToFloat64_nd,
     m: _Index = 1,
-    k: _nt.CoFloat64_0d | _nt.CoFloat64_1d = [],
-    lbnd: _nt.CoFloating_0d = 0,
-    scl: _nt.CoFloating_0d = 1,
+    k: _CoF64 | _nt.CoFloat64_1d = [],
+    lbnd: _CoFloat = 0,
+    scl: _CoFloat = 1,
     axis: _Index = 0,
 ) -> _F64_nd: ...
 @overload
 def polyint(
     c: _nt.CoFloating_nd,
     m: _Index = 1,
-    k: _nt.CoFloating_0d | _nt.CoFloating_1d = [],
-    lbnd: _nt.CoFloating_0d = 0,
-    scl: _nt.CoFloating_0d = 1,
+    k: _CoFloat | _nt.CoFloating_1d = [],
+    lbnd: _CoFloat = 0,
+    scl: _CoFloat = 1,
     axis: _Index = 0,
 ) -> _Float_nd: ...
 @overload
 def polyint(
     c: _nt.ToComplex_nd,
     m: _Index = 1,
-    k: _nt.CoComplex_0d | _nt.CoComplex_1d = [],
-    lbnd: _nt.CoComplex_0d = 0,
-    scl: _nt.CoComplex_0d = 1,
+    k: _CoComplex | _nt.CoComplex_1d = [],
+    lbnd: _CoComplex = 0,
+    scl: _CoComplex = 1,
     axis: _Index = 0,
 ) -> _Complex_nd: ...
 @overload
 def polyint(
     c: _nt.CoComplex_nd,
     m: _Index,
-    k: _nt.ToComplex_0d | _nt.ToComplex_1d,
-    lbnd: _nt.CoComplex_0d = 0,
-    scl: _nt.CoComplex_0d = 1,
+    k: _ToComplex | _nt.ToComplex_1d,
+    lbnd: _CoComplex = 0,
+    scl: _CoComplex = 1,
     axis: _Index = 0,
 ) -> _Complex_nd: ...
 @overload
@@ -343,9 +351,9 @@ def polyint(
     c: _nt.CoComplex_nd,
     m: _Index = 1,
     *,
-    k: _nt.ToComplex_0d | _nt.ToComplex_1d,
-    lbnd: _nt.CoComplex_0d = 0,
-    scl: _nt.CoComplex_0d = 1,
+    k: _ToComplex | _nt.ToComplex_1d,
+    lbnd: _CoComplex = 0,
+    scl: _CoComplex = 1,
     axis: _Index = 0,
 ) -> _Complex_nd: ...
 @overload
@@ -359,24 +367,24 @@ def polyint(
 ) -> _Object_nd: ...
 
 #
+@overload  # workaround for microsoft/pyright#10232
+def polyvalfromroots(
+    x: _nt._ToArray_nnd[_InexactT], r: _nt.CastsArray[_InexactT, _nt.NeitherShape], tensor: bool = True
+) -> _nt.Array[_InexactT]: ...
+@overload  # workaround for microsoft/pyright#10232
+def polyvalfromroots(
+    x: _nt.CastsArray[_InexactT, _nt.NeitherShape], r: _nt._ToArray_nnd[_InexactT], tensor: bool = True
+) -> _nt.Array[_InexactT]: ...
 @overload
-def polyvalfromroots(x: _nt.CoFloating_0d, r: _nt.CoFloating_0d, tensor: bool = True) -> np.floating: ...
-@overload
-def polyvalfromroots(x: _nt.CoFloating_1nd, r: _nt.CoFloating_nd, tensor: bool = True) -> _Float_nd: ...
-@overload
-def polyvalfromroots(x: _nt.CoFloating_nd, r: _nt.CoFloating_1nd, tensor: bool = True) -> _Float_nd: ...
-@overload
-def polyvalfromroots(x: _nt.ToComplex_0d, r: _nt.CoComplex_0d, tensor: bool = True) -> np.complexfloating: ...
+def polyvalfromroots(x: _nt.CastsScalar[_InexactT], r: _InexactT, tensor: bool = True) -> _InexactT: ...
 @overload
-def polyvalfromroots(x: _nt.CoComplex_0d, r: _nt.ToComplex_0d, tensor: bool = True) -> np.complexfloating: ...
+def polyvalfromroots(x: _InexactT, r: _nt.CastsScalar[_InexactT], tensor: bool = True) -> _InexactT: ...
 @overload
-def polyvalfromroots(x: _nt.ToComplex_1nd, r: _nt.CoComplex_nd, tensor: bool = True) -> _Complex_nd: ...
+def polyvalfromroots(x: _nt.CoFloat64_1nd, r: _nt.CoFloat64_nd, tensor: bool = True) -> _nt.Array[np.float64]: ...
 @overload
-def polyvalfromroots(x: _nt.ToComplex_nd, r: _nt.CoComplex_1nd, tensor: bool = True) -> _Complex_nd: ...
+def polyvalfromroots(x: _nt.CoFloat64_nd, r: _nt.CoFloat64_1nd, tensor: bool = True) -> _nt.Array[np.float64]: ...
 @overload
-def polyvalfromroots(x: _nt.CoComplex_1nd, r: _nt.ToComplex_nd, tensor: bool = True) -> _Complex_nd: ...
-@overload
-def polyvalfromroots(x: _nt.CoComplex_nd, r: _nt.ToComplex_1nd, tensor: bool = True) -> _Complex_nd: ...
+def polyvalfromroots(x: _CoF64, r: _CoF64, tensor: bool = True) -> np.float64: ...
 @overload
 def polyvalfromroots(x: _nt.ToObject_1nd, r: _ToNumeric_nd, tensor: bool = True) -> _Object_nd: ...
 @overload
@@ -384,17 +392,17 @@ def polyvalfromroots(x: _ToNumeric_nd, r: _nt.ToObject_1nd, tensor: bool = True)
 
 #
 @overload
-def polyval(x: _nt.CoInteger_0d, c: _nt.CoInteger_1d, tensor: bool = True) -> np.float64: ...
+def polyval(x: _CoInt, c: _nt.CoInteger_1d, tensor: bool = True) -> np.float64: ...
 @overload
-def polyval(x: _nt.ToFloat64_0d, c: _nt.CoFloat64_1d, tensor: bool = True) -> np.float64: ...
+def polyval(x: _ToF64, c: _nt.CoFloat64_1d, tensor: bool = True) -> np.float64: ...
 @overload
-def polyval(x: _nt.CoFloat64_0d, c: _nt.ToFloat64_1d, tensor: bool = True) -> np.float64: ...
+def polyval(x: _CoF64, c: _nt.ToFloat64_1d, tensor: bool = True) -> np.float64: ...
 @overload
-def polyval(x: _nt.CoFloating_0d, c: _nt.CoFloating_1d, tensor: bool = True) -> np.floating: ...
+def polyval(x: _CoFloat, c: _nt.CoFloating_1d, tensor: bool = True) -> np.floating: ...
 @overload
-def polyval(x: _nt.ToComplex_0d, c: _nt.CoComplex_1d, tensor: bool = True) -> np.complexfloating: ...
+def polyval(x: _ToComplex, c: _nt.CoComplex_1d, tensor: bool = True) -> np.complexfloating: ...
 @overload
-def polyval(x: _nt.CoComplex_0d, c: _nt.ToComplex_1d, tensor: bool = True) -> np.complexfloating: ...
+def polyval(x: _CoComplex, c: _nt.ToComplex_1d, tensor: bool = True) -> np.complexfloating: ...
 @overload
 def polyval(x: _nt.ToFloat64_1nd, c: _nt.CoFloat64_1nd, tensor: bool = True) -> _F64_nd: ...
 @overload
@@ -412,21 +420,21 @@ def polyval(x: _ToNumeric_nd, c: _nt.ToObject_1nd, tensor: bool = True) -> _Obje
 
 #
 @overload
-def polyval2d(x: _nt.CoInteger_0d, y: _nt.CoInteger_0d, c: _nt.CoInteger_1d) -> np.float64: ...
+def polyval2d(x: _CoInt, y: _CoInt, c: _nt.CoInteger_1d) -> np.float64: ...
 @overload
-def polyval2d(x: _nt.ToFloat64_0d, y: _nt.CoFloat64_0d, c: _nt.CoFloat64_1d) -> np.float64: ...
+def polyval2d(x: _ToF64, y: _CoF64, c: _nt.CoFloat64_1d) -> np.float64: ...
 @overload
-def polyval2d(x: _nt.CoFloat64_0d, y: _nt.ToFloat64_0d, c: _nt.CoFloat64_1d) -> np.float64: ...
+def polyval2d(x: _CoF64, y: _ToF64, c: _nt.CoFloat64_1d) -> np.float64: ...
 @overload
-def polyval2d(x: _nt.CoFloat64_0d, y: _nt.CoFloat64_0d, c: _nt.ToFloat64_1d) -> np.float64: ...
+def polyval2d(x: _CoF64, y: _CoF64, c: _nt.ToFloat64_1d) -> np.float64: ...
 @overload
-def polyval2d(x: _nt.CoFloating_0d, y: _nt.CoFloating_0d, c: _nt.CoFloating_1d) -> np.floating: ...
+def polyval2d(x: _CoFloat, y: _CoFloat, c: _nt.CoFloating_1d) -> np.floating: ...
 @overload
-def polyval2d(x: _nt.ToComplex_0d, y: _nt.CoComplex_0d, c: _nt.CoComplex_1d) -> np.complexfloating: ...
+def polyval2d(x: _ToComplex, y: _CoComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polyval2d(x: _nt.CoComplex_0d, y: _nt.ToComplex_0d, c: _nt.CoComplex_1d) -> np.complexfloating: ...
+def polyval2d(x: _CoComplex, y: _ToComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polyval2d(x: _nt.CoComplex_0d, y: _nt.CoComplex_0d, c: _nt.ToComplex_1d) -> np.complexfloating: ...
+def polyval2d(x: _CoComplex, y: _CoComplex, c: _nt.ToComplex_1d) -> np.complexfloating: ...
 @overload
 def polyval2d(x: _nt.ToFloat64_1nd, y: _nt.CoFloat64_nd, c: _nt.CoFloat64_1nd) -> _F64_nd: ...
 @overload
@@ -462,21 +470,21 @@ def polyval2d(x: _ToNumeric_nd, y: _nt.ToObject_1nd, c: _ToNumeric_nd) -> _Objec
 
 # keep in sync with *val2d
 @overload
-def polygrid2d(x: _nt.CoInteger_0d, y: _nt.CoInteger_0d, c: _nt.CoInteger_1d) -> np.float64: ...
+def polygrid2d(x: _CoInt, y: _CoInt, c: _nt.CoInteger_1d) -> np.float64: ...
 @overload
-def polygrid2d(x: _nt.ToFloat64_0d, y: _nt.CoFloat64_0d, c: _nt.CoFloat64_1d) -> np.float64: ...
+def polygrid2d(x: _ToF64, y: _CoF64, c: _nt.CoFloat64_1d) -> np.float64: ...
 @overload
-def polygrid2d(x: _nt.CoFloat64_0d, y: _nt.ToFloat64_0d, c: _nt.CoFloat64_1d) -> np.float64: ...
+def polygrid2d(x: _CoF64, y: _ToF64, c: _nt.CoFloat64_1d) -> np.float64: ...
 @overload
-def polygrid2d(x: _nt.CoFloat64_0d, y: _nt.CoFloat64_0d, c: _nt.ToFloat64_1d) -> np.float64: ...
+def polygrid2d(x: _CoF64, y: _CoF64, c: _nt.ToFloat64_1d) -> np.float64: ...
 @overload
-def polygrid2d(x: _nt.CoFloating_0d, y: _nt.CoFloating_0d, c: _nt.CoFloating_1d) -> np.floating: ...
+def polygrid2d(x: _CoFloat, y: _CoFloat, c: _nt.CoFloating_1d) -> np.floating: ...
 @overload
-def polygrid2d(x: _nt.ToComplex_0d, y: _nt.CoComplex_0d, c: _nt.CoComplex_1d) -> np.complexfloating: ...
+def polygrid2d(x: _ToComplex, y: _CoComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polygrid2d(x: _nt.CoComplex_0d, y: _nt.ToComplex_0d, c: _nt.CoComplex_1d) -> np.complexfloating: ...
+def polygrid2d(x: _CoComplex, y: _ToComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polygrid2d(x: _nt.CoComplex_0d, y: _nt.CoComplex_0d, c: _nt.ToComplex_1d) -> np.complexfloating: ...
+def polygrid2d(x: _CoComplex, y: _CoComplex, c: _nt.ToComplex_1d) -> np.complexfloating: ...
 @overload
 def polygrid2d(x: _nt.ToFloat64_1nd, y: _nt.CoFloat64_nd, c: _nt.CoFloat64_1nd) -> _F64_nd: ...
 @overload
@@ -512,9 +520,9 @@ def polygrid2d(x: _ToNumeric_nd, y: _nt.ToObject_1nd, c: _ToNumeric_nd) -> _Obje
 
 #
 @overload
-def polyval3d(
-    x: _nt.CoFloating_0d, y: _nt.CoFloating_0d, z: _nt.CoFloating_0d, c: _nt.CoFloating_1d
-) -> np.floating: ...
+def polyval3d(x: _CoF64, y: _CoF64, z: _CoF64, c: _nt.CoFloating_1d) -> np.float64: ...
+@overload
+def polyval3d(x: _CoFloat, y: _CoFloat, z: _CoFloat, c: _nt.CoFloating_1d) -> np.floating: ...
 @overload
 def polyval3d(
     x: _nt.CoFloating_1nd, y: _nt.CoFloating_nd, z: _nt.CoFloating_nd, c: _nt.CoFloating_1nd
@@ -528,21 +536,13 @@ def polyval3d(
     x: _nt.CoFloating_nd, y: _nt.CoFloating_nd, z: _nt.CoFloating_1nd, c: _nt.CoFloating_1nd
 ) -> _Float_nd: ...
 @overload
-def polyval3d(
-    x: _nt.ToComplex_0d, y: _nt.CoComplex_0d, z: _nt.CoComplex_0d, c: _nt.CoComplex_1d
-) -> np.complexfloating: ...
+def polyval3d(x: _ToComplex, y: _CoComplex, z: _CoComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polyval3d(
-    x: _nt.CoComplex_0d, y: _nt.ToComplex_0d, z: _nt.CoComplex_0d, c: _nt.CoComplex_1d
-) -> np.complexfloating: ...
+def polyval3d(x: _CoComplex, y: _ToComplex, z: _CoComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polyval3d(
-    x: _nt.CoComplex_0d, y: _nt.CoComplex_0d, z: _nt.ToComplex_0d, c: _nt.CoComplex_1d
-) -> np.complexfloating: ...
+def polyval3d(x: _CoComplex, y: _CoComplex, z: _ToComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polyval3d(
-    x: _nt.CoComplex_0d, y: _nt.CoComplex_0d, z: _nt.CoComplex_0d, c: _nt.ToComplex_1d
-) -> np.complexfloating: ...
+def polyval3d(x: _CoComplex, y: _CoComplex, z: _CoComplex, c: _nt.ToComplex_1d) -> np.complexfloating: ...
 @overload
 def polyval3d(x: _nt.ToComplex_1nd, y: _nt.CoComplex_nd, z: _nt.CoComplex_nd, c: _nt.CoComplex_1nd) -> _Complex_nd: ...
 @overload
@@ -566,9 +566,7 @@ def polyval3d(x: _ToNumeric_nd, y: _ToNumeric_nd, z: _ToNumeric_nd, c: _nt.ToObj
 
 # keep in sync with *val3d
 @overload
-def polygrid3d(
-    x: _nt.CoFloating_0d, y: _nt.CoFloating_0d, z: _nt.CoFloating_0d, c: _nt.CoFloating_1d
-) -> np.floating: ...
+def polygrid3d(x: _CoFloat, y: _CoFloat, z: _CoFloat, c: _nt.CoFloating_1d) -> np.floating: ...
 @overload
 def polygrid3d(
     x: _nt.CoFloating_1nd, y: _nt.CoFloating_nd, z: _nt.CoFloating_nd, c: _nt.CoFloating_1nd
@@ -582,21 +580,13 @@ def polygrid3d(
     x: _nt.CoFloating_nd, y: _nt.CoFloating_nd, z: _nt.CoFloating_1nd, c: _nt.CoFloating_1nd
 ) -> _Float_nd: ...
 @overload
-def polygrid3d(
-    x: _nt.ToComplex_0d, y: _nt.CoComplex_0d, z: _nt.CoComplex_0d, c: _nt.CoComplex_1d
-) -> np.complexfloating: ...
+def polygrid3d(x: _ToComplex, y: _CoComplex, z: _CoComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polygrid3d(
-    x: _nt.CoComplex_0d, y: _nt.ToComplex_0d, z: _nt.CoComplex_0d, c: _nt.CoComplex_1d
-) -> np.complexfloating: ...
+def polygrid3d(x: _CoComplex, y: _ToComplex, z: _CoComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polygrid3d(
-    x: _nt.CoComplex_0d, y: _nt.CoComplex_0d, z: _nt.ToComplex_0d, c: _nt.CoComplex_1d
-) -> np.complexfloating: ...
+def polygrid3d(x: _CoComplex, y: _CoComplex, z: _ToComplex, c: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def polygrid3d(
-    x: _nt.CoComplex_0d, y: _nt.CoComplex_0d, z: _nt.CoComplex_0d, c: _nt.ToComplex_1d
-) -> np.complexfloating: ...
+def polygrid3d(x: _CoComplex, y: _CoComplex, z: _CoComplex, c: _nt.ToComplex_1d) -> np.complexfloating: ...
 @overload
 def polygrid3d(x: _nt.ToComplex_1nd, y: _nt.CoComplex_nd, z: _nt.CoComplex_nd, c: _nt.CoComplex_1nd) -> _Complex_nd: ...
 @overload
diff --git a/src/numpy-stubs/polynomial/polyutils.pyi b/src/numpy-stubs/polynomial/polyutils.pyi
index db83a111..b9207f8c 100644
--- a/src/numpy-stubs/polynomial/polyutils.pyi
+++ b/src/numpy-stubs/polynomial/polyutils.pyi
@@ -80,13 +80,15 @@ def mapparms(old: _CoNumeric_1d, new: _CoNumeric_1d) -> _Tuple2[Any]: ...
 
 #
 @overload
-def mapdomain(x: _nt.CoFloating_0d, old: _nt.CoFloating_1d, new: _nt.CoFloating_1d) -> np.floating: ...
+def mapdomain(x: _nt.co_float | float, old: _nt.CoFloating_1d, new: _nt.CoFloating_1d) -> np.floating: ...
 @overload
-def mapdomain(x: _nt.ToComplex_0d, old: _nt.CoComplex_1d, new: _nt.CoComplex_1d) -> np.complexfloating: ...
+def mapdomain(
+    x: np.complexfloating | _nt.JustComplex, old: _nt.CoComplex_1d, new: _nt.CoComplex_1d
+) -> np.complexfloating: ...
 @overload
-def mapdomain(x: _nt.CoComplex_0d, old: _nt.ToComplex_1d, new: _nt.CoComplex_1d) -> np.complexfloating: ...
+def mapdomain(x: _nt.co_complex | complex, old: _nt.ToComplex_1d, new: _nt.CoComplex_1d) -> np.complexfloating: ...
 @overload
-def mapdomain(x: _nt.CoComplex_0d, old: _nt.CoComplex_1d, new: _nt.ToComplex_1d) -> np.complexfloating: ...
+def mapdomain(x: _nt.co_complex | complex, old: _nt.CoComplex_1d, new: _nt.ToComplex_1d) -> np.complexfloating: ...
 @overload
 def mapdomain(x: _nt.CoFloating_1d, old: _nt.CoFloating_1d, new: _nt.CoFloating_1d) -> _nt.Array1D[np.floating]: ...
 @overload
@@ -96,17 +98,17 @@ def mapdomain(x: _nt.CoComplex_1d, old: _nt.ToComplex_1d, new: _nt.CoComplex_1d)
 @overload
 def mapdomain(x: _nt.CoComplex_1d, old: _nt.CoComplex_1d, new: _nt.ToComplex_1d) -> _nt.Array1D[np.complexfloating]: ...
 @overload
-def mapdomain(x: _nt.ToObject_0d, old: _CoNumeric_1d, new: _CoNumeric_1d) -> Any: ...
-@overload
-def mapdomain(x: _CoNumeric_0d, old: _nt.ToObject_1d, new: _CoNumeric_1d) -> Any: ...
-@overload
-def mapdomain(x: _CoNumeric_0d, old: _CoNumeric_1d, new: _nt.ToObject_1d) -> Any: ...
-@overload
 def mapdomain(x: _nt.ToObject_1d, old: _CoNumeric_1d, new: _CoNumeric_1d) -> _nt.Array1D[np.object_]: ...
 @overload
 def mapdomain(x: _CoNumeric_1d, old: _nt.ToObject_1d, new: _CoNumeric_1d) -> _nt.Array1D[np.object_]: ...
 @overload
 def mapdomain(x: _CoNumeric_1d, old: _CoNumeric_1d, new: _nt.ToObject_1d) -> _nt.Array1D[np.object_]: ...
+@overload
+def mapdomain(x: _CoNumeric_0d, old: _nt.ToObject_1d, new: _CoNumeric_1d) -> Any: ...
+@overload
+def mapdomain(x: _CoNumeric_0d, old: _CoNumeric_1d, new: _nt.ToObject_1d) -> Any: ...
+@overload
+def mapdomain(x: _nt.ToObject_0d, old: _CoNumeric_1d, new: _CoNumeric_1d) -> Any: ...
 
 #
 def format_float(x: _FloatLike_co, parens: bool = False) -> str: ...
diff --git a/src/numpy-stubs/random/_generator.pyi b/src/numpy-stubs/random/_generator.pyi
index 8e33d802..4023b44c 100644
--- a/src/numpy-stubs/random/_generator.pyi
+++ b/src/numpy-stubs/random/_generator.pyi
@@ -13,8 +13,11 @@ from numpy.random import BitGenerator, RandomState, SeedSequence
 
 _ScalarT = TypeVar("_ScalarT", bound=np.generic)
 _IntegerT = TypeVar("_IntegerT", bound=_nt.co_integer)
+_ShapeT = TypeVar("_ShapeT", bound=_nt.Shape)
 
 _DTypeLikeFloat: TypeAlias = _nt.ToDTypeFloat32 | _nt.ToDTypeFloat64
+_CoInt_nnd: TypeAlias = _nt._ToArray_nnd[_nt.co_integer]
+_CoFloat_nnd: TypeAlias = _nt._ToArray_nnd[_nt.co_float]
 
 _ExpMethod: TypeAlias = Literal["zig", "inv"]
 
@@ -139,22 +142,34 @@ class Generator:
     def random(self, /, size: None = None, dtype: _DTypeLikeFloat = ..., out: None = None) -> float: ...
     @overload
     def random(
-        self, /, size: _ShapeLike | None = None, dtype: _nt.ToDTypeFloat64 = ..., *, out: _nt.Array[np.float64]
-    ) -> _nt.Array[np.float64]: ...
+        self, /, size: _ShapeLike | None = None, dtype: _nt.ToDTypeFloat64 = ..., *, out: _nt.Array[np.float64, _ShapeT]
+    ) -> _nt.Array[np.float64, _ShapeT]: ...
     @overload
     def random(
         self, /, size: _ShapeLike, dtype: _nt.ToDTypeFloat64 = ..., out: _nt.Array[np.float64] | None = None
     ) -> _nt.Array[np.float64]: ...
     @overload
     def random(
-        self, /, size: _ShapeLike | None = None, dtype: _nt.ToDTypeFloat32 = ..., *, out: _nt.Array[np.float32]
-    ) -> _nt.Array[np.float32]: ...
+        self, /, size: _ShapeLike | None = None, dtype: _nt.ToDTypeFloat32 = ..., *, out: _nt.Array[np.float32, _ShapeT]
+    ) -> _nt.Array[np.float32, _ShapeT]: ...
     @overload
     def random(
         self, /, size: _ShapeLike, dtype: _nt.ToDTypeFloat32, out: _nt.Array[np.float32] | None = None
     ) -> _nt.Array[np.float32]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def uniform(
+        self, /, low: _CoFloat_nnd, high: _nt.CoFloating_nd = 1.0, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def uniform(
+        self, /, low: _nt.CoFloating_nd, high: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def uniform(
+        self, /, low: _nt.CoFloating_nd = 0.0, *, high: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def uniform(self, /, low: _nt.CoFloating_0d = 0.0, high: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload  # size: (int, ...)  (positional)
@@ -171,6 +186,18 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def triangular(
+        self, /, left: _CoFloat_nnd, mode: _nt.CoFloating_nd, right: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def triangular(
+        self, /, left: _nt.CoFloating_nd, mode: _CoFloat_nnd, right: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def triangular(
+        self, /, left: _nt.CoFloating_nd, mode: _nt.CoFloating_nd, right: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def triangular(
         self, /, left: _nt.CoFloating_0d, mode: _nt.CoFloating_0d, right: _nt.CoFloating_0d, size: None = None
@@ -190,6 +217,10 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def beta(self, /, a: _CoFloat_nnd, b: _nt.CoFloating_nd, size: None = None) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def beta(self, /, a: _nt.CoFloating_nd, b: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def beta(self, /, a: _nt.CoFloating_0d, b: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -244,6 +275,8 @@ class Generator:
     ) -> _nt.Array[np.float32]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def exponential(self, /, scale: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload
     def exponential(self, /, scale: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload
@@ -256,6 +289,18 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def laplace(
+        self, /, loc: _CoFloat_nnd, scale: _nt.CoFloating_nd = 1.0, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def laplace(
+        self, /, loc: _nt.CoFloating_nd, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def laplace(
+        self, /, loc: _nt.CoFloating_nd = 0.0, *, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def laplace(self, /, loc: _nt.CoFloating_0d = 0.0, scale: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload  # size: (int, ...)  (positional)
@@ -272,6 +317,18 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def logistic(
+        self, /, loc: _CoFloat_nnd, scale: _nt.CoFloating_nd = 1.0, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def logistic(
+        self, /, loc: _nt.CoFloating_nd, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def logistic(
+        self, /, loc: _nt.CoFloating_nd = 0.0, *, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def logistic(self, /, loc: _nt.CoFloating_0d = 0.0, scale: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload  # size: (int, ...)  (positional)
@@ -288,6 +345,8 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def power(self, /, a: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def power(self, /, a: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -296,6 +355,8 @@ class Generator:
     def power(self, /, a: _nt.CoFloating_nd, size: _ShapeLike | None = None) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def pareto(self, /, a: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def pareto(self, /, a: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -304,6 +365,18 @@ class Generator:
     def pareto(self, /, a: _nt.CoFloating_nd, size: _ShapeLike | None = None) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def gumbel(
+        self, /, loc: _CoFloat_nnd, scale: _nt.CoFloating_nd = 1.0, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def gumbel(
+        self, /, loc: _nt.CoFloating_nd, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def gumbel(
+        self, /, loc: _nt.CoFloating_nd = 0.0, *, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def gumbel(self, /, loc: _nt.CoFloating_0d = 0.0, scale: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload  # size: (int, ...)  (positional)
@@ -320,6 +393,8 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def weibull(self, /, a: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def weibull(self, /, a: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -328,6 +403,8 @@ class Generator:
     def weibull(self, /, a: _nt.CoFloating_nd, size: _ShapeLike | None = None) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def rayleigh(self, /, scale: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def rayleigh(self, /, scale: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload  # size: (int, ...)  (positional)
@@ -340,6 +417,8 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def chisquare(self, /, df: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def chisquare(self, /, df: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -348,6 +427,14 @@ class Generator:
     def chisquare(self, /, df: _nt.CoFloating_nd, size: _ShapeLike | None = None) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def noncentral_chisquare(
+        self, /, df: _CoFloat_nnd, nonc: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def noncentral_chisquare(
+        self, /, df: _nt.CoFloating_nd, nonc: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def noncentral_chisquare(self, /, df: _nt.CoFloating_0d, nonc: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -380,6 +467,18 @@ class Generator:
     ) -> _nt.Array[np.float32]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def normal(
+        self, /, loc: _CoFloat_nnd, scale: _nt.CoFloating_nd = 1.0, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def normal(
+        self, /, loc: _nt.CoFloating_nd, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def normal(
+        self, /, loc: _nt.CoFloating_nd = 0.0, *, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def normal(self, /, loc: _nt.CoFloating_0d = 0.0, scale: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload  # size: (int, ...)  (positional)
@@ -396,6 +495,18 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def lognormal(
+        self, /, mean: _CoFloat_nnd, sigma: _nt.CoFloating_nd = 1.0, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def lognormal(
+        self, /, mean: _nt.CoFloating_nd = 0.0, *, sigma: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def lognormal(
+        self, /, mean: _nt.CoFloating_nd, sigma: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def lognormal(
         self, /, mean: _nt.CoFloating_0d = 0.0, sigma: _nt.CoFloating_0d = 1.0, size: None = None
@@ -414,6 +525,14 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def vonmises(
+        self, /, mu: _CoFloat_nnd, kappa: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def vonmises(
+        self, /, mu: _nt.CoFloating_nd, kappa: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def vonmises(self, /, mu: _nt.CoFloating_0d, kappa: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -432,6 +551,8 @@ class Generator:
     def standard_cauchy(self, /, size: _ShapeLike) -> _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def standard_t(self, /, df: _CoFloat_nnd, size: None = None) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def standard_t(self, /, df: float, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -440,6 +561,18 @@ class Generator:
     def standard_t(self, /, df: _nt.CoFloating_nd, size: _ShapeLike | None = None) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def standard_gamma(
+        self, /, shape: _CoFloat_nnd, size: None = None, dtype: _nt.ToDTypeFloat64 = ..., out: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def standard_gamma(
+        self, /, shape: _CoFloat_nnd, size: None = None, *, dtype: _nt.ToDTypeFloat32, out: None = None
+    ) -> float | _nt.Array[np.float32]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def standard_gamma(
+        self, /, shape: _CoFloat_nnd, size: None, dtype: _nt.ToDTypeFloat32, out: None = None
+    ) -> float | _nt.Array[np.float32]: ...
     @overload
     def standard_gamma(
         self, /, shape: _nt.CoFloating_0d, size: None = None, dtype: _DTypeLikeFloat = ..., out: None = None
@@ -503,6 +636,14 @@ class Generator:
     ) -> float | _nt.Array[np.float32]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def gamma(
+        self, /, shape: _CoFloat_nnd, scale: _nt.CoFloating_nd = 1.0, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def gamma(
+        self, /, shape: _nt.CoFloating_nd, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def gamma(self, /, shape: _nt.CoFloating_0d, scale: _nt.CoFloating_0d = 1.0, size: None = None) -> float: ...
     @overload  # size: (int, ...)  (positional)
@@ -519,6 +660,14 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def f(
+        self, /, dfnum: _CoFloat_nnd, dfden: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def f(
+        self, /, dfnum: _nt.CoFloating_nd, dfden: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def f(self, /, dfnum: _nt.CoFloating_0d, dfden: _nt.CoFloating_0d, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -529,6 +678,18 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def noncentral_f(
+        self, /, dfnum: _CoFloat_nnd, dfden: _nt.CoFloating_nd, nonc: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def noncentral_f(
+        self, /, dfnum: _nt.CoFloating_nd, dfden: _CoFloat_nnd, nonc: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def noncentral_f(
+        self, /, dfnum: _nt.CoFloating_nd, dfden: _nt.CoFloating_nd, nonc: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def noncentral_f(
         self, /, dfnum: _nt.CoFloating_0d, dfden: _nt.CoFloating_0d, nonc: _nt.CoFloating_0d, size: None = None
@@ -548,6 +709,14 @@ class Generator:
     ) -> float | _nt.Array[np.float64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def wald(
+        self, /, mean: _CoFloat_nnd, scale: _nt.CoFloating_nd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def wald(
+        self, /, mean: _nt.CoFloating_nd, scale: _CoFloat_nnd, size: None = None
+    ) -> float | _nt.Array[np.float64]: ...
     @overload  # size: None  (default)
     def wald(self, /, mean: float, scale: float, size: None = None) -> float: ...
     @overload  # size: (int, ...)
@@ -1025,6 +1194,10 @@ class Generator:
     ) -> np.uint64 | _nt.Array[np.uint64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def binomial(self, /, n: _CoInt_nnd, p: _nt.CoFloating_nd, size: None = None) -> int | _nt.Array[np.int64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def binomial(self, /, n: _nt.CoInteger_nd, p: _CoFloat_nnd, size: None = None) -> int | _nt.Array[np.int64]: ...
     @overload  # size: None  (default)
     def binomial(self, /, n: int, p: _nt.CoFloating_0d, size: None = None) -> int: ...
     @overload  # size: (int, ...)
@@ -1035,6 +1208,14 @@ class Generator:
     ) -> int | _nt.Array[np.int64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def negative_binomial(
+        self, /, n: _CoFloat_nnd, p: _nt.CoFloating_nd, size: None = None
+    ) -> int | _nt.Array[np.int64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def negative_binomial(
+        self, /, n: _nt.CoFloating_nd, p: _CoFloat_nnd, size: None = None
+    ) -> int | _nt.Array[np.int64]: ...
     @overload  # size: None  (default)
     def negative_binomial(self, /, n: _nt.CoFloating_0d, p: _nt.CoFloating_0d, size: None = None) -> int: ...
     @overload  # size: (int, ...)
@@ -1047,6 +1228,8 @@ class Generator:
     ) -> int | _nt.Array[np.int64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def poisson(self, /, lam: _CoFloat_nnd, size: None = None) -> int | _nt.Array[np.int64]: ...
     @overload  # size: None  (default)
     def poisson(self, /, lam: _nt.CoFloating_0d = 1.0, size: None = None) -> int: ...
     @overload  # size: (int, ...)  (positional)
@@ -1057,6 +1240,8 @@ class Generator:
     def poisson(self, /, lam: _nt.CoFloating_nd = 1.0, size: _ShapeLike | None = None) -> int | _nt.Array[np.int64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def zipf(self, /, a: _CoFloat_nnd, size: None = None) -> int | _nt.Array[np.int64]: ...
     @overload  # size: None  (default)
     def zipf(self, /, a: _nt.CoFloating_0d, size: None = None) -> int: ...
     @overload  # size: (int, ...)
@@ -1065,6 +1250,8 @@ class Generator:
     def zipf(self, /, a: _nt.CoFloating_nd, size: _ShapeLike | None = None) -> int | _nt.Array[np.int64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def geometric(self, /, p: _CoFloat_nnd, size: None = None) -> int | _nt.Array[np.int64]: ...
     @overload  # size: None  (default)
     def geometric(self, /, p: _nt.CoFloating_0d, size: None = None) -> int: ...
     @overload  # size: (int, ...)
@@ -1073,6 +1260,18 @@ class Generator:
     def geometric(self, /, p: _nt.CoFloating_nd, size: _ShapeLike | None = None) -> int | _nt.Array[np.int64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def hypergeometric(
+        self, /, ngood: _CoInt_nnd, nbad: _nt.CoInteger_nd, nsample: _nt.CoInteger_nd, size: None = None
+    ) -> int | _nt.Array[np.int64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def hypergeometric(
+        self, /, ngood: _nt.CoInteger_nd, nbad: _CoInt_nnd, nsample: _nt.CoInteger_nd, size: None = None
+    ) -> int | _nt.Array[np.int64]: ...
+    @overload  # workaround for microsoft/pyright#10232
+    def hypergeometric(
+        self, /, ngood: _nt.CoInteger_nd, nbad: _nt.CoInteger_nd, nsample: _CoInt_nnd, size: None = None
+    ) -> int | _nt.Array[np.int64]: ...
     @overload  # size: None  (default)
     def hypergeometric(self, /, ngood: int, nbad: int, nsample: int, size: None = None) -> int: ...
     @overload  # size: (int, ...)
@@ -1090,6 +1289,8 @@ class Generator:
     ) -> int | _nt.Array[np.int64]: ...
 
     #
+    @overload  # workaround for microsoft/pyright#10232
+    def logseries(self, /, p: _CoFloat_nnd, size: None = None) -> int | _nt.Array[np.int64]: ...
     @overload  # size: None  (default)
     def logseries(self, /, p: _nt.CoFloating_0d, size: None = None) -> int: ...
     @overload  # size: (int, ...)