diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi
index 539c5fa53c24..e5c440bc8a79 100644
--- a/numpy/__init__.pyi
+++ b/numpy/__init__.pyi
@@ -2231,11 +2231,9 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DType_co]):
     @overload
     def resize(self, new_shape: _ShapeLike, /, *, refcheck: builtins.bool = ...) -> None: ...
     @overload
-    def resize(self, *new_shape: SupportsIndex, refcheck: builtins.bool = ...) -> None: ...
+    def resize(self, /, *new_shape: SupportsIndex, refcheck: builtins.bool = ...) -> None: ...
 
-    def setflags(
-        self, write: builtins.bool = ..., align: builtins.bool = ..., uic: builtins.bool = ...
-    ) -> None: ...
+    def setflags(self, write: builtins.bool = ..., align: builtins.bool = ..., uic: builtins.bool = ...) -> None: ...
 
     def squeeze(
         self,
@@ -2381,13 +2379,6 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DType_co]):
         sorter: None | _ArrayLikeInt_co = ...,
     ) -> NDArray[intp]: ...
 
-    def setfield(
-        self,
-        val: ArrayLike,
-        dtype: DTypeLike,
-        offset: SupportsIndex = ...,
-    ) -> None: ...
-
     def sort(
         self,
         axis: SupportsIndex = ...,
@@ -2567,23 +2558,14 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DType_co]):
     @overload  # (dtype: ?, type: type[T])
     def view(self, /, dtype: DTypeLike, type: type[_ArrayT]) -> _ArrayT: ...
 
+    def setfield(self, /, val: ArrayLike, dtype: DTypeLike, offset: CanIndex = 0) -> None: ...
     @overload
-    def getfield(
-        self,
-        dtype: _DTypeLike[_SCT],
-        offset: SupportsIndex = ...
-    ) -> NDArray[_SCT]: ...
+    def getfield(self, dtype: _DTypeLike[_SCT], offset: SupportsIndex = 0) -> NDArray[_SCT]: ...
     @overload
-    def getfield(
-        self,
-        dtype: DTypeLike,
-        offset: SupportsIndex = ...
-    ) -> NDArray[Any]: ...
+    def getfield(self, dtype: DTypeLike, offset: SupportsIndex = 0) -> NDArray[Any]: ...
 
-    def __index__(self: NDArray[np.integer[Any]], /) -> int: ...
-    def __int__(self: NDArray[number[Any] | np.timedelta64 | np.bool | object_], /) -> int: ...
-    def __float__(self: NDArray[number[Any] | np.timedelta64 | np.bool | object_], /) -> float: ...
-    def __complex__(self: NDArray[number[Any] | np.bool | object_], /) -> complex: ...
+    def __index__(self: NDArray[integer], /) -> int: ...
+    def __complex__(self: NDArray[number | np.bool | object_], /) -> complex: ...
 
     def __len__(self) -> int: ...
     def __contains__(self, value: object, /) -> builtins.bool: ...
@@ -2659,9 +2641,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DType_co]):
     # @overload
     # def __abs__(self: ndarray[_ShapeType, dtype[complex128]], /) -> ndarray[_ShapeType, dtype[float64]]: ...
     @overload
-    def __abs__(
-        self: ndarray[_ShapeT, dtype[complexfloating[_AnyNBitInexact]]], /
-    ) -> ndarray[_ShapeT, dtype[floating[_AnyNBitInexact]]]: ...
+    def __abs__(self: ndarray[_ShapeT, dtype[complexfloating[_NBit]]], /) -> ndarray[_ShapeT, dtype[floating[_NBit]]]: ...
     @overload
     def __abs__(self: _RealArrayT, /) -> _RealArrayT: ...
 
diff --git a/numpy/_core/_internal.pyi b/numpy/_core/_internal.pyi
index 690554f66f94..15726fe3064e 100644
--- a/numpy/_core/_internal.pyi
+++ b/numpy/_core/_internal.pyi
@@ -1,23 +1,41 @@
-from typing import Any, TypeVar, overload, Generic
 import ctypes as ct
+import re
+from collections.abc import Callable, Iterable
+from typing import Any, Final, Generic, overload
 
-from numpy.typing import NDArray
+from typing_extensions import Self, TypeVar, deprecated
+
+import numpy as np
+import numpy.typing as npt
 from numpy.ctypeslib import c_intp
 
-_CastT = TypeVar("_CastT", bound=ct._CanCastTo)  # Copied from `ctypes.cast`
+_CastT = TypeVar("_CastT", bound=ct._CanCastTo)
+_T_co = TypeVar("_T_co", covariant=True)
 _CT = TypeVar("_CT", bound=ct._CData)
-_PT = TypeVar("_PT", bound=int)
+_PT_co = TypeVar("_PT_co", bound=int | None, default=None, covariant=True)
+
+###
+
+IS_PYPY: Final[bool] = ...
+
+format_re: Final[re.Pattern[str]] = ...
+sep_re: Final[re.Pattern[str]] = ...
+space_re: Final[re.Pattern[str]] = ...
+
+###
 
 # TODO: Let the likes of `shape_as` and `strides_as` return `None`
 # for 0D arrays once we've got shape-support
 
-class _ctypes(Generic[_PT]):
+class _ctypes(Generic[_PT_co]):
     @overload
-    def __new__(cls, array: NDArray[Any], ptr: None = ...) -> _ctypes[None]: ...
+    def __init__(self: _ctypes[None], /, array: npt.NDArray[Any], ptr: None = None) -> None: ...
     @overload
-    def __new__(cls, array: NDArray[Any], ptr: _PT) -> _ctypes[_PT]: ...
+    def __init__(self, /, array: npt.NDArray[Any], ptr: _PT_co) -> None: ...
+
+    #
     @property
-    def data(self) -> _PT: ...
+    def data(self) -> _PT_co: ...
     @property
     def shape(self) -> ct.Array[c_intp]: ...
     @property
@@ -25,6 +43,30 @@ class _ctypes(Generic[_PT]):
     @property
     def _as_parameter_(self) -> ct.c_void_p: ...
 
-    def data_as(self, obj: type[_CastT]) -> _CastT: ...
-    def shape_as(self, obj: type[_CT]) -> ct.Array[_CT]: ...
-    def strides_as(self, obj: type[_CT]) -> ct.Array[_CT]: ...
+    #
+    def data_as(self, /, obj: type[_CastT]) -> _CastT: ...
+    def shape_as(self, /, obj: type[_CT]) -> ct.Array[_CT]: ...
+    def strides_as(self, /, obj: type[_CT]) -> ct.Array[_CT]: ...
+
+    #
+    @deprecated('"get_data" is deprecated. Use "data" instead')
+    def get_data(self, /) -> _PT_co: ...
+    @deprecated('"get_shape" is deprecated. Use "shape" instead')
+    def get_shape(self, /) -> ct.Array[c_intp]: ...
+    @deprecated('"get_strides" is deprecated. Use "strides" instead')
+    def get_strides(self, /) -> ct.Array[c_intp]: ...
+    @deprecated('"get_as_parameter" is deprecated. Use "_as_parameter_" instead')
+    def get_as_parameter(self, /) -> ct.c_void_p: ...
+
+class dummy_ctype(Generic[_T_co]):
+    _cls: type[_T_co]
+
+    def __init__(self, /, cls: type[_T_co]) -> None: ...
+    def __eq__(self, other: Self, /) -> bool: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    def __ne__(self, other: Self, /) -> bool: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    def __mul__(self, other: object, /) -> Self: ...
+    def __call__(self, /, *other: object) -> _T_co: ...
+
+def array_ufunc_errmsg_formatter(dummy: object, ufunc: np.ufunc, method: str, *inputs: object, **kwargs: object) -> str: ...
+def array_function_errmsg_formatter(public_api: Callable[..., object], types: Iterable[str]) -> str: ...
+def npy_ctypes_check(cls: type) -> bool: ...
diff --git a/numpy/_core/arrayprint.pyi b/numpy/_core/arrayprint.pyi
index 661d58a22fe3..1f8be64d5e7b 100644
--- a/numpy/_core/arrayprint.pyi
+++ b/numpy/_core/arrayprint.pyi
@@ -8,6 +8,7 @@ from typing import Any, Final, Literal, SupportsIndex, TypeAlias, TypedDict, ove
 from typing_extensions import deprecated
 
 import numpy as np
+from numpy._globals import _NoValueType
 from numpy._typing import NDArray, _CharLike_co, _FloatLike_co
 
 __all__ = [
@@ -93,13 +94,14 @@ def array2string(
     suppress_small: bool | None = None,
     separator: str = " ",
     prefix: str = "",
-    *,
+    style: _NoValueType = ...,
     formatter: _FormatDict | None = None,
     threshold: int | None = None,
     edgeitems: int | None = None,
     sign: _Sign | None = None,
     floatmode: _FloatMode | None = None,
     suffix: str = "",
+    *,
     legacy: _Legacy | None = None,
 ) -> str: ...
 @overload  # style=<given> (positional), legacy="1.13"
diff --git a/numpy/_core/einsumfunc.pyi b/numpy/_core/einsumfunc.pyi
index d7de9c02e16e..00629a478c25 100644
--- a/numpy/_core/einsumfunc.pyi
+++ b/numpy/_core/einsumfunc.pyi
@@ -180,5 +180,6 @@ def einsum_path(
     subscripts: str | _ArrayLikeInt_co,
     /,
     *operands: _ArrayLikeComplex_co | _DTypeLikeObject,
-    optimize: _OptimizeKind = ...,
+    optimize: _OptimizeKind = "greedy",
+    einsum_call: Literal[False] = False,
 ) -> tuple[list[Any], str]: ...
diff --git a/numpy/_core/multiarray.pyi b/numpy/_core/multiarray.pyi
index b656472dfec7..ea304c0789ab 100644
--- a/numpy/_core/multiarray.pyi
+++ b/numpy/_core/multiarray.pyi
@@ -355,7 +355,8 @@ class _ConstructorEmpty(Protocol):
         **kwargs: Unpack[_KwargsEmpty],
     ) -> NDArray[Any]: ...
 
-error: Final = Exception
+# using `Final` or `TypeAlias` will break stubtest
+error = Exception
 
 # from ._multiarray_umath
 ITEM_HASOBJECT: Final[L[1]]
diff --git a/numpy/_core/records.pyi b/numpy/_core/records.pyi
index 308f96b7407b..b4ca5ff0e3bf 100644
--- a/numpy/_core/records.pyi
+++ b/numpy/_core/records.pyi
@@ -1,12 +1,13 @@
 # ruff: noqa: ANN401
 # pyright: reportSelfClsParameterName=false
 from collections.abc import Iterable, Sequence
-from types import EllipsisType
-from typing import Any, Literal, Protocol, SupportsIndex, TypeAlias, TypeVar, overload, type_check_only
+from typing import Any, ClassVar, Literal, Protocol, SupportsIndex, TypeAlias, overload, type_check_only
 
 from _typeshed import StrOrBytesPath
+from typing_extensions import TypeVar
 
-from numpy import _ByteOrder, _OrderKACF, _SupportsBuffer, dtype, generic, ndarray, void
+import numpy as np
+from numpy import _ByteOrder, _OrderKACF, _SupportsBuffer
 from numpy._typing import ArrayLike, DTypeLike, NDArray, _ArrayLikeVoid_co, _NestedSequence, _ShapeLike
 
 __all__ = [
@@ -22,11 +23,11 @@ __all__ = [
 ]
 
 _T = TypeVar("_T")
-_SCT = TypeVar("_SCT", bound=generic)
-_DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True)
+_SCT = TypeVar("_SCT", bound=np.generic)
+_DTypeT_co = TypeVar("_DTypeT_co", bound=np.dtype[Any], covariant=True)
 _ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], covariant=True)
 
-_RecArray: TypeAlias = recarray[Any, dtype[_SCT]]
+_RecArray: TypeAlias = recarray[Any, np.dtype[_SCT]]
 
 @type_check_only
 class _SupportsReadInto(Protocol):
@@ -37,7 +38,7 @@ class _SupportsReadInto(Protocol):
 ###
 
 # exported in `numpy.rec`
-class record(void):
+class record(np.void):
     def __getattribute__(self, attr: str) -> Any: ...
     def __setattr__(self, attr: str, val: ArrayLike) -> None: ...
     def pprint(self) -> str: ...
@@ -47,10 +48,9 @@ class record(void):
     def __getitem__(self, key: list[str]) -> record: ...
 
 # exported in `numpy.rec`
-class recarray(ndarray[_ShapeT_co, _DType_co]):
-    # NOTE: While not strictly mandatory, we're demanding here that arguments
-    # for the `format_parser`- and `dtype`-based dtype constructors are
-    # mutually exclusive
+class recarray(np.ndarray[_ShapeT_co, _DTypeT_co]):
+    __name__: ClassVar[Literal["record"]] = "record"
+    __module__: Literal["numpy"] = "numpy"
     @overload
     def __new__(
         subtype,
@@ -66,7 +66,7 @@ class recarray(ndarray[_ShapeT_co, _DType_co]):
         byteorder: _ByteOrder | None = None,
         aligned: bool = False,
         order: _OrderKACF = "C",
-    ) -> recarray[Any, dtype[record]]: ...
+    ) -> _RecArray[record]: ...
     @overload
     def __new__(
         subtype,
@@ -81,18 +81,20 @@ class recarray(ndarray[_ShapeT_co, _DType_co]):
         byteorder: None = None,
         aligned: Literal[False] = False,
         order: _OrderKACF = "C",
-    ) -> recarray[Any, dtype[Any]]: ...
+    ) -> _RecArray[Any]: ...
     def __array_finalize__(self, /, obj: object) -> None: ...
     def __getattribute__(self, attr: str, /) -> Any: ...
     def __setattr__(self, attr: str, val: ArrayLike, /) -> None: ...
-    @overload
-    def field(self, /, attr: int | str, val: None = None) -> Any: ...
+
+    #
     @overload
     def field(self, /, attr: int | str, val: ArrayLike) -> None: ...
+    @overload
+    def field(self, /, attr: int | str, val: None = None) -> Any: ...
 
 # exported in `numpy.rec`
 class format_parser:
-    dtype: dtype[void]
+    dtype: np.dtype[np.void]
     def __init__(
         self,
         /,
@@ -213,6 +215,7 @@ def array(
     dtype: None = None,
     shape: _ShapeLike | None = None,
     offset: int = 0,
+    strides: tuple[int, ...] | None = None,
     formats: None = None,
     names: None = None,
     titles: None = None,
@@ -226,6 +229,7 @@ def array(
     dtype: DTypeLike,
     shape: _ShapeLike | None = None,
     offset: int = 0,
+    strides: tuple[int, ...] | None = None,
     formats: None = None,
     names: None = None,
     titles: None = None,
@@ -239,6 +243,7 @@ def array(
     dtype: None = None,
     shape: _ShapeLike | None = None,
     offset: int = 0,
+    strides: tuple[int, ...] | None = None,
     *,
     formats: DTypeLike,
     names: str | Sequence[str] | None = None,
@@ -253,6 +258,7 @@ def array(
     dtype: DTypeLike,
     shape: _ShapeLike,
     offset: int = 0,
+    strides: tuple[int, ...] | None = None,
     formats: None = None,
     names: None = None,
     titles: None = None,
@@ -267,6 +273,7 @@ def array(
     *,
     shape: _ShapeLike,
     offset: int = 0,
+    strides: tuple[int, ...] | None = None,
     formats: DTypeLike,
     names: str | Sequence[str] | None = None,
     titles: str | Sequence[str] | None = None,
@@ -280,6 +287,7 @@ def array(
     dtype: DTypeLike,
     shape: _ShapeLike | None = None,
     offset: int = 0,
+    strides: tuple[int, ...] | None = None,
     formats: None = None,
     names: None = None,
     titles: None = None,
@@ -293,6 +301,7 @@ def array(
     dtype: None = None,
     shape: _ShapeLike | None = None,
     offset: int = 0,
+    strides: tuple[int, ...] | None = None,
     *,
     formats: DTypeLike,
     names: str | Sequence[str] | None = None,
diff --git a/numpy/_globals.pyi b/numpy/_globals.pyi
index c6b17d68d6b2..b2231a9636b0 100644
--- a/numpy/_globals.pyi
+++ b/numpy/_globals.pyi
@@ -6,8 +6,10 @@ from typing import Final, final
 @final
 class _CopyMode(enum.Enum):
     ALWAYS = True
-    IF_NEEDED = False
-    NEVER = 2
+    NEVER = False
+    IF_NEEDED = 2
+
+    def __bool__(self, /) -> bool: ...
 
 @final
 class _NoValueType: ...
diff --git a/numpy/ma/core.pyi b/numpy/ma/core.pyi
index 57136fa9d31c..83c0636ce4a7 100644
--- a/numpy/ma/core.pyi
+++ b/numpy/ma/core.pyi
@@ -1,19 +1,13 @@
-from collections.abc import Callable
-from typing import Any, TypeVar
-
-from numpy import (
-    amax,
-    amin,
-    bool_,
-    expand_dims,
-    clip,
-    indices,
-    squeeze,
-    angle,
-    ndarray,
-    dtype,
-    float64,
-)
+# pyright: reportIncompatibleMethodOverride=false
+# ruff: noqa: ANN001, ANN002, ANN003, ANN201, ANN202 ANN204
+
+from typing import Any, SupportsIndex, TypeVar
+
+from _typeshed import Incomplete
+from typing_extensions import deprecated
+
+from numpy import _OrderKACF, amax, amin, bool_, dtype, expand_dims, float64, ndarray
+from numpy._typing import ArrayLike, _DTypeLikeBool
 
 __all__ = [
     "MAError",
@@ -111,8 +105,8 @@ __all__ = [
     "less",
     "less_equal",
     "log",
-    "log10",
     "log2",
+    "log10",
     "logical_and",
     "logical_not",
     "logical_or",
@@ -257,6 +251,7 @@ cosh: _MaskedUnaryOperation
 tanh: _MaskedUnaryOperation
 abs: _MaskedUnaryOperation
 absolute: _MaskedUnaryOperation
+angle: _MaskedUnaryOperation
 fabs: _MaskedUnaryOperation
 negative: _MaskedUnaryOperation
 floor: _MaskedUnaryOperation
@@ -284,20 +279,21 @@ greater_equal: _MaskedBinaryOperation
 less: _MaskedBinaryOperation
 greater: _MaskedBinaryOperation
 logical_and: _MaskedBinaryOperation
-alltrue: _MaskedBinaryOperation
+def alltrue(target: ArrayLike, axis: SupportsIndex | None = 0, dtype: _DTypeLikeBool | None = None) -> Incomplete: ...
 logical_or: _MaskedBinaryOperation
-sometrue: Callable[..., Any]
+def sometrue(target: ArrayLike, axis: SupportsIndex | None = 0, dtype: _DTypeLikeBool | None = None) -> Incomplete: ...
 logical_xor: _MaskedBinaryOperation
 bitwise_and: _MaskedBinaryOperation
 bitwise_or: _MaskedBinaryOperation
 bitwise_xor: _MaskedBinaryOperation
 hypot: _MaskedBinaryOperation
-divide: _MaskedBinaryOperation
-true_divide: _MaskedBinaryOperation
-floor_divide: _MaskedBinaryOperation
-remainder: _MaskedBinaryOperation
-fmod: _MaskedBinaryOperation
-mod: _MaskedBinaryOperation
+
+divide: _DomainedBinaryOperation
+true_divide: _DomainedBinaryOperation
+floor_divide: _DomainedBinaryOperation
+remainder: _DomainedBinaryOperation
+fmod: _DomainedBinaryOperation
+mod: _DomainedBinaryOperation
 
 def make_mask_descr(ndtype): ...
 def getmask(a): ...
@@ -448,10 +444,10 @@ class MaskedArray(ndarray[_ShapeType_co, _DType_co]):
     def var(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
     def std(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
     def round(self, decimals=..., out=...): ...
-    def argsort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
+    def argsort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ...
     def argmin(self, axis=..., fill_value=..., out=..., *, keepdims=...): ...
     def argmax(self, axis=..., fill_value=..., out=..., *, keepdims=...): ...
-    def sort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
+    def sort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ...
     def min(self, axis=..., out=..., fill_value=..., keepdims=...): ...
     # NOTE: deprecated
     # def tostring(self, fill_value=..., order=...): ...
@@ -460,6 +456,7 @@ class MaskedArray(ndarray[_ShapeType_co, _DType_co]):
     def partition(self, *args, **kwargs): ...
     def argpartition(self, *args, **kwargs): ...
     def take(self, indices, axis=..., out=..., mode=...): ...
+
     copy: Any
     diagonal: Any
     flatten: Any
@@ -468,19 +465,26 @@ class MaskedArray(ndarray[_ShapeType_co, _DType_co]):
     swapaxes: Any
     T: Any
     transpose: Any
+
     @property  # type: ignore[misc]
     def mT(self): ...
-    def tolist(self, fill_value=...): ...
-    def tobytes(self, fill_value=..., order=...): ...
-    def tofile(self, fid, sep=..., format=...): ...
-    def toflex(self): ...
-    torecords: Any
+
+    #
+    def toflex(self) -> Incomplete: ...
+    def torecords(self) -> Incomplete: ...
+    def tolist(self, fill_value: Incomplete | None = None) -> Incomplete: ...
+    @deprecated("tostring() is deprecated. Use tobytes() instead.")
+    def tostring(self, /, fill_value: Incomplete | None = None, order: _OrderKACF = "C") -> bytes: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    def tobytes(self, /, fill_value: Incomplete | None = None, order: _OrderKACF = "C") -> bytes: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    def tofile(self, /, fid: Incomplete, sep: str = "", format: str = "%s") -> Incomplete: ...
+
+    #
     def __reduce__(self): ...
     def __deepcopy__(self, memo=...): ...
 
 class mvoid(MaskedArray[_ShapeType_co, _DType_co]):
     def __new__(
-        self,
+        self,  # pyright: ignore[reportSelfClsParameterName]
         data,
         mask=...,
         dtype=...,
@@ -593,8 +597,8 @@ maximum: _extrema_operation
 
 def take(a, indices, axis=..., out=..., mode=...): ...
 def power(a, b, third=...): ...
-def argsort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
-def sort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
+def argsort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ...
+def sort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., *, stable=...): ...
 def compressed(x): ...
 def concatenate(arrays, axis=...): ...
 def diag(v, k=...): ...
@@ -629,19 +633,21 @@ def asanyarray(a, dtype=...): ...
 def fromflex(fxarray): ...
 
 class _convert2ma:
-    __doc__: Any
-    def __init__(self, funcname, params=...): ...
-    def getdoc(self): ...
-    def __call__(self, *args, **params): ...
+    def __init__(self, /, funcname: str, np_ret: str, np_ma_ret: str, params: dict[str, Any] | None = None) -> None: ...
+    def __call__(self, /, *args: object, **params: object) -> Any: ...  # noqa: ANN401
+    def getdoc(self, /, np_ret: str, np_ma_ret: str) -> str | None: ...
 
 arange: _convert2ma
+clip: _convert2ma
 empty: _convert2ma
 empty_like: _convert2ma
 frombuffer: _convert2ma
 fromfunction: _convert2ma
 identity: _convert2ma
+indices: _convert2ma
 ones: _convert2ma
 ones_like: _convert2ma
+squeeze: _convert2ma
 zeros: _convert2ma
 zeros_like: _convert2ma
 
diff --git a/numpy/ma/extras.pyi b/numpy/ma/extras.pyi
index 580309cc679d..ba76f3517526 100644
--- a/numpy/ma/extras.pyi
+++ b/numpy/ma/extras.pyi
@@ -1,9 +1,10 @@
-from typing import Any
+from _typeshed import Incomplete
 
+import numpy as np
 from numpy.lib._function_base_impl import average
 from numpy.lib._index_tricks_impl import AxisConcatenator
 
-from .core import dot, mask_rowcols
+from .core import MaskedArray, dot
 
 __all__ = [
     "apply_along_axis",
@@ -19,8 +20,8 @@ __all__ = [
     "compress_nd",
     "compress_rowcols",
     "compress_rows",
-    "count_masked",
     "corrcoef",
+    "count_masked",
     "cov",
     "diagflat",
     "dot",
@@ -30,9 +31,9 @@ __all__ = [
     "flatnotmasked_edges",
     "hsplit",
     "hstack",
-    "isin",
     "in1d",
     "intersect1d",
+    "isin",
     "mask_cols",
     "mask_rowcols",
     "mask_rows",
@@ -48,8 +49,8 @@ __all__ = [
     "setdiff1d",
     "setxor1d",
     "stack",
-    "unique",
     "union1d",
+    "unique",
     "vander",
     "vstack",
 ]
@@ -59,9 +60,9 @@ def masked_all(shape, dtype = ...): ...
 def masked_all_like(arr): ...
 
 class _fromnxfunction:
-    __name__: Any
-    __doc__: Any
-    def __init__(self, funcname): ...
+    __name__: Incomplete
+    __doc__: Incomplete
+    def __init__(self, funcname) -> None: ...
     def getdoc(self): ...
     def __call__(self, *args, **params): ...
 
@@ -109,13 +110,13 @@ def cov(x, y=..., rowvar=..., bias=..., allow_masked=..., ddof=...): ...
 def corrcoef(x, y=..., rowvar=..., bias = ..., allow_masked=..., ddof = ...): ...
 
 class MAxisConcatenator(AxisConcatenator):
-    concatenate: Any
+    @staticmethod
+    def concatenate(arrays: Incomplete, axis: int = 0) -> Incomplete: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
     @classmethod
-    def makemat(cls, arr): ...
-    def __getitem__(self, key): ...
+    def makemat(cls, arr: Incomplete) -> Incomplete: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleVariableOverride]
 
 class mr_class(MAxisConcatenator):
-    def __init__(self): ...
+    def __init__(self) -> None: ...
 
 mr_: mr_class
 
@@ -128,3 +129,6 @@ def clump_unmasked(a): ...
 def clump_masked(a): ...
 def vander(x, n=...): ...
 def polyfit(x, y, deg, rcond=..., full=..., w=..., cov=...): ...
+
+#
+def mask_rowcols(a: Incomplete, axis: Incomplete | None = None) -> MaskedArray[Incomplete, np.dtype[Incomplete]]: ...
diff --git a/numpy/matlib.pyi b/numpy/matlib.pyi
index cce0bf5b0541..c6a10c6327ef 100644
--- a/numpy/matlib.pyi
+++ b/numpy/matlib.pyi
@@ -70,6 +70,7 @@ from numpy import (
     bitwise_invert,
     bitwise_left_shift,
     bitwise_not,
+    bitwise_or,
     bitwise_right_shift,
     bitwise_xor,
     blackman,
@@ -89,6 +90,7 @@ from numpy import (
     c_,
     can_cast,
     cbrt,
+    cdouble,
     ceil,
     char,
     character,
@@ -160,6 +162,7 @@ from numpy import (
     expand_dims,
     expm1,
     extract,
+    f2py,
     fabs,
     fft,
     fill_diagonal,
@@ -209,6 +212,7 @@ from numpy import (
     greater_equal,
     half,
     hamming,
+    hanning,
     heaviside,
     histogram,
     histogram2d,
@@ -220,6 +224,7 @@ from numpy import (
     i0,
     iinfo,
     imag,
+    in1d,
     index_exp,
     indices,
     inexact,
@@ -425,9 +430,11 @@ from numpy import (
     sort,
     sort_complex,
     spacing,
+    split,
     sqrt,
     square,
     squeeze,
+    stack,
     std,
     str_,
     strings,
@@ -459,6 +466,7 @@ from numpy import (
     trunc,
     typecodes,
     typename,
+    typing,
     ubyte,
     ufunc,
     uint,
diff --git a/numpy/matrixlib/defmatrix.pyi b/numpy/matrixlib/defmatrix.pyi
index 03476555e59e..a6095cc1155a 100644
--- a/numpy/matrixlib/defmatrix.pyi
+++ b/numpy/matrixlib/defmatrix.pyi
@@ -1,10 +1,10 @@
-from collections.abc import Sequence, Mapping
+from collections.abc import Mapping, Sequence
 from typing import Any
 
 from numpy import matrix
 from numpy._typing import ArrayLike, DTypeLike, NDArray
 
-__all__ = ["matrix", "bmat", "asmatrix"]
+__all__ = ["asmatrix", "bmat", "matrix"]
 
 def bmat(
     obj: str | Sequence[ArrayLike] | NDArray[Any],
@@ -12,6 +12,6 @@ def bmat(
     gdict: None | Mapping[str, Any] = ...,
 ) -> matrix[tuple[int, int], Any]: ...
 
-def asmatrix(data: ArrayLike, dtype: DTypeLike = ...) -> matrix[tuple[int, int], Any]: ...
-
-mat = asmatrix
+def asmatrix(
+    data: ArrayLike, dtype: DTypeLike = ...
+) -> matrix[tuple[int, int], Any]: ...
diff --git a/numpy/random/bit_generator.pyi b/numpy/random/bit_generator.pyi
index 8dfbcd9909dd..78fb769683d3 100644
--- a/numpy/random/bit_generator.pyi
+++ b/numpy/random/bit_generator.pyi
@@ -1,128 +1,107 @@
 import abc
-from threading import Lock
 from collections.abc import Callable, Mapping, Sequence
-from typing import (
-    Any,
-    NamedTuple,
-    TypeAlias,
-    TypedDict,
-    TypeVar,
-    overload,
-    Literal,
-    type_check_only,
-)
-
-from numpy import dtype, uint32, uint64
-from numpy._typing import (
-    NDArray,
-    _ArrayLikeInt_co,
-    _ShapeLike,
-    _SupportsDType,
-    _UInt32Codes,
-    _UInt64Codes,
-)
-
-_T = TypeVar("_T")
-
-_DTypeLikeUint32: TypeAlias = (
-    dtype[uint32]
-    | _SupportsDType[dtype[uint32]]
-    | type[uint32]
-    | _UInt32Codes
-)
-_DTypeLikeUint64: TypeAlias = (
-    dtype[uint64]
-    | _SupportsDType[dtype[uint64]]
-    | type[uint64]
-    | _UInt64Codes
-)
+from threading import Lock
+from typing import Any, ClassVar, Literal, NamedTuple, TypeAlias, TypedDict, overload, type_check_only
+
+from _typeshed import Incomplete
+from typing_extensions import CapsuleType, Self
+
+import numpy as np
+from numpy._typing import NDArray, _ArrayLikeInt_co, _DTypeLike, _ShapeLike, _UInt32Codes, _UInt64Codes
+
+__all__ = ["BitGenerator", "SeedSequence"]
+
+###
+
+_DTypeLikeUint_: TypeAlias = _DTypeLike[np.uint32 | np.uint64] | _UInt32Codes | _UInt64Codes
 
 @type_check_only
 class _SeedSeqState(TypedDict):
-    entropy: None | int | Sequence[int]
+    entropy: int | Sequence[int] | None
     spawn_key: tuple[int, ...]
     pool_size: int
     n_children_spawned: int
 
 @type_check_only
 class _Interface(NamedTuple):
-    state_address: Any
-    state: Any
-    next_uint64: Any
-    next_uint32: Any
-    next_double: Any
-    bit_generator: Any
+    state_address: Incomplete
+    state: Incomplete
+    next_uint64: Incomplete
+    next_uint32: Incomplete
+    next_double: Incomplete
+    bit_generator: Incomplete
+
+@type_check_only
+class _CythonMixin:
+    def __setstate_cython__(self, pyx_state: object, /) -> None: ...
+    def __reduce_cython__(self) -> Any: ...  # noqa: ANN401
+
+@type_check_only
+class _GenerateStateMixin(_CythonMixin):
+    def generate_state(self, /, n_words: int, dtype: _DTypeLikeUint_ = ...) -> NDArray[np.uint32 | np.uint64]: ...
+
+###
 
 class ISeedSequence(abc.ABC):
     @abc.abstractmethod
-    def generate_state(
-        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
-    ) -> NDArray[uint32 | uint64]: ...
+    def generate_state(self, /, n_words: int, dtype: _DTypeLikeUint_ = ...) -> NDArray[np.uint32 | np.uint64]: ...
 
-class ISpawnableSeedSequence(ISeedSequence):
+class ISpawnableSeedSequence(ISeedSequence, abc.ABC):
     @abc.abstractmethod
-    def spawn(self: _T, n_children: int) -> list[_T]: ...
+    def spawn(self, /, n_children: int) -> list[Self]: ...
+
+class SeedlessSeedSequence(_GenerateStateMixin, ISpawnableSeedSequence):
+    def spawn(self, /, n_children: int) -> list[Self]: ...
 
-class SeedlessSeedSequence(ISpawnableSeedSequence):
-    def generate_state(
-        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
-    ) -> NDArray[uint32 | uint64]: ...
-    def spawn(self: _T, n_children: int) -> list[_T]: ...
+class SeedSequence(_GenerateStateMixin, ISpawnableSeedSequence):
+    __pyx_vtable__: ClassVar[CapsuleType] = ...
 
-class SeedSequence(ISpawnableSeedSequence):
-    entropy: None | int | Sequence[int]
+    entropy: int | Sequence[int] | None
     spawn_key: tuple[int, ...]
     pool_size: int
     n_children_spawned: int
-    pool: NDArray[uint32]
+    pool: NDArray[np.uint32]
+
     def __init__(
         self,
-        entropy: None | int | Sequence[int] | _ArrayLikeInt_co = ...,
+        /,
+        entropy: _ArrayLikeInt_co | None = None,
         *,
-        spawn_key: Sequence[int] = ...,
-        pool_size: int = ...,
+        spawn_key: Sequence[int] = (),
+        pool_size: int = 4,
         n_children_spawned: int = ...,
     ) -> None: ...
-    def __repr__(self) -> str: ...
+    def spawn(self, /, n_children: int) -> list[Self]: ...
     @property
-    def state(
-        self,
-    ) -> _SeedSeqState: ...
-    def generate_state(
-        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
-    ) -> NDArray[uint32 | uint64]: ...
-    def spawn(self, n_children: int) -> list[SeedSequence]: ...
+    def state(self) -> _SeedSeqState: ...
 
-class BitGenerator(abc.ABC):
+class BitGenerator(_CythonMixin, abc.ABC):
     lock: Lock
-    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
-    def __getstate__(self) -> tuple[dict[str, Any], ISeedSequence]: ...
-    def __setstate__(
-            self, state_seed_seq: dict[str, Any] | tuple[dict[str, Any], ISeedSequence]
-    ) -> None: ...
-    def __reduce__(
-        self,
-    ) -> tuple[
-        Callable[[str], BitGenerator],
-        tuple[str],
-        tuple[dict[str, Any], ISeedSequence]
-    ]: ...
-    @abc.abstractmethod
     @property
     def state(self) -> Mapping[str, Any]: ...
     @state.setter
-    def state(self, value: Mapping[str, Any]) -> None: ...
+    def state(self, value: Mapping[str, Any], /) -> None: ...
     @property
     def seed_seq(self) -> ISeedSequence: ...
-    def spawn(self, n_children: int) -> list[BitGenerator]: ...
-    @overload
-    def random_raw(self, size: None = ..., output: Literal[True] = ...) -> int: ...  # type: ignore[misc]
-    @overload
-    def random_raw(self, size: _ShapeLike = ..., output: Literal[True] = ...) -> NDArray[uint64]: ...  # type: ignore[misc]
-    @overload
-    def random_raw(self, size: None | _ShapeLike = ..., output: Literal[False] = ...) -> None: ...  # type: ignore[misc]
-    def _benchmark(self, cnt: int, method: str = ...) -> None: ...
     @property
     def ctypes(self) -> _Interface: ...
     @property
     def cffi(self) -> _Interface: ...
+    @property
+    def capsule(self) -> CapsuleType: ...
+
+    #
+    def __init__(self, /, seed: _ArrayLikeInt_co | SeedSequence | None = None) -> None: ...
+    def __reduce__(self) -> tuple[Callable[[str], Self], tuple[str], tuple[Mapping[str, Any], ISeedSequence]]: ...
+    def spawn(self, /, n_children: int) -> list[Self]: ...
+    def _benchmark(self, /, cnt: int, method: str = "uint64") -> None: ...
+
+    #
+    @overload
+    def random_raw(self, /, size: None = None, output: Literal[True] = True) -> int: ...
+    @overload
+    def random_raw(self, /, size: _ShapeLike, output: Literal[True] = True) -> NDArray[np.uint64]: ...
+    @overload
+    def random_raw(self, /, size: _ShapeLike | None, output: Literal[False]) -> None: ...
+    @overload
+    def random_raw(self, /, size: _ShapeLike | None = None, *, output: Literal[False]) -> None: ...
diff --git a/numpy/testing/__init__.pyi b/numpy/testing/__init__.pyi
index e47b8f9546c6..ba3c9a2b7a44 100644
--- a/numpy/testing/__init__.pyi
+++ b/numpy/testing/__init__.pyi
@@ -2,97 +2,101 @@ from unittest import TestCase
 
 from . import overrides
 from ._private.utils import (
-    NOGIL_BUILD,
-    IS_WASM,
+    HAS_LAPACK64,
+    HAS_REFCOUNT,
+    IS_EDITABLE,
+    IS_INSTALLED,
+    IS_MUSL,
     IS_PYPY,
     IS_PYSTON,
-    IS_MUSL,
-    IS_EDITABLE,
-    HAS_REFCOUNT,
-    HAS_LAPACK64,
-    assert_equal,
+    IS_WASM,
+    NOGIL_BUILD,
+    NUMPY_ROOT,
+    IgnoreException,
+    KnownFailureException,
+    SkipTest,
+    assert_,
+    assert_allclose,
     assert_almost_equal,
     assert_approx_equal,
+    assert_array_almost_equal,
+    assert_array_almost_equal_nulp,
+    assert_array_compare,
     assert_array_equal,
     assert_array_less,
-    assert_string_equal,
-    assert_array_almost_equal,
+    assert_array_max_ulp,
+    assert_equal,
+    assert_no_gc_cycles,
+    assert_no_warnings,
     assert_raises,
+    assert_raises_regex,
+    assert_string_equal,
+    assert_warns,
+    break_cycles,
     build_err_msg,
+    check_support_sve,
+    clear_and_catch_warnings,
     decorate_methods,
     jiffies,
+    measure,
     memusage,
     print_assert_equal,
+    run_threaded,
     rundocs,
     runstring,
-    verbose,
-    measure,
-    assert_,
-    assert_array_almost_equal_nulp,
-    assert_raises_regex,
-    assert_array_max_ulp,
-    assert_warns,
-    assert_no_warnings,
-    assert_allclose,
-    IgnoreException,
-    clear_and_catch_warnings,
-    SkipTest,
-    KnownFailureException,
-    temppath,
-    tempdir,
     suppress_warnings,
-    assert_array_compare,
-    assert_no_gc_cycles,
-    break_cycles,
-    check_support_sve,
-    run_threaded,
+    tempdir,
+    temppath,
+    verbose,
 )
 
 __all__ = [
-    "assert_equal",
+    "HAS_LAPACK64",
+    "HAS_REFCOUNT",
+    "IS_EDITABLE",
+    "IS_INSTALLED",
+    "IS_MUSL",
+    "IS_PYPY",
+    "IS_PYSTON",
+    "IS_WASM",
+    "NOGIL_BUILD",
+    "NUMPY_ROOT",
+    "IgnoreException",
+    "KnownFailureException",
+    "SkipTest",
+    "TestCase",
+    "assert_",
+    "assert_allclose",
     "assert_almost_equal",
     "assert_approx_equal",
+    "assert_array_almost_equal",
+    "assert_array_almost_equal_nulp",
+    "assert_array_compare",
     "assert_array_equal",
     "assert_array_less",
-    "assert_string_equal",
-    "assert_array_almost_equal",
+    "assert_array_max_ulp",
+    "assert_equal",
+    "assert_no_gc_cycles",
+    "assert_no_warnings",
     "assert_raises",
+    "assert_raises_regex",
+    "assert_string_equal",
+    "assert_warns",
+    "break_cycles",
     "build_err_msg",
+    "check_support_sve",
+    "clear_and_catch_warnings",
     "decorate_methods",
     "jiffies",
+    "measure",
     "memusage",
+    "overrides",
     "print_assert_equal",
+    "run_threaded",
     "rundocs",
     "runstring",
-    "verbose",
-    "measure",
-    "assert_",
-    "assert_array_almost_equal_nulp",
-    "assert_raises_regex",
-    "assert_array_max_ulp",
-    "assert_warns",
-    "assert_no_warnings",
-    "assert_allclose",
-    "IgnoreException",
-    "clear_and_catch_warnings",
-    "SkipTest",
-    "KnownFailureException",
-    "temppath",
-    "tempdir",
-    "IS_PYPY",
-    "HAS_REFCOUNT",
-    "IS_WASM",
     "suppress_warnings",
-    "assert_array_compare",
-    "assert_no_gc_cycles",
-    "break_cycles",
-    "HAS_LAPACK64",
-    "IS_PYSTON",
-    "IS_MUSL",
-    "check_support_sve",
-    "NOGIL_BUILD",
-    "IS_EDITABLE",
-    "run_threaded",
-    "TestCase",
-    "overrides",
+    "tempdir",
+    "temppath",
+    "verbose",
 ]
diff --git a/numpy/testing/_private/utils.pyi b/numpy/testing/_private/utils.pyi
index b2f4045c7703..75ea45d3a721 100644
--- a/numpy/testing/_private/utils.pyi
+++ b/numpy/testing/_private/utils.pyi
@@ -1,42 +1,42 @@
-import sys
 import ast
+import sys
 import types
-import warnings
 import unittest
-from _typeshed import GenericPath, StrOrBytesPath, StrPath
+import warnings
 from collections.abc import Callable, Iterable, Sequence
 from contextlib import _GeneratorContextManager
+from pathlib import Path
 from re import Pattern
 from typing import (
-    Literal as L,
     Any,
     AnyStr,
     ClassVar,
+    Final,
+    Generic,
     NoReturn,
+    SupportsIndex,
     TypeAlias,
     overload,
     type_check_only,
-    TypeVar,
-    Final,
-    SupportsIndex,
-    ParamSpec
 )
+from typing import Literal as L
+from unittest.case import SkipTest
+
+from _typeshed import ConvertibleToFloat, GenericPath, StrOrBytesPath, StrPath
+from typing_extensions import ParamSpec, Self, TypeVar, TypeVarTuple, Unpack
 
 import numpy as np
-from numpy import number, object_, _ConvertibleToFloat
 from numpy._typing import (
-    NDArray,
     ArrayLike,
     DTypeLike,
+    NDArray,
+    _ArrayLikeDT64_co,
     _ArrayLikeNumber_co,
     _ArrayLikeObject_co,
     _ArrayLikeTD64_co,
-    _ArrayLikeDT64_co,
 )
 
-from unittest.case import SkipTest
-
-__all__ = [
+__all__ = [  # noqa: RUF022
     "IS_EDITABLE",
     "IS_MUSL",
     "IS_PYPY",
@@ -83,58 +83,33 @@ __all__ = [
     "run_threaded",
 ]
 
-_P = ParamSpec("_P")
+###
+
 _T = TypeVar("_T")
-_ET = TypeVar("_ET", bound=BaseException)
+_Ts = TypeVarTuple("_Ts")
+_Tss = ParamSpec("_Tss")
+_ET = TypeVar("_ET", bound=BaseException, default=BaseException)
 _FT = TypeVar("_FT", bound=Callable[..., Any])
+_W_co = TypeVar("_W_co", bound=_WarnLog | None, default=_WarnLog | None, covariant=True)
+_T_or_bool = TypeVar("_T_or_bool", default=bool)
+
+_StrLike: TypeAlias = str | bytes
+_RegexLike: TypeAlias = _StrLike | Pattern[Any]
+_NumericArrayLike: TypeAlias = _ArrayLikeNumber_co | _ArrayLikeObject_co
 
-# Must return a bool or an ndarray/generic type
-# that is supported by `np.logical_and.reduce`
+_ExceptionSpec: TypeAlias = type[_ET] | tuple[type[_ET], ...]
+_WarningSpec: TypeAlias = type[Warning]
+_WarnLog: TypeAlias = list[warnings.WarningMessage]
+_ToModules: TypeAlias = Iterable[types.ModuleType]
+
+# Must return a bool or an ndarray/generic type that is supported by `np.logical_and.reduce`
 _ComparisonFunc: TypeAlias = Callable[
     [NDArray[Any], NDArray[Any]],
-    (
-        bool
-        | np.bool
-        | number[Any]
-        | NDArray[np.bool | number[Any] | object_]
-    )
+    bool | np.bool | np.number | NDArray[np.bool | np.number | np.object_],
 ]
 
-class KnownFailureException(Exception): ...
-class IgnoreException(Exception): ...
-
-class clear_and_catch_warnings(warnings.catch_warnings[list[warnings.WarningMessage]]):
-    class_modules: ClassVar[tuple[types.ModuleType, ...]]
-    modules: set[types.ModuleType]
-    @overload
-    def __new__(
-        cls,
-        record: L[False] = ...,
-        modules: Iterable[types.ModuleType] = ...,
-    ) -> _clear_and_catch_warnings_without_records: ...
-    @overload
-    def __new__(
-        cls,
-        record: L[True],
-        modules: Iterable[types.ModuleType] = ...,
-    ) -> _clear_and_catch_warnings_with_records: ...
-    @overload
-    def __new__(
-        cls,
-        record: bool,
-        modules: Iterable[types.ModuleType] = ...,
-    ) -> clear_and_catch_warnings: ...
-    def __enter__(self) -> None | list[warnings.WarningMessage]: ...
-    def __exit__(
-        self,
-        __exc_type: None | type[BaseException] = ...,
-        __exc_val: None | BaseException = ...,
-        __exc_tb: None | types.TracebackType = ...,
-    ) -> None: ...
-
 # Type-check only `clear_and_catch_warnings` subclasses for both values of the
 # `record` parameter. Copied from the stdlib `warnings` stubs.
-
 @type_check_only
 class _clear_and_catch_warnings_with_records(clear_and_catch_warnings):
     def __enter__(self) -> list[warnings.WarningMessage]: ...
@@ -143,321 +118,379 @@ class _clear_and_catch_warnings_with_records(clear_and_catch_warnings):
 class _clear_and_catch_warnings_without_records(clear_and_catch_warnings):
     def __enter__(self) -> None: ...
 
+###
+
+verbose: int = 0
+NUMPY_ROOT: Final[Path] = ...
+IS_INSTALLED: Final[bool] = ...
+IS_EDITABLE: Final[bool] = ...
+IS_MUSL: Final[bool] = ...
+IS_PYPY: Final[bool] = ...
+IS_PYSTON: Final[bool] = ...
+IS_WASM: Final[bool] = ...
+HAS_REFCOUNT: Final[bool] = ...
+HAS_LAPACK64: Final[bool] = ...
+NOGIL_BUILD: Final[bool] = ...
+
+class KnownFailureException(Exception): ...
+class IgnoreException(Exception): ...
+
+# NOTE: `warnings.catch_warnings` is incorrectly defined as invariant in typeshed
+class clear_and_catch_warnings(warnings.catch_warnings[_W_co], Generic[_W_co]):  # type: ignore[type-var]  # pyright: ignore[reportInvalidTypeArguments]
+    class_modules: ClassVar[tuple[types.ModuleType, ...]] = ()
+    modules: Final[set[types.ModuleType]]
+    @overload  # record: True
+    def __init__(self: clear_and_catch_warnings[_WarnLog], /, record: L[True], modules: _ToModules = ()) -> None: ...
+    @overload  # record: False (default)
+    def __init__(self: clear_and_catch_warnings[None], /, record: L[False] = False, modules: _ToModules = ()) -> None: ...
+    @overload  # record; bool
+    def __init__(self, /, record: bool, modules: _ToModules = ()) -> None: ...
+
 class suppress_warnings:
-    log: list[warnings.WarningMessage]
-    def __init__(
-        self,
-        forwarding_rule: L["always", "module", "once", "location"] = ...,
-    ) -> None: ...
-    def filter(
-        self,
-        category: type[Warning] = ...,
-        message: str = ...,
-        module: None | types.ModuleType = ...,
-    ) -> None: ...
-    def record(
-        self,
-        category: type[Warning] = ...,
-        message: str = ...,
-        module: None | types.ModuleType = ...,
-    ) -> list[warnings.WarningMessage]: ...
-    def __enter__(self: _T) -> _T: ...
-    def __exit__(
-        self,
-        __exc_type: None | type[BaseException] = ...,
-        __exc_val: None | BaseException = ...,
-        __exc_tb: None | types.TracebackType = ...,
-    ) -> None: ...
-    def __call__(self, func: _FT) -> _FT: ...
-
-verbose: int
-IS_EDITABLE: Final[bool]
-IS_MUSL: Final[bool]
-IS_PYPY: Final[bool]
-IS_PYSTON: Final[bool]
-IS_WASM: Final[bool]
-HAS_REFCOUNT: Final[bool]
-HAS_LAPACK64: Final[bool]
-NOGIL_BUILD: Final[bool]
-
-def assert_(val: object, msg: str | Callable[[], str] = ...) -> None: ...
+    log: Final[_WarnLog]
+    def __init__(self, /, forwarding_rule: L["always", "module", "once", "location"] = "always") -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, cls: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None, /) -> None: ...
+    def __call__(self, /, func: _FT) -> _FT: ...
+
+    #
+    def filter(self, /, category: type[Warning] = ..., message: str = "", module: types.ModuleType | None = None) -> None: ...
+    def record(self, /, category: type[Warning] = ..., message: str = "", module: types.ModuleType | None = None) -> _WarnLog: ...
 
 # Contrary to runtime we can't do `os.name` checks while type checking,
 # only `sys.platform` checks
 if sys.platform == "win32" or sys.platform == "cygwin":
     def memusage(processName: str = ..., instance: int = ...) -> int: ...
 elif sys.platform == "linux":
-    def memusage(_proc_pid_stat: StrOrBytesPath = ...) -> None | int: ...
+    def memusage(_proc_pid_stat: StrOrBytesPath = ...) -> int | None: ...
 else:
     def memusage() -> NoReturn: ...
 
 if sys.platform == "linux":
-    def jiffies(
-        _proc_pid_stat: StrOrBytesPath = ...,
-        _load_time: list[float] = ...,
-    ) -> int: ...
+    def jiffies(_proc_pid_stat: StrOrBytesPath = ..., _load_time: list[float] = []) -> int: ...
 else:
-    def jiffies(_load_time: list[float] = ...) -> int: ...
+    def jiffies(_load_time: list[float] = []) -> int: ...
 
+#
 def build_err_msg(
     arrays: Iterable[object],
-    err_msg: str,
+    err_msg: object,
     header: str = ...,
     verbose: bool = ...,
     names: Sequence[str] = ...,
-    precision: None | SupportsIndex = ...,
+    precision: SupportsIndex | None = ...,
 ) -> str: ...
 
+#
+def print_assert_equal(test_string: str, actual: object, desired: object) -> None: ...
+
+#
+def assert_(val: object, msg: str | Callable[[], str] = "") -> None: ...
+
+#
 def assert_equal(
     actual: object,
     desired: object,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    err_msg: object = "",
+    verbose: bool = True,
     *,
-    strict: bool = ...
-) -> None: ...
-
-def print_assert_equal(
-    test_string: str,
-    actual: object,
-    desired: object,
+    strict: bool = False,
 ) -> None: ...
 
 def assert_almost_equal(
-    actual: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    desired: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    decimal: int = ...,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    actual: _NumericArrayLike,
+    desired: _NumericArrayLike,
+    decimal: int = 7,
+    err_msg: object = "",
+    verbose: bool = True,
 ) -> None: ...
 
-# Anything that can be coerced into `builtins.float`
+#
 def assert_approx_equal(
-    actual: _ConvertibleToFloat,
-    desired: _ConvertibleToFloat,
-    significant: int = ...,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    actual: ConvertibleToFloat,
+    desired: ConvertibleToFloat,
+    significant: int = 7,
+    err_msg: object = "",
+    verbose: bool = True,
 ) -> None: ...
 
+#
 def assert_array_compare(
     comparison: _ComparisonFunc,
     x: ArrayLike,
     y: ArrayLike,
-    err_msg: object = ...,
-    verbose: bool = ...,
-    header: str = ...,
-    precision: SupportsIndex = ...,
-    equal_nan: bool = ...,
-    equal_inf: bool = ...,
+    err_msg: object = "",
+    verbose: bool = True,
+    header: str = "",
+    precision: SupportsIndex = 6,
+    equal_nan: bool = True,
+    equal_inf: bool = True,
     *,
-    strict: bool = ...
+    strict: bool = False,
+    names: tuple[str, str] = ("ACTUAL", "DESIRED"),
 ) -> None: ...
 
+#
 def assert_array_equal(
-    x: ArrayLike,
-    y: ArrayLike,
-    /,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    actual: object,
+    desired: object,
+    err_msg: object = "",
+    verbose: bool = True,
     *,
-    strict: bool = ...
+    strict: bool = False,
 ) -> None: ...
 
+#
 def assert_array_almost_equal(
-    x: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    y: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    /,
-    decimal: float = ...,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    actual: _NumericArrayLike,
+    desired: _NumericArrayLike,
+    decimal: float = 6,
+    err_msg: object = "",
+    verbose: bool = True,
 ) -> None: ...
 
 @overload
 def assert_array_less(
-    x: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    y: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    x: _ArrayLikeDT64_co,
+    y: _ArrayLikeDT64_co,
+    err_msg: object = "",
+    verbose: bool = True,
     *,
-    strict: bool = ...
+    strict: bool = False,
 ) -> None: ...
 @overload
 def assert_array_less(
     x: _ArrayLikeTD64_co,
     y: _ArrayLikeTD64_co,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    err_msg: object = "",
+    verbose: bool = True,
     *,
-    strict: bool = ...
+    strict: bool = False,
 ) -> None: ...
 @overload
 def assert_array_less(
-    x: _ArrayLikeDT64_co,
-    y: _ArrayLikeDT64_co,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    x: _NumericArrayLike,
+    y: _NumericArrayLike,
+    err_msg: object = "",
+    verbose: bool = True,
     *,
-    strict: bool = ...
+    strict: bool = False,
 ) -> None: ...
 
-def runstring(
-    astr: str | bytes | types.CodeType,
-    dict: None | dict[str, Any],
-) -> Any: ...
-
+#
 def assert_string_equal(actual: str, desired: str) -> None: ...
 
-def rundocs(
-    filename: StrPath | None = ...,
-    raise_on_error: bool = ...,
-) -> None: ...
-
-def check_support_sve(__cache: list[_T]) -> _T: ...
-
-def raises(*args: type[BaseException]) -> Callable[[_FT], _FT]: ...
-
-@overload
-def assert_raises(  # type: ignore
-    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
-    callable: Callable[_P, Any],
-    /,
-    *args: _P.args,
-    **kwargs: _P.kwargs,
-) -> None: ...
+#
 @overload
 def assert_raises(
-    expected_exception: type[_ET] | tuple[type[_ET], ...],
+    exception_class: _ExceptionSpec[_ET],
+    /,
     *,
-    msg: None | str = ...,
+    msg: str | None = None,
 ) -> unittest.case._AssertRaisesContext[_ET]: ...
-
 @overload
-def assert_raises_regex(
-    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
-    expected_regex: str | bytes | Pattern[Any],
-    callable: Callable[_P, Any],
+def assert_raises(
+    exception_class: _ExceptionSpec,
+    callable: Callable[_Tss, Any],
     /,
-    *args: _P.args,
-    **kwargs: _P.kwargs,
+    *args: _Tss.args,
+    **kwargs: _Tss.kwargs,
 ) -> None: ...
+
+#
 @overload
 def assert_raises_regex(
-    expected_exception: type[_ET] | tuple[type[_ET], ...],
-    expected_regex: str | bytes | Pattern[Any],
+    exception_class: _ExceptionSpec[_ET],
+    expected_regexp: _RegexLike,
     *,
-    msg: None | str = ...,
+    msg: str | None = None,
 ) -> unittest.case._AssertRaisesContext[_ET]: ...
-
-def decorate_methods(
-    cls: type[Any],
-    decorator: Callable[[Callable[..., Any]], Any],
-    testmatch: None | str | bytes | Pattern[Any] = ...,
+@overload
+def assert_raises_regex(
+    exception_class: _ExceptionSpec,
+    expected_regexp: _RegexLike,
+    callable: Callable[_Tss, Any],
+    *args: _Tss.args,
+    **kwargs: _Tss.kwargs,
 ) -> None: ...
 
-def measure(
-    code_str: str | bytes | ast.mod | ast.AST,
-    times: int = ...,
-    label: None | str = ...,
-) -> float: ...
-
+#
 @overload
 def assert_allclose(
-    actual: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    desired: _ArrayLikeNumber_co | _ArrayLikeObject_co,
-    rtol: float = ...,
-    atol: float = ...,
-    equal_nan: bool = ...,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    actual: _ArrayLikeTD64_co,
+    desired: _ArrayLikeTD64_co,
+    rtol: float = 1e-7,
+    atol: float = 0,
+    equal_nan: bool = True,
+    err_msg: object = "",
+    verbose: bool = True,
     *,
-    strict: bool = ...
+    strict: bool = False,
 ) -> None: ...
 @overload
 def assert_allclose(
-    actual: _ArrayLikeTD64_co,
-    desired: _ArrayLikeTD64_co,
-    rtol: float = ...,
-    atol: float = ...,
-    equal_nan: bool = ...,
-    err_msg: object = ...,
-    verbose: bool = ...,
+    actual: _NumericArrayLike,
+    desired: _NumericArrayLike,
+    rtol: float = 1e-7,
+    atol: float = 0,
+    equal_nan: bool = True,
+    err_msg: object = "",
+    verbose: bool = True,
     *,
-    strict: bool = ...
+    strict: bool = False,
 ) -> None: ...
 
+#
 def assert_array_almost_equal_nulp(
     x: _ArrayLikeNumber_co,
     y: _ArrayLikeNumber_co,
-    nulp: float = ...,
+    nulp: float = 1,
 ) -> None: ...
 
+#
 def assert_array_max_ulp(
     a: _ArrayLikeNumber_co,
     b: _ArrayLikeNumber_co,
-    maxulp: float = ...,
-    dtype: DTypeLike = ...,
+    maxulp: float = 1,
+    dtype: DTypeLike | None = None,
 ) -> NDArray[Any]: ...
 
+#
 @overload
-def assert_warns(warning_class: type[Warning]) -> _GeneratorContextManager[None]: ...
+def assert_warns(warning_class: _WarningSpec) -> _GeneratorContextManager[None]: ...
 @overload
-def assert_warns(
-    warning_class: type[Warning],
-    func: Callable[_P, _T],
-    /,
-    *args: _P.args,
-    **kwargs: _P.kwargs,
-) -> _T: ...
+def assert_warns(warning_class: _WarningSpec, func: Callable[_Tss, _T], *args: _Tss.args, **kwargs: _Tss.kwargs) -> _T: ...
 
+#
 @overload
 def assert_no_warnings() -> _GeneratorContextManager[None]: ...
 @overload
-def assert_no_warnings(
-    func: Callable[_P, _T],
-    /,
-    *args: _P.args,
-    **kwargs: _P.kwargs,
-) -> _T: ...
+def assert_no_warnings(func: Callable[_Tss, _T], /, *args: _Tss.args, **kwargs: _Tss.kwargs) -> _T: ...
 
+#
+@overload
+def assert_no_gc_cycles() -> _GeneratorContextManager[None]: ...
+@overload
+def assert_no_gc_cycles(func: Callable[_Tss, Any], /, *args: _Tss.args, **kwargs: _Tss.kwargs) -> None: ...
+
+###
+
+#
 @overload
 def tempdir(
-    suffix: None = ...,
-    prefix: None = ...,
-    dir: None = ...,
+    suffix: None = None,
+    prefix: None = None,
+    dir: None = None,
 ) -> _GeneratorContextManager[str]: ...
 @overload
 def tempdir(
-    suffix: AnyStr | None = ...,
-    prefix: AnyStr | None = ...,
-    dir: GenericPath[AnyStr] | None = ...,
+    suffix: AnyStr | None = None,
+    prefix: AnyStr | None = None,
+    *,
+    dir: GenericPath[AnyStr],
+) -> _GeneratorContextManager[AnyStr]: ...
+@overload
+def tempdir(
+    suffix: AnyStr | None = None,
+    *,
+    prefix: AnyStr,
+    dir: GenericPath[AnyStr] | None = None,
+) -> _GeneratorContextManager[AnyStr]: ...
+@overload
+def tempdir(
+    suffix: AnyStr,
+    prefix: AnyStr | None = None,
+    dir: GenericPath[AnyStr] | None = None,
 ) -> _GeneratorContextManager[AnyStr]: ...
 
+#
 @overload
 def temppath(
-    suffix: None = ...,
-    prefix: None = ...,
-    dir: None = ...,
-    text: bool = ...,
+    suffix: None = None,
+    prefix: None = None,
+    dir: None = None,
+    text: bool = False,
 ) -> _GeneratorContextManager[str]: ...
 @overload
 def temppath(
-    suffix: AnyStr | None = ...,
-    prefix: AnyStr | None = ...,
-    dir: GenericPath[AnyStr] | None = ...,
-    text: bool = ...,
+    suffix: AnyStr | None,
+    prefix: AnyStr | None,
+    dir: GenericPath[AnyStr],
+    text: bool = False,
+) -> _GeneratorContextManager[AnyStr]: ...
+@overload
+def temppath(
+    suffix: AnyStr | None = None,
+    prefix: AnyStr | None = None,
+    *,
+    dir: GenericPath[AnyStr],
+    text: bool = False,
+) -> _GeneratorContextManager[AnyStr]: ...
+@overload
+def temppath(
+    suffix: AnyStr | None,
+    prefix: AnyStr,
+    dir: GenericPath[AnyStr] | None = None,
+    text: bool = False,
+) -> _GeneratorContextManager[AnyStr]: ...
+@overload
+def temppath(
+    suffix: AnyStr | None = None,
+    *,
+    prefix: AnyStr,
+    dir: GenericPath[AnyStr] | None = None,
+    text: bool = False,
+) -> _GeneratorContextManager[AnyStr]: ...
+@overload
+def temppath(
+    suffix: AnyStr,
+    prefix: AnyStr | None = None,
+    dir: GenericPath[AnyStr] | None = None,
+    text: bool = False,
 ) -> _GeneratorContextManager[AnyStr]: ...
 
+#
+def check_support_sve(__cache: list[_T_or_bool] = []) -> _T_or_bool: ...  # noqa: PYI063
+
+#
+def decorate_methods(
+    cls: type,
+    decorator: Callable[[Callable[..., Any]], Any],
+    testmatch: _RegexLike | None = None,
+) -> None: ...
+
+#
 @overload
-def assert_no_gc_cycles() -> _GeneratorContextManager[None]: ...
+def run_threaded(
+    func: Callable[[], None],
+    max_workers: int = 8,
+    pass_count: bool = False,
+    pass_barrier: bool = False,
+    outer_iterations: int = 1,
+    prepare_args: None = None,
+) -> None: ...
 @overload
-def assert_no_gc_cycles(
-    func: Callable[_P, Any],
-    /,
-    *args: _P.args,
-    **kwargs: _P.kwargs,
+def run_threaded(
+    func: Callable[[Unpack[_Ts]], None],
+    max_workers: int,
+    pass_count: bool,
+    pass_barrier: bool,
+    outer_iterations: int,
+    prepare_args: tuple[Unpack[_Ts]],
+) -> None: ...
+@overload
+def run_threaded(
+    func: Callable[[Unpack[_Ts]], None],
+    max_workers: int = 8,
+    pass_count: bool = False,
+    pass_barrier: bool = False,
+    outer_iterations: int = 1,
+    *,
+    prepare_args: tuple[Unpack[_Ts]],
 ) -> None: ...
 
+#
+def runstring(astr: _StrLike | types.CodeType, dict: dict[str, Any] | None) -> Any: ...  # noqa: ANN401
+def rundocs(filename: StrPath | None = None, raise_on_error: bool = True) -> None: ...
+def measure(code_str: _StrLike | ast.AST, times: int = 1, label: str | None = None) -> float: ...
 def break_cycles() -> None: ...
-
-def run_threaded(func: Callable[[], None], iters: int, pass_count: bool = False) -> None: ...
diff --git a/numpy/typing/tests/data/fail/ndarray_misc.pyi b/numpy/typing/tests/data/fail/ndarray_misc.pyi
index 674b378829a0..489aefca7ffc 100644
--- a/numpy/typing/tests/data/fail/ndarray_misc.pyi
+++ b/numpy/typing/tests/data/fail/ndarray_misc.pyi
@@ -16,11 +16,6 @@ AR_b: npt.NDArray[np.bool]
 
 ctypes_obj = AR_f8.ctypes
 
-reveal_type(ctypes_obj.get_data())  # E: has no attribute
-reveal_type(ctypes_obj.get_shape())  # E: has no attribute
-reveal_type(ctypes_obj.get_strides())  # E: has no attribute
-reveal_type(ctypes_obj.get_as_parameter())  # E: has no attribute
-
 f8.argpartition(0)  # E: has no attribute
 f8.diagonal()  # E: has no attribute
 f8.dot(1)  # E: has no attribute
@@ -31,8 +26,6 @@ f8.setfield(2, np.float64)  # E: has no attribute
 f8.sort()  # E: has no attribute
 f8.trace()  # E: has no attribute
 
-AR_M.__int__()  # E: Invalid self argument
-AR_M.__float__()  # E: Invalid self argument
 AR_M.__complex__()  # E: Invalid self argument
 AR_b.__index__()  # E: Invalid self argument
 
diff --git a/numpy/typing/tests/data/fail/testing.pyi b/numpy/typing/tests/data/fail/testing.pyi
index 953670180203..f7eaa7d20836 100644
--- a/numpy/typing/tests/data/fail/testing.pyi
+++ b/numpy/typing/tests/data/fail/testing.pyi
@@ -3,7 +3,7 @@ import numpy.typing as npt
 
 AR_U: npt.NDArray[np.str_]
 
-def func() -> bool: ...
+def func(x: object) -> bool: ...
 
 np.testing.assert_(True, msg=1)  # E: incompatible type
 np.testing.build_err_msg(1, "test")  # E: incompatible type
@@ -20,9 +20,9 @@ np.testing.assert_allclose(AR_U, AR_U)  # E: incompatible type
 np.testing.assert_array_almost_equal_nulp(AR_U, AR_U)  # E: incompatible type
 np.testing.assert_array_max_ulp(AR_U, AR_U)  # E: incompatible type
 
-np.testing.assert_warns(warning_class=RuntimeWarning, func=func)  # E: No overload variant
+np.testing.assert_warns(RuntimeWarning, func)  # E: No overload variant
 np.testing.assert_no_warnings(func=func)  # E: No overload variant
-np.testing.assert_no_warnings(func, None)  # E: Too many arguments
-np.testing.assert_no_warnings(func, test=None)  # E: No overload variant
+np.testing.assert_no_warnings(func)  # E: Too many arguments
+np.testing.assert_no_warnings(func, y=None)  # E: No overload variant
 
 np.testing.assert_no_gc_cycles(func=func)  # E: No overload variant
diff --git a/numpy/typing/tests/data/pass/ndarray_misc.py b/numpy/typing/tests/data/pass/ndarray_misc.py
index fef9d519b78b..758626e18dd6 100644
--- a/numpy/typing/tests/data/pass/ndarray_misc.py
+++ b/numpy/typing/tests/data/pass/ndarray_misc.py
@@ -24,6 +24,8 @@ class SubClass(npt.NDArray[np.float64]): ...
 C: np.ndarray[Any, np.dtype[np.int32]] = np.array([0, 1, 2], dtype=np.int32)
 D = np.ones(3).view(SubClass)
 
+ctypes_obj = A.ctypes
+
 i4.all()
 A.all()
 A.all(axis=0)
@@ -181,3 +183,14 @@ class SubClass(npt.NDArray[np.float64]): ...
 A_void: npt.NDArray[np.void] = np.empty(3, [("yop", float), ("yap", float)])
 A_void["yop"] = A_float[:, 0]
 A_void["yap"] = A_float[:, 1]
+
+# deprecated
+
+with np.testing.assert_warns(DeprecationWarning):
+    ctypes_obj.get_data()  # pyright: ignore[reportDeprecated]
+with np.testing.assert_warns(DeprecationWarning):
+    ctypes_obj.get_shape()  # pyright: ignore[reportDeprecated]
+with np.testing.assert_warns(DeprecationWarning):
+    ctypes_obj.get_strides()  # pyright: ignore[reportDeprecated]
+with np.testing.assert_warns(DeprecationWarning):
+    ctypes_obj.get_as_parameter()  # pyright: ignore[reportDeprecated]
diff --git a/numpy/typing/tests/data/reveal/testing.pyi b/numpy/typing/tests/data/reveal/testing.pyi
index 5301090a5f4b..741c71f62a5b 100644
--- a/numpy/typing/tests/data/reveal/testing.pyi
+++ b/numpy/typing/tests/data/reveal/testing.pyi
@@ -32,15 +32,15 @@ assert_type(np.testing.IgnoreException(), np.testing.IgnoreException)
 
 assert_type(
     np.testing.clear_and_catch_warnings(modules=[np.testing]),
-    np.testing._private.utils._clear_and_catch_warnings_without_records,
+    np.testing.clear_and_catch_warnings[None],
 )
 assert_type(
     np.testing.clear_and_catch_warnings(True),
-    np.testing._private.utils._clear_and_catch_warnings_with_records,
+    np.testing.clear_and_catch_warnings[list[warnings.WarningMessage]],
 )
 assert_type(
     np.testing.clear_and_catch_warnings(False),
-    np.testing._private.utils._clear_and_catch_warnings_without_records,
+    np.testing.clear_and_catch_warnings[None],
 )
 assert_type(
     np.testing.clear_and_catch_warnings(bool_obj),