diff --git a/.mypyignore b/.mypyignore
index 34f3d08f..1e4ef84c 100644
--- a/.mypyignore
+++ b/.mypyignore
@@ -39,63 +39,63 @@ scipy\.special\._support_alternative_backends\..*
 scipy\.stats\._qmvnt\.phi(nv)?
 
 # https://github.com/KotlinIsland/basedmypy/issues/815
-scipy.special.agm
-scipy.special.be(i|r)p?
-scipy.special.besselpoly
-scipy.special.(log_)?wright_bessel
-scipy.special.beta(ln|incc?(inv)?)?
-scipy.special.binom
-scipy.special.poch
-scipy.special.(inv_)?boxcox(1p)?
-scipy.special.cbrt(r(c|iv?)?)?
-scipy.special.co(s|t)dg
-scipy.special.(cos|pow)m1
-scipy.special.ellip((e|k)(inc)?|km1|rc)
-scipy.special.erf(c(inv|x)?|i(nv)?)?
-scipy.special.eval_(cheby(c|s|t|u)|hermite(norm)?|laguerre|legendre)
-scipy.special.eval_sh_(cheby(t|u)|legendre)
-scipy.special.exp(10?|2|i|it|m1|n|rel)
-scipy.special.xlog(1p)?y
-scipy.special.(di|log|r)?gamma
-scipy.special.gamma(incc?(inv)?|ln|sgn)?
-scipy.special.(pseudo_)?huber
-scipy.special.hyp(0f1|eru)
-scipy.special.(i|k)(0|1|v)e?
-scipy.special.(mod)?struve
-scipy.special.it(2|mod)?struve0
-scipy.special.(j|y)(0|1|n|ve?)
-scipy.special.k(e(i|r)p?|n)
-scipy.special.(rel_)?entr
-scipy.special.kl_div
-scipy.special.kolmog(i|orov)
-scipy.special.log(_(expit|ndtr)|1p|it)
-scipy.special.lpmv
-scipy.special.mathieu_(a|b)
-scipy.special.(obl|pro)_cv
-scipy.special.owens_t
-scipy.special.psi
-scipy.special.radian
-scipy.special.round
-scipy.special.sindg
-scipy.special.smirnovi?
-scipy.special.spence
-scipy.special.tandg
-scipy.special.tklmbda
-scipy.special.voigt_profile
-scipy.special.dawsn
-scipy.special.wofz
-scipy.special.wrightomega
-scipy.special.zetac
-scipy.special.bdtr(c|i(k|n)?)?
-scipy.special.btdtri(a|b)
-scipy.special.chdtr(c|iv?)?
-scipy.special.chndtr(i(df|nc|x))?
-scipy.special.fdtr(c|i(dfd)?)?
-scipy.special.gdtr(c|i(a|b|x))?
-scipy.special.nbdtr(c|i(k|n)?)?
-scipy.special.ncfdtr(i((nc)?|df(d|n)))?
-scipy.special.nctdtr(i(df|nc|t))?
-scipy.special.ndtr(i(_exp)?)?
-scipy.special.nrdtri(mn|sd)
-scipy.special.pdtr(c|ik?)?
-scipy.special.stdtr(i(df|t))?
+scipy\.special\.agm
+scipy\.special\.beta(ln|incc?(inv)?)?
+scipy\.special\.binom
+scipy\.special\.poch
+scipy\.special\.(inv_)?boxcox(1p)?
+scipy\.special\.cbrt(r(c|iv?)?)?
+scipy\.special\.(cos|sin|tan|cot)dg
+scipy\.special\.(cos|pow|exp)m1
+scipy\.special\.ellip((e|k)(inc)?|km1|rc)
+scipy\.special\.erf(c(inv|x)?|i(nv)?)?
+scipy\.special\.eval_(cheby(c|s)|hermite(norm)?|laguerre)
+scipy\.special\.eval_(sh_)?(cheby(t|u)|legendre|jacobi)
+scipy\.special\.exp(10?|2|i|n|rel)
+scipy\.special\.(exp|log|log_exp)it
+scipy\.special\.log1p
+scipy\.special\.xlog(1p)?y
+scipy\.special\.(di|log|r)?gamma
+scipy\.special\.gamma(incc?(inv)?|ln|sgn)?
+scipy\.special\.(pseudo_)?huber
+scipy\.special\.hyp((0|2)f1|eru)
+scipy\.special\.be(i|r)p?
+scipy\.special\.(i|k)(0|1|v)e?
+scipy\.special\.(mod)?struve
+scipy\.special\.it(2|mod)?struve0
+scipy\.special\.(j|y)(0|1|n|ve?)
+scipy\.special\.k(e(i|r)p?|n)
+scipy\.special\.(rel_)?entr
+scipy\.special\.kl_div
+scipy\.special\.kolmog(i|orov)
+scipy\.special\.lpmv
+scipy\.special\.mathieu_(a|b)
+scipy\.special\.(obl|pro)_cv
+scipy\.special\.owens_t
+scipy\.special\.psi
+scipy\.special\.radian
+scipy\.special\.round
+scipy\.special\.smirnovi?
+scipy\.special\.spence
+scipy\.special\.sph_harm
+scipy\.special\.tklmbda
+scipy\.special\.voigt_profile
+scipy\.special\.dawsn
+scipy\.special\.wofz
+scipy\.special\.besselpoly
+scipy\.special\.(log_)?wright_bessel
+scipy\.special\.wrightomega
+scipy\.special\.zetac
+scipy\.special\.bdtr(c|i(k|n)?)?
+scipy\.special\.btdtri(a|b)
+scipy\.special\.chdtr(c|iv?)?
+scipy\.special\.chndtr(i(df|nc|x))?
+scipy\.special\.fdtr(c|i(dfd)?)?
+scipy\.special\.gdtr(c|i(a|b|x))?
+scipy\.special\.nbdtr(c|i(k|n)?)?
+scipy\.special\.ncfdtr(i((nc)?|df(d|n)))?
+scipy\.special\.nctdtr(i(df|nc|t))?
+scipy\.special\.(log_)?ndtr(i(_exp)?)?
+scipy\.special\.nrdtri(mn|sd)
+scipy\.special\.pdtr(c|ik?)?
+scipy\.special\.stdtr(i(df|t))?
diff --git a/scipy-stubs/special/_ufuncs.pyi b/scipy-stubs/special/_ufuncs.pyi
index df276daa..fe773811 100644
--- a/scipy-stubs/special/_ufuncs.pyi
+++ b/scipy-stubs/special/_ufuncs.pyi
@@ -3,7 +3,7 @@
 
 from types import EllipsisType
 from typing import Any, Generic, Literal as L, TypeAlias, TypedDict, final, overload, type_check_only
-from typing_extensions import LiteralString, Never, TypeVar, Unpack, override
+from typing_extensions import LiteralString, Never, TypeVar, Unpack, deprecated, override
 
 import numpy as np
 import optype as op
@@ -255,35 +255,63 @@ _T = TypeVar("_T")
 _NameT_co = TypeVar("_NameT_co", bound=LiteralString, covariant=True)
 _IdentityT_co = TypeVar("_IdentityT_co", bound=L[0] | None, default=None, covariant=True)
 _OutT = TypeVar("_OutT", bound=onp.ArrayND[np.number[Any]])
+_MaybeOutT = TypeVar("_MaybeOutT", bound=onp.ArrayND[np.number[Any]] | None, default=None)
 
+_Falsy: TypeAlias = L[False, 0]
+_Truthy: TypeAlias = L[True, 1]
+
+_Out1: TypeAlias = tuple[_MaybeOutT] | _MaybeOutT
 _Tuple2: TypeAlias = tuple[_T, _T]
 _Tuple3: TypeAlias = tuple[_T, _T, _T]
 _Tuple4: TypeAlias = tuple[_T, _T, _T, _T]
 _Tuple5: TypeAlias = tuple[_T, _T, _T, _T, _T]
 
+_ToBool_D: TypeAlias = onp.ToBool | onp.ToBoolND
+_ToInt_D: TypeAlias = onp.ToInt | onp.ToIntND
+_ToFloat_D: TypeAlias = onp.ToFloat | onp.ToFloatND
+_ToComplex_D: TypeAlias = onp.ToComplex | onp.ToComplexND
+
+_Float64ND: TypeAlias = onp.ArrayND[np.float64]
+
 _Float: TypeAlias = np.float32 | np.float64
+_FloatND: TypeAlias = onp.ArrayND[_Float]
+_Float_D: TypeAlias = _Float | onp.ArrayND[_Float]
+_Float_DT = TypeVar("_Float_DT", bound=_Float_D)
+
 _LFloat: TypeAlias = _Float | np.longdouble
+_LFloatND: TypeAlias = onp.ArrayND[_LFloat]
+_LFloat_D: TypeAlias = _LFloat | _LFloatND
+_LFloat_DT = TypeVar("_LFloat_DT", bound=_LFloat_D)
+
 _Complex: TypeAlias = np.complex64 | np.complex128
-_Inexact: TypeAlias = _Float | _Complex
+_ComplexND: TypeAlias = onp.ArrayND[_Complex]
+_Complex_D: TypeAlias = _Complex | _ComplexND
+_Complex_DT = TypeVar("_Complex_DT", bound=_Complex_D)
 
-_FloatNDT = TypeVar("_FloatNDT", bound=_Float | onp.ArrayND[_Float])
-_LFloatNDT = TypeVar("_LFloatNDT", bound=_LFloat | onp.ArrayND[_LFloat])
-_ComplexNDT = TypeVar("_ComplexNDT", bound=_Complex | onp.ArrayND[_Complex])
-_InexactNDT = TypeVar("_InexactNDT", bound=_Inexact | onp.ArrayND[_Inexact])
+_Inexact: TypeAlias = _Float | _Complex
+_InexactND: TypeAlias = onp.ArrayND[_Inexact]
+_Inexact_D: TypeAlias = _Inexact | _InexactND
+_InexactNDT = TypeVar("_InexactNDT", bound=_Inexact_D)
 
 _SubFloat: TypeAlias = np.float16 | np.integer[Any] | np.bool_
 _ToSubFloat: TypeAlias = float | _SubFloat
 
 _ToDType_l: TypeAlias = onp.AnyLongDType
+_ToDType_q: TypeAlias = onp.AnyLongLongDType
 _ToDType_f: TypeAlias = onp.AnyFloat32DType
 _ToDType_d: TypeAlias = onp.AnyFloat64DType
 _ToDType_g: TypeAlias = onp.AnyLongDoubleDType
 _ToDType_F: TypeAlias = onp.AnyComplex64DType
 _ToDType_D: TypeAlias = onp.AnyComplex128DType
-_ToDType_FD: TypeAlias = onp.AnyComplex64DType | onp.AnyComplex128DType
 _ToDType_fd: TypeAlias = _ToDType_f | _ToDType_d
 _ToDType_fdg: TypeAlias = _ToDType_fd | _ToDType_g
+_ToDType_FD: TypeAlias = _ToDType_F | _ToDType_D
+_ToDType_fdFD: TypeAlias = _ToDType_fd | _ToDType_FD
+
+_JustFloat: TypeAlias = opt.Just[float]
+_JustComplex: TypeAlias = opt.Just[complex]
 
+_Axis: TypeAlias = AnyShape | None
 _Indices: TypeAlias = op.CanIndex | slice | EllipsisType | tuple[op.CanIndex | slice | EllipsisType, ...] | onp.ToIntND
 
 @type_check_only
@@ -291,7 +319,7 @@ class _KwBase(TypedDict, total=False):
     order: OrderKACF
     casting: Casting
     subok: onp.ToBool
-    where: onp.ToBool | onp.ToBoolND
+    where: _ToBool_D
 
 @type_check_only
 class _UFunc(np.ufunc, Generic[_NameT_co, _IdentityT_co]):  # pyright: ignore[reportGeneralTypeIssues]
@@ -376,7 +404,7 @@ _ToSignature1_FD: TypeAlias = _Tuple2[_ToDType_F] | _Tuple2[_ToDType_D]
 
 @type_check_only
 class _Kw11f(_KwBase, TypedDict, total=False):
-    dtype: _ToDType_fd | None
+    dtype: _ToDType_fd
     signature: L["f->f", "d->d"] | _ToSignature1_fd
 
 @type_check_only
@@ -391,7 +419,7 @@ class _Kw11c(_KwBase, TypedDict, total=False):
 
 @type_check_only
 class _Kw11fc(_KwBase, TypedDict, total=False):
-    dtype: _ToDType_fd | _ToDType_FD | None
+    dtype: _ToDType_fdFD | None
     signature: L["f->f", "d->d", "F->F", "D->D"] | _ToSignature1_fd | _ToSignature1_FD
 
 _ToSignature2_ld: TypeAlias = tuple[_ToDType_l, _ToDType_d, _ToDType_d]
@@ -406,17 +434,17 @@ class _Kw21ld(_KwBase, TypedDict, total=False):
 
 @type_check_only
 class _Kw21f(_KwBase, TypedDict, total=False):
-    dtype: _ToDType_fd | None
+    dtype: _ToDType_fd
     signature: L["ff->f", "dd->d"] | _ToSignature2_fd2
 
 @type_check_only
 class _Kw21fc1(_KwBase, TypedDict, total=False):
-    dtype: _ToDType_fd | _ToDType_FD | None
+    dtype: _ToDType_fdFD | None
     signature: L["ff->f", "ld->d", "dd->d", "fF->F", "dD->D"] | _ToSignature2_ld | _ToSignature2_fd2 | _ToSignature2_fFdD
 
 @type_check_only
 class _Kw21fc2(_KwBase, TypedDict, total=False):
-    dtype: _ToDType_fd | _ToDType_FD | None
+    dtype: _ToDType_fdFD | None
     signature: L["ff->f", "dd->d", "FF->F", "DD->D"] | _ToSignature2_fd2 | _ToSignature2_FD2
 
 _ToSignature3_lld: TypeAlias = tuple[_ToDType_l, _ToDType_l, _ToDType_d, _ToDType_d]
@@ -425,16 +453,34 @@ _ToSignature3_fd3: TypeAlias = _Tuple4[_ToDType_f] | _Tuple4[_ToDType_d]
 
 @type_check_only
 class _Kw31f(_KwBase, TypedDict, total=False):
-    dtype: _ToDType_fd | None
+    dtype: _ToDType_fd
     signature: L["fff->f", "ddd->d", "lld->d", "dld->d"] | _ToSignature3_fd3 | _ToSignature3_lld | _ToSignature3_dld
 
 _ToSignature3_fd4: TypeAlias = _Tuple5[_ToDType_f] | _Tuple5[_ToDType_d]
 
 @type_check_only
 class _Kw41f(_KwBase, TypedDict, total=False):
-    dtype: _ToDType_fd | None
+    dtype: _ToDType_fd
     signature: L["ffff->f", "dddd->d"] | _ToSignature3_fd4
 
+@type_check_only
+class _Kw41fc1(_KwBase, TypedDict, total=False):
+    # (qq|ff)ff->F; (qq|dd)dd->D
+    dtype: _ToDType_FD
+    signature: (
+        L["ffff->f", "lddd->d", "dddd->d", "fffF->F", "dddD->D"]
+        | tuple[_ToDType_l | _ToDType_fd, _ToDType_fd, _ToDType_fd, _ToDType_fdFD, _ToDType_fdFD]
+    )
+
+@type_check_only
+class _KwSphHarm(_KwBase, TypedDict, total=False):
+    # (qq|ff)ff->F; (qq|dd)dd->D
+    dtype: _ToDType_FD
+    signature: (
+        L["qqff->F", "ffff->F", "qqdd->D", "dddd->D"]
+        | tuple[_ToDType_q | _ToDType_fd, _ToDType_q | _ToDType_fd, _ToDType_fd, _ToDType_fd, _ToDType_FD]
+    )
+
 @final
 @type_check_only
 class _UFunc11f(_UFunc11[_NameT_co, _IdentityT_co], Generic[_NameT_co, _IdentityT_co]):
@@ -446,13 +492,13 @@ class _UFunc11f(_UFunc11[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
     def types(self, /) -> list[L["f->f", "d->d"]]: ...
     #
     @overload
-    def __call__(self, x: _ToSubFloat, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11f]) -> _Float: ...
+    def __call__(self, x: _ToSubFloat, /, out: _Out1 = None, **kw: Unpack[_Kw11f]) -> _Float: ...
     @overload
-    def __call__(self, x: _FloatNDT, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11f]) -> _FloatNDT: ...
+    def __call__(self, x: _Float_DT, /, out: _Out1 = None, **kw: Unpack[_Kw11f]) -> _Float_DT: ...
     @overload
-    def __call__(self, x: onp.ToFloatND, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11f]) -> onp.ArrayND[_Float]: ...
+    def __call__(self, x: onp.ToFloatND, /, out: _Out1 = None, **kw: Unpack[_Kw11f]) -> _FloatND: ...
     @overload
-    def __call__(self, x: onp.ToFloat | onp.ToFloatND, /, out: tuple[_OutT] | _OutT, **kw: Unpack[_Kw11f]) -> _OutT: ...
+    def __call__(self, x: _ToFloat_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw11f]) -> _OutT: ...
     #
     @override
     def at(self, a: onp.ArrayND[_Float | _SubFloat], indices: _Indices, /) -> None: ...
@@ -468,13 +514,13 @@ class _UFunc11g(_UFunc11[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
     def types(self, /) -> list[L["f->f", "d->d", "g->g"]]: ...
     #
     @overload
-    def __call__(self, x: _ToSubFloat, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11g]) -> _LFloat: ...
+    def __call__(self, x: _ToSubFloat, /, out: _Out1 = None, **kw: Unpack[_Kw11g]) -> _LFloat: ...
     @overload
-    def __call__(self, x: _LFloatNDT, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11g]) -> _LFloatNDT: ...
+    def __call__(self, x: _LFloat_DT, /, out: _Out1 = None, **kw: Unpack[_Kw11g]) -> _LFloat_DT: ...
     @overload
-    def __call__(self, x: onp.ToFloatND, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11g]) -> onp.ArrayND[_Float]: ...
+    def __call__(self, x: onp.ToFloatND, /, out: _Out1 = None, **kw: Unpack[_Kw11g]) -> _FloatND: ...
     @overload
-    def __call__(self, x: onp.ToFloat | onp.ToFloatND, /, out: tuple[_OutT] | _OutT, **kw: Unpack[_Kw11g]) -> _OutT: ...
+    def __call__(self, x: _ToFloat_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw11g]) -> _OutT: ...
     #
     @override
     def at(self, a: onp.ArrayND[_LFloat | _SubFloat], indices: _Indices, /) -> None: ...
@@ -490,13 +536,13 @@ class _UFunc11c(_UFunc11[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
     def types(self, /) -> list[L["F->F", "D->D"]]: ...
     #
     @overload
-    def __call__(self, x: onp.ToFloat, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11c]) -> _Complex: ...
+    def __call__(self, x: onp.ToFloat, /, out: _Out1 = None, **kw: Unpack[_Kw11c]) -> _Complex: ...
     @overload
-    def __call__(self, x: _ComplexNDT, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11c]) -> _ComplexNDT: ...
+    def __call__(self, x: _Complex_DT, /, out: _Out1 = None, **kw: Unpack[_Kw11c]) -> _Complex_DT: ...
     @overload
-    def __call__(self, x: onp.ToComplexND, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11c]) -> onp.ArrayND[_Complex]: ...
+    def __call__(self, x: onp.ToComplexND, /, out: _Out1 = None, **kw: Unpack[_Kw11c]) -> _ComplexND: ...
     @overload
-    def __call__(self, x: onp.ToComplex | onp.ToComplexND, /, out: tuple[_OutT] | _OutT, **kw: Unpack[_Kw11c]) -> _OutT: ...
+    def __call__(self, x: _ToComplex_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw11c]) -> _OutT: ...
     #
     @override
     def at(self, a: onp.ArrayND[_Inexact | _SubFloat], indices: _Indices, /) -> None: ...
@@ -512,17 +558,17 @@ class _UFunc11fc(_UFunc11[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identit
     def types(self, /) -> list[L["f->f", "d->d", "F->F", "D->D"]]: ...
     #
     @overload
-    def __call__(self, x: _ToSubFloat, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11fc]) -> _Float: ...
+    def __call__(self, x: _ToSubFloat, /, out: _Out1 = None, **kw: Unpack[_Kw11fc]) -> _Float: ...
     @overload
-    def __call__(self, x: complex | _ToSubFloat, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11fc]) -> _Inexact: ...
+    def __call__(self, x: complex | _ToSubFloat, /, out: _Out1 = None, **kw: Unpack[_Kw11fc]) -> _Inexact: ...
     @overload
-    def __call__(self, x: _InexactNDT, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11fc]) -> _InexactNDT: ...
+    def __call__(self, x: _InexactNDT, /, out: _Out1 = None, **kw: Unpack[_Kw11fc]) -> _InexactNDT: ...
     @overload
-    def __call__(self, x: onp.ToFloatND, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11fc]) -> onp.ArrayND[_Float]: ...
+    def __call__(self, x: onp.ToFloatND, /, out: _Out1 = None, **kw: Unpack[_Kw11fc]) -> _FloatND: ...
     @overload
-    def __call__(self, x: onp.ToComplexND, /, out: tuple[None] | None = None, **kw: Unpack[_Kw11fc]) -> onp.ArrayND[_Inexact]: ...
+    def __call__(self, x: onp.ToComplexND, /, out: _Out1 = None, **kw: Unpack[_Kw11fc]) -> _InexactND: ...
     @overload
-    def __call__(self, x: onp.ToComplex | onp.ToComplexND, /, out: tuple[_OutT] | _OutT, **kw: Unpack[_Kw11fc]) -> _OutT: ...
+    def __call__(self, x: _ToComplex_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw11fc]) -> _OutT: ...
     #
     @override
     def at(self, a: onp.ArrayND[_Inexact | _SubFloat], indices: _Indices, /) -> None: ...
@@ -538,61 +584,25 @@ class _UFunc21ld(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identit
     def types(self, /) -> list[L["ld->d"]]: ...
     #
     @overload
-    def __call__(
-        self,
-        n: onp.ToInt,
-        x: onp.ToFloat,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21ld],
-    ) -> np.float64: ...
+    def __call__(self, n: onp.ToInt, x: onp.ToFloat, /, out: _Out1 = None, **kw: Unpack[_Kw21ld]) -> np.float64: ...
     @overload
-    def __call__(
-        self,
-        n: onp.ToInt | onp.ToIntND,
-        x: onp.ToFloatND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21ld],
-    ) -> onp.ArrayND[np.float64]: ...
+    def __call__(self, n: _ToInt_D, x: onp.ToFloatND, /, out: _Out1 = None, **kw: Unpack[_Kw21ld]) -> _Float64ND: ...
     @overload
-    def __call__(
-        self,
-        n: onp.ToIntND,
-        x: onp.ToFloat | onp.ToFloatND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21ld],
-    ) -> onp.ArrayND[np.float64]: ...
+    def __call__(self, n: onp.ToIntND, x: _ToFloat_D, /, out: _Out1 = None, **kw: Unpack[_Kw21ld]) -> _Float64ND: ...
     @overload
-    def __call__(
-        self,
-        n: onp.ToInt | onp.ToIntND,
-        x: onp.ToFloat | onp.ToFloatND,
-        /,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21ld],
-    ) -> _OutT: ...
+    def __call__(self, n: _ToInt_D, x: _ToFloat_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw21ld]) -> _OutT: ...
     #
     @override
     def at(self, a: onp.ArrayND[np.integer[Any] | np.bool_], indices: _Indices, b: onp.ToFloatND, /) -> None: ...
     #
     @overload
-    def outer(self, n: onp.ToInt, x: onp.ToFloat, /, **kwargs: Unpack[_Kw21ld]) -> np.float64: ...
+    def outer(self, n: onp.ToInt, x: onp.ToFloat, /, **kw: Unpack[_Kw21ld]) -> np.float64: ...
     @overload
-    def outer(self, n: onp.ToInt | onp.ToFloatND, x: onp.ToFloatND, /, **kwargs: Unpack[_Kw21ld]) -> onp.ArrayND[np.float64]: ...
+    def outer(self, n: onp.ToInt | onp.ToFloatND, x: onp.ToFloatND, /, **kw: Unpack[_Kw21ld]) -> _Float64ND: ...
     @overload
-    def outer(self, n: onp.ToIntND, x: onp.ToFloat | onp.ToFloatND, /, **kwargs: Unpack[_Kw21ld]) -> onp.ArrayND[np.float64]: ...
+    def outer(self, n: onp.ToIntND, x: _ToFloat_D, /, **kw: Unpack[_Kw21ld]) -> _Float64ND: ...
     @overload
-    def outer(
-        self,
-        n: onp.ToInt | onp.ToIntND,
-        x: onp.ToFloat | onp.ToFloatND,
-        /,
-        *,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21ld],
-    ) -> _OutT: ...
+    def outer(self, n: _ToInt_D, x: _ToFloat_D, /, *, out: _Out1[_OutT], **kw: Unpack[_Kw21ld]) -> _OutT: ...
     #
     @override
     def accumulate(self, /, *args: Never, **kwargs: Never) -> Never: ...
@@ -611,50 +621,26 @@ class _UFunc21f(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
     def types(self, /) -> list[L["ff->f", "dd->d", "ld->d"]]: ...
     #
     @overload
-    def __call__(
-        self,
-        a: _ToSubFloat,
-        b: _ToSubFloat,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21f],
-    ) -> _Float: ...
+    def __call__(self, a: onp.ToFloat, b: onp.ToJustInt | _JustFloat | np.float64, /, out: _Out1 = None) -> np.float64: ...
     @overload
-    def __call__(
-        self,
-        a: _FloatNDT | _ToSubFloat,
-        b: _FloatNDT | _ToSubFloat,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21f],
-    ) -> _FloatNDT: ...
+    def __call__(self, a: _ToSubFloat, b: _ToSubFloat, /, out: _Out1 = None, **kw: Unpack[_Kw21f]) -> _Float: ...
     @overload
     def __call__(
         self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToFloatND,
+        a: _Float_DT | _ToSubFloat,
+        b: _Float_DT | _ToSubFloat,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw21f],
+    ) -> _Float_DT: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloatND,
-        b: onp.ToFloat | onp.ToFloatND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21f],
-    ) -> onp.ArrayND[_Float]: ...
+    def __call__(self, a: onp.ToIntND | _Float64ND, b: onp.ToIntND | _Float64ND, /, out: _Out1 = None) -> _Float64ND: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToFloat | onp.ToFloatND,
-        /,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21f],
-    ) -> _OutT: ...
+    def __call__(self, a: _ToFloat_D, b: onp.ToFloatND, /, out: _Out1 = None, **kw: Unpack[_Kw21f]) -> _FloatND: ...
+    @overload
+    def __call__(self, a: onp.ToFloatND, b: _ToFloat_D, /, out: _Out1 = None, **kw: Unpack[_Kw21f]) -> _FloatND: ...
+    @overload
+    def __call__(self, a: _ToFloat_D, b: _ToFloat_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw21f]) -> _OutT: ...
     #
     @override
     def at(self, a: onp.ArrayND[_Float | _SubFloat], indices: _Indices, b: onp.ToFloatND, /) -> None: ...
@@ -665,9 +651,9 @@ class _UFunc21f(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
         /,
         array: onp.ToFloatND,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[onp.ArrayND[_Float] | None] | onp.ArrayND[_Float] | None = None,
-    ) -> onp.ArrayND[_Float]: ...
+        dtype: _ToDType_fd = None,
+        out: _Out1[_FloatND | None] = None,
+    ) -> _FloatND: ...
     #
     @overload
     def reduce(
@@ -675,61 +661,61 @@ class _UFunc21f(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
         /,
         array: onp.ToFloatND,
         axis: None,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
-        out: tuple[None] | None = None,
-        keepdims: L[False] = False,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
+        keepdims: _Falsy = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> np.float32 | np.float64: ...
+        where: _ToBool_D = True,
+    ) -> _Float: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None = 0,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
-        out: tuple[None] | None = None,
-        keepdims: L[False] = False,
+        axis: _Axis = 0,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
+        keepdims: _Falsy = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> np.float32 | np.float64 | onp.ArrayND[np.float32 | np.float64]: ...
+        where: _ToBool_D = True,
+    ) -> _Float_D: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None = 0,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
-        out: tuple[None] | None = None,
+        axis: _Axis = 0,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
         *,
-        keepdims: L[True],
+        keepdims: _Truthy,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> onp.ArrayND[np.float32 | np.float64]: ...
+        where: _ToBool_D = True,
+    ) -> _FloatND: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None,
-        out: tuple[_OutT] | _OutT,
+        axis: _Axis,
+        dtype: _ToDType_fd,
+        out: _Out1[_OutT],
         keepdims: bool = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _OutT: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None = 0,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
+        axis: _Axis = 0,
+        dtype: _ToDType_fd = None,
         *,
-        out: tuple[_OutT] | _OutT,
+        out: _Out1[_OutT],
         keepdims: bool = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _OutT: ...
     #
     def reduceat(
@@ -738,26 +724,18 @@ class _UFunc21f(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
         array: onp.ToFloatND,
         indices: _Indices,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[onp.ArrayND[_Float] | None] | onp.ArrayND[_Float] | None = None,
-    ) -> onp.ArrayND[_Float]: ...
+        dtype: _ToDType_fd = None,
+        out: _Out1[_FloatND | None] = None,
+    ) -> _FloatND: ...
     #
     @overload
-    def outer(self, a: onp.ToFloat, b: onp.ToFloat, /, **kwargs: Unpack[_Kw21f]) -> _Float: ...
+    def outer(self, a: onp.ToFloat, b: onp.ToFloat, /, **kw: Unpack[_Kw21f]) -> _Float: ...
     @overload
-    def outer(self, a: onp.ToFloat | onp.ToFloatND, b: onp.ToFloatND, /, **kwargs: Unpack[_Kw21f]) -> onp.ArrayND[_Float]: ...
+    def outer(self, a: _ToFloat_D, b: onp.ToFloatND, /, **kw: Unpack[_Kw21f]) -> _FloatND: ...
     @overload
-    def outer(self, a: onp.ToFloatND, b: onp.ToFloat | onp.ToFloatND, /, **kwargs: Unpack[_Kw21f]) -> onp.ArrayND[_Float]: ...
+    def outer(self, a: onp.ToFloatND, b: _ToFloat_D, /, **kw: Unpack[_Kw21f]) -> _FloatND: ...
     @overload
-    def outer(
-        self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToFloat | onp.ToFloatND,
-        /,
-        *,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21f],
-    ) -> _OutT: ...
+    def outer(self, a: _ToFloat_D, b: _ToFloat_D, /, *, out: _Out1[_OutT], **kw: Unpack[_Kw21f]) -> _OutT: ...
 
 @final
 @type_check_only
@@ -770,68 +748,19 @@ class _UFunc21fc1(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
     def types(self, /) -> list[L["ff->f", "dd->d", "fF->F", "dD->D", "ld->d"]]: ...
     #
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloat,
-        b: _ToSubFloat,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> _Float: ...
+    def __call__(self, a: onp.ToFloat, b: _ToSubFloat, /, out: _Out1 = None, **kw: Unpack[_Kw21fc1]) -> _Float: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloat,
-        b: _InexactNDT,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> _InexactNDT: ...
+    def __call__(self, a: onp.ToFloat, b: _InexactNDT, /, out: _Out1 = None, **kw: Unpack[_Kw21fc1]) -> _InexactNDT: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToFloatND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> onp.ArrayND[_Float]: ...
+    def __call__(self, a: _ToFloat_D, b: onp.ToFloatND, /, out: _Out1 = None, **kw: Unpack[_Kw21fc1]) -> _FloatND: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloatND,
-        b: onp.ToFloat | onp.ToFloatND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> onp.ArrayND[_Float]: ...
+    def __call__(self, a: onp.ToFloatND, b: _ToFloat_D, /, out: _Out1 = None, **kw: Unpack[_Kw21fc1]) -> _FloatND: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToComplexND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> onp.ArrayND[_Inexact]: ...
+    def __call__(self, a: _ToFloat_D, b: onp.ToComplexND, /, out: _Out1 = None, **kw: Unpack[_Kw21fc1]) -> _InexactND: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloatND,
-        b: onp.ToComplex | onp.ToComplexND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> onp.ArrayND[_Inexact]: ...
+    def __call__(self, a: onp.ToFloatND, b: _ToComplex_D, /, out: _Out1 = None, **kw: Unpack[_Kw21fc1]) -> _InexactND: ...
     @overload
-    def __call__(
-        self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToComplex | onp.ToComplexND,
-        /,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> _OutT: ...
+    def __call__(self, a: _ToFloat_D, b: _ToComplex_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw21fc1]) -> _OutT: ...
     #
     @override  # only works if real
     def at(self, a: onp.ArrayND[_Float | _SubFloat], indices: _Indices, b: onp.ToFloatND, /) -> None: ...
@@ -842,9 +771,9 @@ class _UFunc21fc1(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
         /,
         array: onp.ToFloatND,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[onp.ArrayND[_Float] | None] | onp.ArrayND[_Float] | None = None,
-    ) -> onp.ArrayND[_Float]: ...
+        dtype: _ToDType_fd = None,
+        out: _Out1[_FloatND | None] = None,
+    ) -> _FloatND: ...
     #
     @overload
     def reduce(
@@ -852,61 +781,61 @@ class _UFunc21fc1(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
         /,
         array: onp.ToFloatND,
         axis: None,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
-        out: tuple[None] | None = None,
-        keepdims: L[False] = False,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
+        keepdims: _Falsy = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _Float: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None = 0,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
-        out: tuple[None] | None = None,
-        keepdims: L[False] = False,
+        axis: _Axis = 0,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
+        keepdims: _Falsy = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> _Float | onp.ArrayND[_Float]: ...
+        where: _ToBool_D = True,
+    ) -> _Float_D: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None = 0,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
-        out: tuple[None] | None = None,
+        axis: _Axis = 0,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
         *,
-        keepdims: L[True],
+        keepdims: _Truthy,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> onp.ArrayND[_Float]: ...
+        where: _ToBool_D = True,
+    ) -> _FloatND: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None,
-        out: tuple[_OutT] | _OutT,
+        axis: _Axis,
+        dtype: _ToDType_fd,
+        out: _Out1[_OutT],
         keepdims: bool = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _OutT: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None = 0,
-        dtype: onp.AnyFloat32DType | onp.AnyFloat64DType | None = None,
+        axis: _Axis = 0,
+        dtype: _ToDType_fd = None,
         *,
-        out: tuple[_OutT] | _OutT,
+        out: _Out1[_OutT],
         keepdims: bool = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _OutT: ...
     #
     def reduceat(
@@ -915,32 +844,24 @@ class _UFunc21fc1(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
         array: onp.ToFloatND,
         indices: _Indices,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[onp.ArrayND[_Float] | None] | onp.ArrayND[_Float] | None = None,
-    ) -> onp.ArrayND[_Float]: ...
+        dtype: _ToDType_fd = None,
+        out: _Out1[_FloatND | None] = None,
+    ) -> _FloatND: ...
     #
     @overload
     def outer(self, a: onp.ToFloat, b: onp.ToFloat, /, **kw: Unpack[_Kw21fc1]) -> _Float: ...
     @overload
     def outer(self, a: onp.ToFloat, b: onp.ToComplex, /, **kw: Unpack[_Kw21fc1]) -> _Inexact: ...
     @overload
-    def outer(self, a: onp.ToFloat | onp.ToFloatND, b: onp.ToFloatND, /, **kw: Unpack[_Kw21fc1]) -> onp.ArrayND[_Float]: ...
+    def outer(self, a: _ToFloat_D, b: onp.ToFloatND, /, **kw: Unpack[_Kw21fc1]) -> _FloatND: ...
     @overload
-    def outer(self, a: onp.ToFloatND, b: onp.ToFloat | onp.ToFloatND, /, **kw: Unpack[_Kw21fc1]) -> onp.ArrayND[_Float]: ...
+    def outer(self, a: onp.ToFloatND, b: _ToFloat_D, /, **kw: Unpack[_Kw21fc1]) -> _FloatND: ...
     @overload
-    def outer(self, a: onp.ToFloat | onp.ToFloatND, b: onp.ToComplexND, /, **kw: Unpack[_Kw21fc1]) -> onp.ArrayND[_Inexact]: ...
+    def outer(self, a: _ToFloat_D, b: onp.ToComplexND, /, **kw: Unpack[_Kw21fc1]) -> _InexactND: ...
     @overload
-    def outer(self, a: onp.ToFloatND, b: onp.ToComplex | onp.ToComplexND, /, **kw: Unpack[_Kw21fc1]) -> onp.ArrayND[_Inexact]: ...
+    def outer(self, a: onp.ToFloatND, b: _ToComplex_D, /, **kw: Unpack[_Kw21fc1]) -> _InexactND: ...
     @overload
-    def outer(
-        self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToComplex | onp.ToComplexND,
-        /,
-        *,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21fc1],
-    ) -> _OutT: ...
+    def outer(self, a: _ToFloat_D, b: _ToComplex_D, /, *, out: _Out1[_OutT], **kw: Unpack[_Kw21fc1]) -> _OutT: ...
 
 @final
 @type_check_only
@@ -953,86 +874,37 @@ class _UFunc21fc2(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
     def types(self, /) -> list[L["ff->f", "dd->d", "FF->F", "DD->D"]]: ...
     #
     @overload
-    def __call__(
-        self,
-        x: _ToSubFloat,
-        y: _ToSubFloat,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> _Float: ...
+    def __call__(self, x: _ToSubFloat, y: _ToSubFloat, /, out: _Out1 = None, **kw: Unpack[_Kw21fc2]) -> np.float64: ...
     @overload
-    def __call__(
-        self,
-        x: _ToSubFloat,
-        y: opt.Just[complex],
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> _Complex: ...
+    def __call__(self, x: _ToSubFloat, y: _JustComplex, /, out: _Out1 = None, **kw: Unpack[_Kw21fc2]) -> np.complex128: ...
     @overload
     def __call__(
         self,
-        x: opt.Just[complex],
-        y: opt.Just[complex] | _ToSubFloat,
+        x: _JustComplex,
+        y: _JustComplex | onp.ToFloat,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> _Complex: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw21fc2],
+    ) -> np.complex128: ...
     @overload
     def __call__(
         self,
         x: _InexactNDT | _ToSubFloat,
         y: _InexactNDT | _ToSubFloat,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
+        out: _Out1 = None,
+        **kw: Unpack[_Kw21fc2],
     ) -> _InexactNDT: ...
     @overload
-    def __call__(
-        self,
-        x: onp.ToFloat | onp.ToFloatND,
-        y: onp.ToFloatND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> onp.ArrayND[_Float]: ...
+    def __call__(self, x: _ToFloat_D, y: onp.ToFloatND, /, out: _Out1 = None, **kw: Unpack[_Kw21fc2]) -> _FloatND: ...
     @overload
-    def __call__(
-        self,
-        x: onp.ToFloatND,
-        y: onp.ToFloat | onp.ToFloatND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> onp.ArrayND[_Float]: ...
+    def __call__(self, x: onp.ToFloatND, y: _ToFloat_D, /, out: _Out1 = None, **kw: Unpack[_Kw21fc2]) -> _FloatND: ...
     @overload
-    def __call__(
-        self,
-        x: onp.ToComplex | onp.ToComplexND,
-        y: onp.ToComplexND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> onp.ArrayND[_Inexact]: ...
+    def __call__(self, x: _ToComplex_D, y: onp.ToComplexND, /, out: _Out1 = None, **kw: Unpack[_Kw21fc2]) -> _InexactND: ...
     @overload
-    def __call__(
-        self,
-        x: onp.ToComplexND,
-        y: onp.ToComplex | onp.ToComplexND,
-        /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> onp.ArrayND[_Inexact]: ...
+    def __call__(self, x: onp.ToComplexND, y: _ToComplex_D, /, out: _Out1 = None, **kw: Unpack[_Kw21fc2]) -> _InexactND: ...
     @overload
-    def __call__(
-        self,
-        x: onp.ToComplex | onp.ToComplexND,
-        y: onp.ToComplex | onp.ToComplexND,
-        /,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> _OutT: ...
+    def __call__(self, x: _ToComplex_D, y: _ToComplex_D, /, out: _Out1[_OutT], **kw: Unpack[_Kw21fc2]) -> _OutT: ...
     #
     @overload
     def at(self, x: onp.ArrayND[_Float | _SubFloat], indices: _Indices, y: onp.ToFloatND, /) -> None: ...
@@ -1045,18 +917,18 @@ class _UFunc21fc2(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
         /,
         array: onp.ToFloatND,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[onp.ArrayND[_Float] | None] | onp.ArrayND[_Float] | None = None,
-    ) -> onp.ArrayND[_Float]: ...
+        dtype: _ToDType_fd = None,
+        out: _Out1[_FloatND | None] = None,
+    ) -> _FloatND: ...
     @overload
     def accumulate(
         self,
         /,
         array: onp.ToComplexND,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | _ToDType_FD | None = None,
-        out: tuple[onp.ArrayND[_Inexact] | None] | onp.ArrayND[_Inexact] | None = None,
-    ) -> onp.ArrayND[_Inexact]: ...
+        dtype: _ToDType_fdFD | None = None,
+        out: _Out1[_InexactND | None] = None,
+    ) -> _InexactND: ...
     #
     @overload
     def reduce(
@@ -1064,86 +936,86 @@ class _UFunc21fc2(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
         /,
         array: onp.ToFloatND,
         axis: None,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[None] | None = None,
-        keepdims: L[False] = False,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
+        keepdims: _Falsy = False,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _Float: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToFloatND,
-        axis: AnyShape | None = 0,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[None] | None = None,
+        axis: _Axis = 0,
+        dtype: _ToDType_fd = None,
+        out: _Out1 = None,
         *,
-        keepdims: L[True],
+        keepdims: _Truthy,
         initial: onp.ToFloat = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> onp.ArrayND[_Float]: ...
+        where: _ToBool_D = True,
+    ) -> _FloatND: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToComplexND,
         axis: None,
-        dtype: _ToDType_fd | _ToDType_FD | None = None,
-        out: tuple[None] | None = None,
-        keepdims: L[False] = False,
+        dtype: _ToDType_fdFD | None = None,
+        out: _Out1 = None,
+        keepdims: _Falsy = False,
         initial: onp.ToComplex = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _Inexact: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToComplexND,
-        axis: AnyShape | None = 0,
-        dtype: _ToDType_fd | _ToDType_FD | None = None,
-        out: tuple[None] | None = None,
+        axis: _Axis = 0,
+        dtype: _ToDType_fdFD | None = None,
+        out: _Out1 = None,
         *,
-        keepdims: L[True],
+        keepdims: _Truthy,
         initial: onp.ToComplex = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> onp.ArrayND[_Inexact]: ...
+        where: _ToBool_D = True,
+    ) -> _InexactND: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToComplexND,
-        axis: AnyShape | None = 0,
-        dtype: _ToDType_fd | _ToDType_FD | None = None,
-        out: tuple[None] | None = None,
-        keepdims: L[False] = False,
+        axis: _Axis = 0,
+        dtype: _ToDType_fdFD | None = None,
+        out: _Out1 = None,
+        keepdims: _Falsy = False,
         initial: onp.ToComplex = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
-    ) -> _Inexact | onp.ArrayND[_Inexact]: ...
+        where: _ToBool_D = True,
+    ) -> _Inexact_D: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToComplexND,
-        axis: AnyShape | None,
-        dtype: _ToDType_fd | _ToDType_FD | None,
-        out: tuple[_OutT] | _OutT,
+        axis: _Axis,
+        dtype: _ToDType_fdFD | None,
+        out: _Out1[_OutT],
         keepdims: bool = False,
         initial: onp.ToComplex = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _OutT: ...
     @overload
     def reduce(
         self,
         /,
         array: onp.ToComplexND,
-        axis: AnyShape | None = 0,
-        dtype: _ToDType_fd | _ToDType_FD | None = None,
+        axis: _Axis = 0,
+        dtype: _ToDType_fdFD | None = None,
         *,
-        out: tuple[_OutT] | _OutT,
+        out: _Out1[_OutT],
         keepdims: bool = False,
         initial: onp.ToComplex = ...,
-        where: onp.ToBool | onp.ToBoolND = True,
+        where: _ToBool_D = True,
     ) -> _OutT: ...
     #
     @overload
@@ -1153,9 +1025,9 @@ class _UFunc21fc2(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
         array: onp.ToFloatND,
         indices: _Indices,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | None = None,
-        out: tuple[onp.ArrayND[_Float] | None] | onp.ArrayND[_Float] | None = None,
-    ) -> onp.ArrayND[_Float]: ...
+        dtype: _ToDType_fd = None,
+        out: _Out1[_FloatND | None] = None,
+    ) -> _FloatND: ...
     @overload
     def reduceat(
         self,
@@ -1163,44 +1035,24 @@ class _UFunc21fc2(_UFunc21[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identi
         array: onp.ToComplexND,
         indices: _Indices,
         axis: op.CanIndex = 0,
-        dtype: _ToDType_fd | _ToDType_FD | None = None,
-        out: tuple[onp.ArrayND[_Inexact] | None] | onp.ArrayND[_Inexact] | None = None,
-    ) -> onp.ArrayND[_Inexact]: ...
+        dtype: _ToDType_fdFD | None = None,
+        out: _Out1[_InexactND | None] = None,
+    ) -> _InexactND: ...
     #
     @overload
     def outer(self, x: onp.ToFloat, y: onp.ToFloat, /, **kw: Unpack[_Kw21fc2]) -> _Float: ...
     @overload
     def outer(self, x: onp.ToComplex, y: onp.ToComplex, /, **kw: Unpack[_Kw21fc2]) -> _Inexact: ...
     @overload
-    def outer(self, x: onp.ToFloat | onp.ToFloatND, y: onp.ToFloatND, /, **kw: Unpack[_Kw21fc2]) -> onp.ArrayND[_Float]: ...
+    def outer(self, x: _ToFloat_D, y: onp.ToFloatND, /, **kw: Unpack[_Kw21fc2]) -> _FloatND: ...
     @overload
-    def outer(self, x: onp.ToFloatND, y: onp.ToFloat | onp.ToFloatND, /, **kw: Unpack[_Kw21fc2]) -> onp.ArrayND[_Float]: ...
+    def outer(self, x: onp.ToFloatND, y: _ToFloat_D, /, **kw: Unpack[_Kw21fc2]) -> _FloatND: ...
     @overload
-    def outer(
-        self,
-        x: onp.ToComplex | onp.ToComplexND,
-        y: onp.ToComplexND,
-        /,
-        **kw: Unpack[_Kw21fc2],
-    ) -> onp.ArrayND[_Inexact]: ...
+    def outer(self, x: _ToComplex_D, y: onp.ToComplexND, /, **kw: Unpack[_Kw21fc2]) -> _InexactND: ...
     @overload
-    def outer(
-        self,
-        x: onp.ToComplexND,
-        y: onp.ToComplex | onp.ToComplexND,
-        /,
-        **kw: Unpack[_Kw21fc2],
-    ) -> onp.ArrayND[_Inexact]: ...
+    def outer(self, x: onp.ToComplexND, y: _ToComplex_D, /, **kw: Unpack[_Kw21fc2]) -> _InexactND: ...
     @overload
-    def outer(
-        self,
-        x: onp.ToComplex | onp.ToComplexND,
-        y: onp.ToComplex | onp.ToComplexND,
-        /,
-        *,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw21fc2],
-    ) -> _OutT: ...
+    def outer(self, x: _ToComplex_D, y: _ToComplex_D, /, *, out: _Out1[_OutT], **kw: Unpack[_Kw21fc2]) -> _OutT: ...
 
 @final
 @type_check_only
@@ -1219,58 +1071,58 @@ class _UFunc31f(_UFunc31[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
         b: _ToSubFloat,
         x: _ToSubFloat,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw31f],
+        out: _Out1 = None,
+        **kw: Unpack[_Kw31f],
     ) -> _Float: ...
     @overload
     def __call__(
         self,
-        a: _FloatNDT | _ToSubFloat,
-        b: _FloatNDT | _ToSubFloat,
-        x: _FloatNDT | _ToSubFloat,
+        a: _Float_DT | _ToSubFloat,
+        b: _Float_DT | _ToSubFloat,
+        x: _Float_DT | _ToSubFloat,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw31f],
-    ) -> _FloatNDT: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw31f],
+    ) -> _Float_DT: ...
     @overload
     def __call__(
         self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToFloat | onp.ToFloatND,
+        a: _ToFloat_D,
+        b: _ToFloat_D,
         x: onp.ToFloatND,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw31f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw31f],
+    ) -> _FloatND: ...
     @overload
     def __call__(
         self,
-        a: onp.ToFloat | onp.ToFloatND,
+        a: _ToFloat_D,
         b: onp.ToFloatND,
-        x: onp.ToFloat | onp.ToFloatND,
+        x: _ToFloat_D,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw31f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw31f],
+    ) -> _FloatND: ...
     @overload
     def __call__(
         self,
         a: onp.ToFloatND,
-        b: onp.ToFloat | onp.ToFloatND,
-        x: onp.ToFloat | onp.ToFloatND,
+        b: _ToFloat_D,
+        x: _ToFloat_D,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw31f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw31f],
+    ) -> _FloatND: ...
     @overload
     def __call__(
         self,
-        a: onp.ToFloat | onp.ToFloatND,
-        b: onp.ToFloat | onp.ToFloatND,
-        x: onp.ToFloat | onp.ToFloatND,
+        a: _ToFloat_D,
+        b: _ToFloat_D,
+        x: _ToFloat_D,
         /,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw31f],
+        out: _Out1[_OutT],
+        **kw: Unpack[_Kw31f],
     ) -> _OutT: ...
 
 @final
@@ -1291,74 +1143,289 @@ class _UFunc41f(_UFunc41[_NameT_co, _IdentityT_co], Generic[_NameT_co, _Identity
         nc: _ToSubFloat,
         f: _ToSubFloat,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw41f],
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41f],
     ) -> _Float: ...
     @overload
     def __call__(
         self,
-        dfn: _FloatNDT | _ToSubFloat,
-        dfd: _FloatNDT | _ToSubFloat,
-        nc: _FloatNDT | _ToSubFloat,
-        f: _FloatNDT | _ToSubFloat,
+        dfn: _Float_DT | _ToSubFloat,
+        dfd: _Float_DT | _ToSubFloat,
+        nc: _Float_DT | _ToSubFloat,
+        f: _Float_DT | _ToSubFloat,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw41f],
-    ) -> _FloatNDT: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41f],
+    ) -> _Float_DT: ...
     @overload
     def __call__(
         self,
-        dfn: onp.ToFloat | onp.ToFloatND,
-        dfd: onp.ToFloat | onp.ToFloatND,
-        nc: onp.ToFloat | onp.ToFloatND,
+        dfn: _ToFloat_D,
+        dfd: _ToFloat_D,
+        nc: _ToFloat_D,
         f: onp.ToFloatND,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw41f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41f],
+    ) -> _FloatND: ...
     @overload
     def __call__(
         self,
-        dfn: onp.ToFloat | onp.ToFloatND,
-        dfd: onp.ToFloat | onp.ToFloatND,
+        dfn: _ToFloat_D,
+        dfd: _ToFloat_D,
         nc: onp.ToFloatND,
-        f: onp.ToFloat | onp.ToFloatND,
+        f: _ToFloat_D,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw41f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41f],
+    ) -> _FloatND: ...
     @overload
     def __call__(
         self,
-        dfn: onp.ToFloat | onp.ToFloatND,
+        dfn: _ToFloat_D,
         dfd: onp.ToFloatND,
-        nc: onp.ToFloat | onp.ToFloatND,
-        f: onp.ToFloat | onp.ToFloatND,
+        nc: _ToFloat_D,
+        f: _ToFloat_D,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw41f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41f],
+    ) -> _FloatND: ...
     @overload
     def __call__(
         self,
         dfn: onp.ToFloatND,
-        dfd: onp.ToFloat | onp.ToFloatND,
-        nc: onp.ToFloat | onp.ToFloatND,
-        f: onp.ToFloat | onp.ToFloatND,
+        dfd: _ToFloat_D,
+        nc: _ToFloat_D,
+        f: _ToFloat_D,
         /,
-        out: tuple[None] | None = None,
-        **kwargs: Unpack[_Kw41f],
-    ) -> onp.ArrayND[_Float]: ...
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41f],
+    ) -> _FloatND: ...
     @overload
     def __call__(
         self,
-        dfn: onp.ToFloat | onp.ToFloatND,
-        dfd: onp.ToFloat | onp.ToFloatND,
-        nc: onp.ToFloat | onp.ToFloatND,
-        f: onp.ToFloat | onp.ToFloatND,
+        dfn: _ToFloat_D,
+        dfd: _ToFloat_D,
+        nc: _ToFloat_D,
+        f: _ToFloat_D,
         /,
-        out: tuple[_OutT] | _OutT,
-        **kwargs: Unpack[_Kw41f],
+        out: _Out1[_OutT],
+        **kw: Unpack[_Kw41f],
+    ) -> _OutT: ...
+
+@final
+@type_check_only
+class _UFunc41fc1(_UFunc41[_NameT_co, _IdentityT_co], Generic[_NameT_co, _IdentityT_co]):
+    # `eval_[sh_]jacobi` and `hyp2f1`
+    @property
+    @override
+    def ntypes(self, /) -> L[4, 5]: ...
+    @property
+    @override
+    def types(self, /) -> list[L["ffff->f", "lddd->d", "dddd->d", "fffF->F", "dddD->D"]]: ...
+    #
+    @overload
+    def __call__(
+        self,
+        n: _ToSubFloat,
+        a: _ToSubFloat,
+        b: _ToSubFloat,
+        x: _ToSubFloat,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _Float: ...
+    @overload
+    def __call__(
+        self,
+        n: _Float_DT | _ToSubFloat,
+        a: _Float_DT | _ToSubFloat,
+        b: _Float_DT | _ToSubFloat,
+        x: _Float_DT | _ToSubFloat,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _Float_DT: ...
+    @overload
+    def __call__(
+        self,
+        n: onp.ToFloat | np.complex64,
+        a: onp.ToFloat | np.complex64,
+        b: onp.ToFloat | np.complex64,
+        x: _Complex_DT,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _Complex_DT: ...
+    @overload
+    def __call__(
+        self,
+        n: _ToFloat_D,
+        a: _ToFloat_D,
+        b: _ToFloat_D,
+        x: onp.ToFloatND,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _FloatND: ...
+    @overload
+    def __call__(
+        self,
+        n: _ToFloat_D,
+        a: _ToFloat_D,
+        b: onp.ToFloatND,
+        x: _ToFloat_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _FloatND: ...
+    @overload
+    def __call__(
+        self,
+        n: _ToFloat_D,
+        a: onp.ToFloatND,
+        b: _ToFloat_D,
+        x: _ToFloat_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _FloatND: ...
+    @overload
+    def __call__(
+        self,
+        n: onp.ToFloatND,
+        a: _ToFloat_D,
+        b: _ToFloat_D,
+        x: _ToFloat_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _FloatND: ...
+    @overload
+    def __call__(
+        self,
+        n: _ToFloat_D,
+        a: _ToFloat_D,
+        b: _ToFloat_D,
+        x: onp.ToComplexND,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _InexactND: ...
+    @overload
+    def __call__(
+        self,
+        n: _ToFloat_D,
+        a: _ToFloat_D,
+        b: onp.ToFloatND,
+        x: _ToComplex_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _InexactND: ...
+    @overload
+    def __call__(
+        self,
+        n: _ToFloat_D,
+        a: onp.ToFloatND,
+        b: _ToFloat_D,
+        x: _ToComplex_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _InexactND: ...
+    @overload
+    def __call__(
+        self,
+        n: onp.ToFloatND,
+        a: _ToFloat_D,
+        b: _ToFloat_D,
+        x: _ToComplex_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_Kw41fc1],
+    ) -> _InexactND: ...
+    @overload
+    def __call__(
+        self,
+        n: _ToFloat_D,
+        a: _ToFloat_D,
+        b: _ToFloat_D,
+        x: _ToComplex_D,
+        /,
+        out: _Out1[_OutT],
+        **kw: Unpack[_Kw41fc1],
+    ) -> _OutT: ...
+
+@final
+@type_check_only
+class _UFuncSphHarm(_UFunc41[L["sph_harm"], None]):
+    @property
+    @override
+    def ntypes(self, /) -> L[4]: ...
+    @property
+    @override
+    def types(self, /) -> list[L["qqff->F", "ffff->F", "qqdd->D", "dddd->D"]]: ...
+    #
+    @overload
+    @deprecated("This function is deprecated and will be removed in SciPy 1.17.0. Use `scipy.special.sph_harm_y` instead.")
+    def __call__(
+        self,
+        m: onp.ToFloat,
+        n: onp.ToFloat,
+        theta: onp.ToFloat,
+        phi: onp.ToFloat,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_KwSphHarm],
+    ) -> _Complex: ...
+    @overload
+    @deprecated("This function is deprecated and will be removed in SciPy 1.17.0. Use `scipy.special.sph_harm_y` instead.")
+    def __call__(
+        self,
+        m: _ToFloat_D,
+        n: _ToFloat_D,
+        theta: _ToFloat_D,
+        phi: onp.ToFloatND,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_KwSphHarm],
+    ) -> _ComplexND: ...
+    @overload
+    @deprecated("This function is deprecated and will be removed in SciPy 1.17.0. Use `scipy.special.sph_harm_y` instead.")
+    def __call__(
+        self,
+        m: _ToFloat_D,
+        n: _ToFloat_D,
+        theta: onp.ToFloatND,
+        phi: _ToFloat_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_KwSphHarm],
+    ) -> _ComplexND: ...
+    @overload
+    @deprecated("This function is deprecated and will be removed in SciPy 1.17.0. Use `scipy.special.sph_harm_y` instead.")
+    def __call__(
+        self,
+        m: _ToFloat_D,
+        n: onp.ToFloatND,
+        theta: _ToFloat_D,
+        phi: _ToFloat_D,
+        /,
+        out: _Out1 = None,
+        **kw: Unpack[_KwSphHarm],
+    ) -> _ComplexND: ...
+    @overload
+    @deprecated("This function is deprecated and will be removed in SciPy 1.17.0. Use `scipy.special.sph_harm_y` instead.")
+    def __call__(
+        self,
+        m: _ToFloat_D,
+        n: _ToFloat_D,
+        theta: _ToFloat_D,
+        phi: _ToFloat_D,
+        /,
+        out: _Out1[_OutT],
+        **kw: Unpack[_KwSphHarm],
     ) -> _OutT: ...
 
 ###
@@ -1373,396 +1440,405 @@ class errstate(EnterNoneMixin):
 _sf_error_test_function: np.ufunc
 
 # f->f; d->d
-_cosine_cdf: _UFunc11f[L["_cosine_cdf"], L[0]]
-_cosine_invcdf: _UFunc11f[L["_cosine_invcdf"], L[0]]
-_factorial: _UFunc11f[L["_factorial"], L[0]]
-_kolmogc: _UFunc11f[L["_kolmogc"], L[0]]
-_kolmogci: _UFunc11f[L["_kolmogci"], L[0]]
-_kolmogp: _UFunc11f[L["_kolmogp"], L[0]]
-_lanczos_sum_expg_scaled: _UFunc11f[L["_lanczos_sum_expg_scaled"], L[0]]
-_lgam1p: _UFunc11f[L["_lgam1p"], L[0]]
-_log1pmx: _UFunc11f[L["_log1pmx"], L[0]]
-_riemann_zeta: _UFunc11f[L["_riemann_zeta"], L[0]]
-_scaled_exp1: _UFunc11f[L["_scaled_exp1"]]
-bei: _UFunc11f[L["bei"]]
-beip: _UFunc11f[L["beip"]]
-ber: _UFunc11f[L["ber"]]
-berp: _UFunc11f[L["berp"]]
-cbrt: _UFunc11f[L["cbrt"], L[0]]
-cosdg: _UFunc11f[L["cosdg"], L[0]]
-cosm1: _UFunc11f[L["cosm1"], L[0]]
-cotdg: _UFunc11f[L["cotdg"], L[0]]
-ellipe: _UFunc11f[L["ellipe"], L[0]]
-ellipk: _UFunc11f[L["ellipk"], L[0]]
-ellipkm1: _UFunc11f[L["ellipkm1"], L[0]]
-entr: _UFunc11f[L["entr"], L[0]]
-erfcinv: _UFunc11f[L["erfcinv"], L[0]]
-erfinv: _UFunc11f[L["erfinv"], L[0]]
-exp10: _UFunc11f[L["exp10"], L[0]]
-exp2: _UFunc11f[L["exp2"], L[0]]
-exprel: _UFunc11f[L["exprel"]]
-gammaln: _UFunc11f[L["gammaln"]]
-gammasgn: _UFunc11f[L["gammasgn"], L[0]]
-i0: _UFunc11f[L["i0"], L[0]]
-i0e: _UFunc11f[L["i0e"], L[0]]
-i1: _UFunc11f[L["i1"], L[0]]
-i1e: _UFunc11f[L["i1e"], L[0]]
-it2struve0: _UFunc11f[L["it2struve0"]]
-itmodstruve0: _UFunc11f[L["itmodstruve0"]]
-itstruve0: _UFunc11f[L["itstruve0"]]
-j0: _UFunc11f[L["j0"], L[0]]
-j1: _UFunc11f[L["j1"], L[0]]
-k0: _UFunc11f[L["k0"], L[0]]
-k0e: _UFunc11f[L["k0e"], L[0]]
-k1: _UFunc11f[L["k1"], L[0]]
-k1e: _UFunc11f[L["k1e"], L[0]]
-kei: _UFunc11f[L["kei"]]
-keip: _UFunc11f[L["keip"]]
-ker: _UFunc11f[L["ker"]]
-kerp: _UFunc11f[L["kerp"]]
-kolmogi: _UFunc11f[L["kolmogi"], L[0]]
-kolmogorov: _UFunc11f[L["kolmogorov"], L[0]]
-ndtri: _UFunc11f[L["ndtri"], L[0]]
-ndtri_exp: _UFunc11f[L["ndtri_exp"], L[0]]
-round: _UFunc11f[L["round"], L[0]]
-sindg: _UFunc11f[L["sindg"], L[0]]
-tandg: _UFunc11f[L["tandg"], L[0]]
-y0: _UFunc11f[L["y0"], L[0]]
-y1: _UFunc11f[L["y1"], L[0]]
-zetac: _UFunc11f[L["zetac"], L[0]]
+_cosine_cdf: _UFunc11f[L["_cosine_cdf"], L[0]] = ...
+_cosine_invcdf: _UFunc11f[L["_cosine_invcdf"], L[0]] = ...
+_factorial: _UFunc11f[L["_factorial"], L[0]] = ...
+_kolmogc: _UFunc11f[L["_kolmogc"], L[0]] = ...
+_kolmogci: _UFunc11f[L["_kolmogci"], L[0]] = ...
+_kolmogp: _UFunc11f[L["_kolmogp"], L[0]] = ...
+_lanczos_sum_expg_scaled: _UFunc11f[L["_lanczos_sum_expg_scaled"], L[0]] = ...
+_lgam1p: _UFunc11f[L["_lgam1p"], L[0]] = ...
+_log1pmx: _UFunc11f[L["_log1pmx"], L[0]] = ...
+_scaled_exp1: _UFunc11f[L["_scaled_exp1"]] = ...
+bei: _UFunc11f[L["bei"]] = ...
+beip: _UFunc11f[L["beip"]] = ...
+ber: _UFunc11f[L["ber"]] = ...
+berp: _UFunc11f[L["berp"]] = ...
+cbrt: _UFunc11f[L["cbrt"], L[0]] = ...
+cosdg: _UFunc11f[L["cosdg"], L[0]] = ...
+cosm1: _UFunc11f[L["cosm1"], L[0]] = ...
+cotdg: _UFunc11f[L["cotdg"], L[0]] = ...
+ellipe: _UFunc11f[L["ellipe"], L[0]] = ...
+ellipk: _UFunc11f[L["ellipk"], L[0]] = ...
+ellipkm1: _UFunc11f[L["ellipkm1"], L[0]] = ...
+entr: _UFunc11f[L["entr"], L[0]] = ...
+erfcinv: _UFunc11f[L["erfcinv"], L[0]] = ...
+erfinv: _UFunc11f[L["erfinv"], L[0]] = ...
+exp10: _UFunc11f[L["exp10"], L[0]] = ...
+exp2: _UFunc11f[L["exp2"], L[0]] = ...
+exprel: _UFunc11f[L["exprel"]] = ...
+gammaln: _UFunc11f[L["gammaln"]] = ...
+gammasgn: _UFunc11f[L["gammasgn"], L[0]] = ...
+i0: _UFunc11f[L["i0"], L[0]] = ...
+i0e: _UFunc11f[L["i0e"], L[0]] = ...
+i1: _UFunc11f[L["i1"], L[0]] = ...
+i1e: _UFunc11f[L["i1e"], L[0]] = ...
+it2struve0: _UFunc11f[L["it2struve0"]] = ...
+itmodstruve0: _UFunc11f[L["itmodstruve0"]] = ...
+itstruve0: _UFunc11f[L["itstruve0"]] = ...
+j0: _UFunc11f[L["j0"], L[0]] = ...
+j1: _UFunc11f[L["j1"], L[0]] = ...
+k0: _UFunc11f[L["k0"], L[0]] = ...
+k0e: _UFunc11f[L["k0e"], L[0]] = ...
+k1: _UFunc11f[L["k1"], L[0]] = ...
+k1e: _UFunc11f[L["k1e"], L[0]] = ...
+kei: _UFunc11f[L["kei"]] = ...
+keip: _UFunc11f[L["keip"]] = ...
+ker: _UFunc11f[L["ker"]] = ...
+kerp: _UFunc11f[L["kerp"]] = ...
+kolmogi: _UFunc11f[L["kolmogi"], L[0]] = ...
+kolmogorov: _UFunc11f[L["kolmogorov"], L[0]] = ...
+ndtri: _UFunc11f[L["ndtri"], L[0]] = ...
+ndtri_exp: _UFunc11f[L["ndtri_exp"], L[0]] = ...
+round: _UFunc11f[L["round"], L[0]] = ...
+sindg: _UFunc11f[L["sindg"], L[0]] = ...
+tandg: _UFunc11f[L["tandg"], L[0]] = ...
+y0: _UFunc11f[L["y0"], L[0]] = ...
+y1: _UFunc11f[L["y1"], L[0]] = ...
+zetac: _UFunc11f[L["zetac"], L[0]] = ...
 
 # f->f; d->d; g->g
-expit: _UFunc11g[L["expit"]]
-log_expit: _UFunc11g[L["log_expit"]]
-logit: _UFunc11g[L["logit"]]
+expit: _UFunc11g[L["expit"]] = ...
+log_expit: _UFunc11g[L["log_expit"]] = ...
+logit: _UFunc11g[L["logit"]] = ...
 
 # F->F; D->D
-wofz: _UFunc11c[L["wofz"], L[0]]
+wofz: _UFunc11c[L["wofz"], L[0]] = ...
 
 # f->f; d->d; F->F; D->D
-_cospi: _UFunc11fc[L["_cospi"]]
-_sinpi: _UFunc11fc[L["_sinpi"]]
-dawsn: _UFunc11fc[L["dawsn"], L[0]]
-erf: _UFunc11fc[L["erf"], L[0]]
-erfc: _UFunc11fc[L["erfc"], L[0]]
-erfcx: _UFunc11fc[L["erfcx"], L[0]]
-erfi: _UFunc11fc[L["erfi"], L[0]]
-exp1: _UFunc11fc[L["exp1"]]
-expi: _UFunc11fc[L["expi"]]
-expm1: _UFunc11fc[L["expm1"], L[0]]
-gamma: _UFunc11fc[L["gamma"]]
-log1p: _UFunc11fc[L["log1p"], L[0]]
-log_ndtr: _UFunc11fc[L["log_ndtr"], L[0]]
-loggamma: _UFunc11fc[L["loggamma"]]
-ndtr: _UFunc11fc[L["ndtr"], L[0]]
-psi: _UFunc11fc[L["psi"]]
-rgamma: _UFunc11fc[L["rgamma"]]
-spence: _UFunc11fc[L["spence"], L[0]]
-wrightomega: _UFunc11fc[L["wrightomega"], L[0]]
+_cospi: _UFunc11fc[L["_cospi"]] = ...
+_sinpi: _UFunc11fc[L["_sinpi"]] = ...
+_riemann_zeta: _UFunc11fc[L["_riemann_zeta"], L[0]] = ...
+dawsn: _UFunc11fc[L["dawsn"], L[0]] = ...
+erf: _UFunc11fc[L["erf"], L[0]] = ...
+erfc: _UFunc11fc[L["erfc"], L[0]] = ...
+erfcx: _UFunc11fc[L["erfcx"], L[0]] = ...
+erfi: _UFunc11fc[L["erfi"], L[0]] = ...
+exp1: _UFunc11fc[L["exp1"]] = ...
+expi: _UFunc11fc[L["expi"]] = ...
+expm1: _UFunc11fc[L["expm1"], L[0]] = ...
+gamma: _UFunc11fc[L["gamma"]] = ...
+log1p: _UFunc11fc[L["log1p"], L[0]] = ...
+log_ndtr: _UFunc11fc[L["log_ndtr"], L[0]] = ...
+loggamma: _UFunc11fc[L["loggamma"]] = ...
+ndtr: _UFunc11fc[L["ndtr"], L[0]] = ...
+psi: _UFunc11fc[L["psi"]] = ...
+rgamma: _UFunc11fc[L["rgamma"]] = ...
+spence: _UFunc11fc[L["spence"], L[0]] = ...
+wrightomega: _UFunc11fc[L["wrightomega"], L[0]] = ...
 
 # f->ff; d->dd
 # TODO
-it2i0k0: np.ufunc
-it2j0y0: np.ufunc
-iti0k0: np.ufunc
-itj0y0: np.ufunc
+it2i0k0: np.ufunc = ...
+it2j0y0: np.ufunc = ...
+iti0k0: np.ufunc = ...
+itj0y0: np.ufunc = ...
 
 # f->FF; d->DD
 # TODO
-modfresnelm: np.ufunc
-modfresnelp: np.ufunc
+modfresnelm: np.ufunc = ...
+modfresnelp: np.ufunc = ...
 
 # f->ff; d->dd; f->FF; D->DD
 # TODO
-fresnel: np.ufunc
-shichi: np.ufunc
-sici: np.ufunc
+fresnel: np.ufunc = ...
+shichi: np.ufunc = ...
+sici: np.ufunc = ...
 
 # f->ffff; d->dddd
 # TODO
-itairy: np.ufunc
+itairy: np.ufunc = ...
 
 # f->FFFF; d->DDDD
 # TODO
-kelvin: np.ufunc
+kelvin: np.ufunc = ...
 
 # f->ffff; d->dddd; F->FFFF; D->DDDD
 # TODO
-airy: np.ufunc
-airye: np.ufunc
+airy: np.ufunc = ...
+airye: np.ufunc = ...
 
 # ld->d
-eval_hermite: _UFunc21ld[L["eval_hermite"], L[0]]
-eval_hermitenorm: _UFunc21ld[L["eval_hermitenorm"], L[0]]
+eval_hermite: _UFunc21ld[L["eval_hermite"], L[0]] = ...
+eval_hermitenorm: _UFunc21ld[L["eval_hermitenorm"], L[0]] = ...
 
 # ff->f; (l|d)d->d
-_igam_fac: _UFunc21f[L["_igam_fac"], L[0]]
-_iv_ratio: _UFunc21f[L["_iv_ratio"], L[0]]
-_nbinom_mean: _UFunc21f[L["_nbinom_mean"], L[0]]
-_nbinom_variance: _UFunc21f[L["_nbinom_variance"], L[0]]
-_nbinom_skewness: _UFunc21f[L["_nbinom_skewness"], L[0]]
-_nbinom_kurtosis_excess: _UFunc21f[L["_nbinom_kurtosis_excess"], L[0]]
-_nct_mean: _UFunc21f[L["_nct_mean"], L[0]]
-_nct_variance: _UFunc21f[L["_nct_variance"], L[0]]
-_nct_skewness: _UFunc21f[L["_nct_skewness"], L[0]]
-_nct_kurtosis_excess: _UFunc21f[L["_nct_kurtosis_excess"], L[0]]
-_smirnovc: _UFunc21f[L["_smirnovc"], L[0]]
-_smirnovci: _UFunc21f[L["_smirnovci"], L[0]]
-_smirnovp: _UFunc21f[L["_smirnovp"], L[0]]
-_stirling2_inexact: _UFunc21f[L["_stirling2_inexact"]]
-_zeta: _UFunc21f[L["_zeta"], L[0]]
-agm: _UFunc21f[L["agm"], L[0]]
-beta: _UFunc21f[L["beta"], L[0]]
-betaln: _UFunc21f[L["betaln"], L[0]]
-binom: _UFunc21f[L["binom"]]
-boxcox: _UFunc21f[L["boxcox"], L[0]]
-boxcox1p: _UFunc21f[L["boxcox1p"], L[0]]
-chdtr: _UFunc21f[L["chdtr"], L[0]]
-chdtrc: _UFunc21f[L["chdtrc"], L[0]]
-chdtri: _UFunc21f[L["chdtri"], L[0]]
-chdtriv: _UFunc21f[L["chdtriv"], L[0]]
-ellipeinc: _UFunc21f[L["ellipeinc"], L[0]]
-ellipkinc: _UFunc21f[L["ellipkinc"], L[0]]
-expn: _UFunc21f[L["expn"], L[0]]
-gammainc: _UFunc21f[L["gammainc"], L[0]]
-gammaincc: _UFunc21f[L["gammaincc"], L[0]]
-gammainccinv: _UFunc21f[L["gammainccinv"], L[0]]
-gammaincinv: _UFunc21f[L["gammaincinv"], L[0]]
-huber: _UFunc21f[L["huber"], L[0]]
-inv_boxcox1p: _UFunc21f[L["inv_boxcox1p"], L[0]]
-inv_boxcox: _UFunc21f[L["inv_boxcox"], L[0]]
-kl_div: _UFunc21f[L["kl_div"], L[0]]
-kn: _UFunc21f[L["kn"], L[0]]
-mathieu_a: _UFunc21f[L["mathieu_a"]]
-mathieu_b: _UFunc21f[L["mathieu_b"]]
-modstruve: _UFunc21f[L["modstruve"], L[0]]
-owens_t: _UFunc21f[L["owens_t"], L[0]]
-pdtr: _UFunc21f[L["pdtr"], L[0]]
-pdtrc: _UFunc21f[L["pdtrc"], L[0]]
-pdtri: _UFunc21f[L["pdtri"], L[0]]
-pdtrik: _UFunc21f[L["pdtrik"], L[0]]
-poch: _UFunc21f[L["poch"], L[0]]
-powm1: _UFunc21f[L["powm1"], L[0]]
-pseudo_huber: _UFunc21f[L["pseudo_huber"], L[0]]
-rel_entr: _UFunc21f[L["rel_entr"], L[0]]
-smirnov: _UFunc21f[L["smirnov"], L[0]]
-smirnovi: _UFunc21f[L["smirnovi"], L[0]]
-stdtr: _UFunc21f[L["stdtr"], L[0]]
-stdtridf: _UFunc21f[L["stdtridf"], L[0]]
-stdtrit: _UFunc21f[L["stdtrit"], L[0]]
-struve: _UFunc21f[L["struve"], L[0]]
-tklmbda: _UFunc21f[L["tklmbda"], L[0]]
-yn: _UFunc21f[L["yn"], L[0]]
+_igam_fac: _UFunc21f[L["_igam_fac"], L[0]] = ...
+_iv_ratio: _UFunc21f[L["_iv_ratio"], L[0]] = ...
+_iv_ratio_c: _UFunc21f[L["_iv_ratio_c"], L[0]] = ...
+_nbinom_mean: _UFunc21f[L["_nbinom_mean"], L[0]] = ...
+_nbinom_variance: _UFunc21f[L["_nbinom_variance"], L[0]] = ...
+_nbinom_skewness: _UFunc21f[L["_nbinom_skewness"], L[0]] = ...
+_nbinom_kurtosis_excess: _UFunc21f[L["_nbinom_kurtosis_excess"], L[0]] = ...
+_nct_mean: _UFunc21f[L["_nct_mean"], L[0]] = ...
+_nct_variance: _UFunc21f[L["_nct_variance"], L[0]] = ...
+_nct_skewness: _UFunc21f[L["_nct_skewness"], L[0]] = ...
+_nct_kurtosis_excess: _UFunc21f[L["_nct_kurtosis_excess"], L[0]] = ...
+_smirnovc: _UFunc21f[L["_smirnovc"], L[0]] = ...
+_smirnovci: _UFunc21f[L["_smirnovci"], L[0]] = ...
+_smirnovp: _UFunc21f[L["_smirnovp"], L[0]] = ...
+_stirling2_inexact: _UFunc21f[L["_stirling2_inexact"]] = ...
+agm: _UFunc21f[L["agm"], L[0]] = ...
+beta: _UFunc21f[L["beta"], L[0]] = ...
+betaln: _UFunc21f[L["betaln"], L[0]] = ...
+binom: _UFunc21f[L["binom"]] = ...
+boxcox: _UFunc21f[L["boxcox"], L[0]] = ...
+boxcox1p: _UFunc21f[L["boxcox1p"], L[0]] = ...
+chdtr: _UFunc21f[L["chdtr"], L[0]] = ...
+chdtrc: _UFunc21f[L["chdtrc"], L[0]] = ...
+chdtri: _UFunc21f[L["chdtri"], L[0]] = ...
+chdtriv: _UFunc21f[L["chdtriv"], L[0]] = ...
+ellipeinc: _UFunc21f[L["ellipeinc"], L[0]] = ...
+ellipkinc: _UFunc21f[L["ellipkinc"], L[0]] = ...
+expn: _UFunc21f[L["expn"], L[0]] = ...
+gammainc: _UFunc21f[L["gammainc"], L[0]] = ...
+gammaincc: _UFunc21f[L["gammaincc"], L[0]] = ...
+gammainccinv: _UFunc21f[L["gammainccinv"], L[0]] = ...
+gammaincinv: _UFunc21f[L["gammaincinv"], L[0]] = ...
+huber: _UFunc21f[L["huber"], L[0]] = ...
+inv_boxcox1p: _UFunc21f[L["inv_boxcox1p"], L[0]] = ...
+inv_boxcox: _UFunc21f[L["inv_boxcox"], L[0]] = ...
+kl_div: _UFunc21f[L["kl_div"], L[0]] = ...
+kn: _UFunc21f[L["kn"], L[0]] = ...
+mathieu_a: _UFunc21f[L["mathieu_a"]] = ...
+mathieu_b: _UFunc21f[L["mathieu_b"]] = ...
+modstruve: _UFunc21f[L["modstruve"], L[0]] = ...
+owens_t: _UFunc21f[L["owens_t"], L[0]] = ...
+pdtr: _UFunc21f[L["pdtr"], L[0]] = ...
+pdtrc: _UFunc21f[L["pdtrc"], L[0]] = ...
+pdtri: _UFunc21f[L["pdtri"], L[0]] = ...
+pdtrik: _UFunc21f[L["pdtrik"], L[0]] = ...
+poch: _UFunc21f[L["poch"], L[0]] = ...
+powm1: _UFunc21f[L["powm1"], L[0]] = ...
+pseudo_huber: _UFunc21f[L["pseudo_huber"], L[0]] = ...
+rel_entr: _UFunc21f[L["rel_entr"], L[0]] = ...
+smirnov: _UFunc21f[L["smirnov"], L[0]] = ...
+smirnovi: _UFunc21f[L["smirnovi"], L[0]] = ...
+stdtr: _UFunc21f[L["stdtr"], L[0]] = ...
+stdtridf: _UFunc21f[L["stdtridf"], L[0]] = ...
+stdtrit: _UFunc21f[L["stdtrit"], L[0]] = ...
+struve: _UFunc21f[L["struve"], L[0]] = ...
+tklmbda: _UFunc21f[L["tklmbda"], L[0]] = ...
+yn: _UFunc21f[L["yn"], L[0]] = ...
 
 # fF->F; dD->D
 # TODO
-hankel1: np.ufunc
-hankel1e: np.ufunc
-hankel2: np.ufunc
-hankel2e: np.ufunc
+hankel1: np.ufunc = ...
+hankel1e: np.ufunc = ...
+hankel2: np.ufunc = ...
+hankel2e: np.ufunc = ...
 
 # ff->f; (l|d)d->d; fF->F; dD->D
-eval_chebyc: _UFunc21fc1[L["eval_chebyc"], L[0]]
-eval_chebys: _UFunc21fc1[L["eval_chebys"], L[0]]
-eval_chebyt: _UFunc21fc1[L["eval_chebyt"], L[0]]
-eval_chebyu: _UFunc21fc1[L["eval_chebyu"], L[0]]
-eval_laguerre: _UFunc21fc1[L["eval_laguerre"], L[0]]
-eval_legendre: _UFunc21fc1[L["eval_legendre"], L[0]]
-eval_sh_chebyt: _UFunc21fc1[L["eval_sh_chebyt"], L[0]]
-eval_sh_chebyu: _UFunc21fc1[L["eval_sh_chebyu"], L[0]]
-eval_sh_legendre: _UFunc21fc1[L["eval_sh_legendre"], L[0]]
-hyp0f1: _UFunc21fc1[L["hyp0f1"], L[0]]
-iv: _UFunc21fc1[L["iv"]]
-ive: _UFunc21fc1[L["ive"]]
-jn: _UFunc21fc1[L["jn"]]
-jv: _UFunc21fc1[L["jv"]]
-jve: _UFunc21fc1[L["jve"]]
-kv: _UFunc21fc1[L["kv"]]
-kve: _UFunc21fc1[L["kve"]]
-yv: _UFunc21fc1[L["yv"]]
-yve: _UFunc21fc1[L["yve"]]
+eval_chebyc: _UFunc21fc1[L["eval_chebyc"], L[0]] = ...
+eval_chebys: _UFunc21fc1[L["eval_chebys"], L[0]] = ...
+eval_chebyt: _UFunc21fc1[L["eval_chebyt"], L[0]] = ...
+eval_chebyu: _UFunc21fc1[L["eval_chebyu"], L[0]] = ...
+eval_laguerre: _UFunc21fc1[L["eval_laguerre"], L[0]] = ...
+eval_legendre: _UFunc21fc1[L["eval_legendre"], L[0]] = ...
+eval_sh_chebyt: _UFunc21fc1[L["eval_sh_chebyt"], L[0]] = ...
+eval_sh_chebyu: _UFunc21fc1[L["eval_sh_chebyu"], L[0]] = ...
+eval_sh_legendre: _UFunc21fc1[L["eval_sh_legendre"], L[0]] = ...
+hyp0f1: _UFunc21fc1[L["hyp0f1"], L[0]] = ...
+iv: _UFunc21fc1[L["iv"]] = ...
+ive: _UFunc21fc1[L["ive"]] = ...
+jn: _UFunc21fc1[L["jn"]] = ...
+jv: _UFunc21fc1[L["jv"]] = ...
+jve: _UFunc21fc1[L["jve"]] = ...
+kv: _UFunc21fc1[L["kv"]] = ...
+kve: _UFunc21fc1[L["kve"]] = ...
+yv: _UFunc21fc1[L["yv"]] = ...
+yve: _UFunc21fc1[L["yve"]] = ...
 
 # lf->f; ld->d; lF->F; lD->D
-_spherical_in: np.ufunc
-_spherical_in_d: np.ufunc
-_spherical_jn: np.ufunc
-_spherical_jn_d: np.ufunc
-_spherical_kn: np.ufunc
-_spherical_kn_d: np.ufunc
-_spherical_yn: np.ufunc
-_spherical_yn_d: np.ufunc
+_spherical_in: np.ufunc = ...
+_spherical_in_d: np.ufunc = ...
+_spherical_jn: np.ufunc = ...
+_spherical_jn_d: np.ufunc = ...
+_spherical_kn: np.ufunc = ...
+_spherical_kn_d: np.ufunc = ...
+_spherical_yn: np.ufunc = ...
+_spherical_yn_d: np.ufunc = ...
 
 # ff->f; dd->d; FF->F; DD->D
-elliprc: _UFunc21fc2[L["elliprc"], L[0]]
-xlog1py: _UFunc21fc2[L["xlog1py"], L[0]]
-xlogy: _UFunc21fc2[L["xlogy"], L[0]]
+elliprc: _UFunc21fc2[L["elliprc"], L[0]] = ...
+xlog1py: _UFunc21fc2[L["xlog1py"], L[0]] = ...
+xlogy: _UFunc21fc2[L["xlogy"], L[0]] = ...
+
+# ff->f; dd->d; Ff->F; Dd->D
+_zeta: np.ufunc = ...
 
 # ff->ff; dd->dd
 # TODO
-pbdv: np.ufunc
-pbvv: np.ufunc
-pbwa: np.ufunc
+pbdv: np.ufunc = ...
+pbvv: np.ufunc = ...
+pbwa: np.ufunc = ...
 
 # ff->ffff; dd->dddd
 # TODO
-ellipj: np.ufunc
+ellipj: np.ufunc = ...
 
 # fff->f; (ll|dl|dd)d->d
-_beta_pdf: _UFunc31f[L["_beta_pdf"], L[0]]
-_beta_ppf: _UFunc31f[L["_beta_ppf"], L[0]]
-_binom_cdf: _UFunc31f[L["_binom_cdf"], L[0]]
-_binom_isf: _UFunc31f[L["_binom_isf"], L[0]]
-_binom_pmf: _UFunc31f[L["_binom_pmf"], L[0]]
-_binom_ppf: _UFunc31f[L["_binom_ppf"], L[0]]
-_binom_sf: _UFunc31f[L["_binom_sf"], L[0]]
-_hypergeom_mean: _UFunc31f[L["_hypergeom_mean"], L[0]]
-_hypergeom_skewness: _UFunc31f[L["_hypergeom_skewness"], L[0]]
-_hypergeom_variance: _UFunc31f[L["_hypergeom_variance"], L[0]]
-_invgauss_isf: _UFunc31f[L["_invgauss_isf"], L[0]]
-_invgauss_ppf: _UFunc31f[L["_invgauss_ppf"], L[0]]
-_nbinom_cdf: _UFunc31f[L["_nbinom_cdf"], L[0]]
-_nbinom_isf: _UFunc31f[L["_nbinom_isf"], L[0]]
-_nbinom_pmf: _UFunc31f[L["_nbinom_pmf"], L[0]]
-_nbinom_ppf: _UFunc31f[L["_nbinom_ppf"], L[0]]
-_nbinom_sf: _UFunc31f[L["_nbinom_sf"], L[0]]
-_ncf_kurtosis_excess: _UFunc31f[L["_ncf_kurtosis_excess"], L[0]]
-_ncf_mean: _UFunc31f[L["_ncf_mean"], L[0]]
-_ncf_skewness: _UFunc31f[L["_ncf_skewness"], L[0]]
-_ncf_variance: _UFunc31f[L["_ncf_variance"], L[0]]
-_nct_cdf: _UFunc31f[L["_nct_cdf"], L[0]]
-_nct_isf: _UFunc31f[L["_nct_isf"], L[0]]
-_nct_ppf: _UFunc31f[L["_nct_ppf"], L[0]]
-_nct_sf: _UFunc31f[L["_nct_sf"], L[0]]
-_ncx2_cdf: _UFunc31f[L["_ncx2_cdf"], L[0]]
-_ncx2_isf: _UFunc31f[L["_ncx2_isf"], L[0]]
-_ncx2_pdf: _UFunc31f[L["_ncx2_pdf"], L[0]]
-_ncx2_ppf: _UFunc31f[L["_ncx2_ppf"], L[0]]
-_ncx2_sf: _UFunc31f[L["_ncx2_sf"], L[0]]
-bdtr: _UFunc31f[L["bdtr"], L[0]]
-bdtrc: _UFunc31f[L["bdtrc"], L[0]]
-bdtri: _UFunc31f[L["bdtri"], L[0]]
-bdtrik: _UFunc31f[L["bdtrik"], L[0]]
-bdtrin: _UFunc31f[L["bdtrin"], L[0]]
-besselpoly: _UFunc31f[L["besselpoly"], L[0]]
-betainc: _UFunc31f[L["betainc"], L[0]]
-betaincc: _UFunc31f[L["betaincc"], L[0]]
-betainccinv: _UFunc31f[L["betainccinv"], L[0]]
-betaincinv: _UFunc31f[L["betaincinv"], L[0]]
-btdtr: _UFunc31f[L["btdtr"], L[0]]
-btdtri: _UFunc31f[L["btdtri"], L[0]]
-btdtria: _UFunc31f[L["btdtria"], L[0]]
-btdtrib: _UFunc31f[L["btdtrib"], L[0]]
-chndtr: _UFunc31f[L["chndtr"], L[0]]
-chndtridf: _UFunc31f[L["chndtridf"], L[0]]
-chndtrinc: _UFunc31f[L["chndtrinc"], L[0]]
-chndtrix: _UFunc31f[L["chndtrix"], L[0]]
-fdtr: _UFunc31f[L["fdtr"], L[0]]
-fdtrc: _UFunc31f[L["fdtrc"], L[0]]
-fdtri: _UFunc31f[L["fdtri"], L[0]]
-fdtridfd: _UFunc31f[L["fdtridfd"], L[0]]
-gdtr: _UFunc31f[L["gdtr"], L[0]]
-gdtrc: _UFunc31f[L["gdtrc"], L[0]]
-gdtria: _UFunc31f[L["gdtria"], L[0]]
-gdtrib: _UFunc31f[L["gdtrib"], L[0]]
-gdtrix: _UFunc31f[L["gdtrix"], L[0]]
-hyperu: _UFunc31f[L["hyperu"], L[0]]
-log_wright_bessel: _UFunc31f[L["log_wright_bessel"]]
-lpmv: _UFunc31f[L["lpmv"], L[0]]
-nbdtr: _UFunc31f[L["nbdtr"], L[0]]
-nbdtrc: _UFunc31f[L["nbdtrc"], L[0]]
-nbdtri: _UFunc31f[L["nbdtri"], L[0]]
-nbdtrik: _UFunc31f[L["nbdtrik"], L[0]]
-nbdtrin: _UFunc31f[L["nbdtrin"], L[0]]
-nctdtr: _UFunc31f[L["nctdtr"], L[0]]
-nctdtridf: _UFunc31f[L["nctdtridf"], L[0]]
-nctdtrinc: _UFunc31f[L["nctdtrinc"], L[0]]
-nctdtrit: _UFunc31f[L["nctdtrit"], L[0]]
-nrdtrimn: _UFunc31f[L["nrdtrimn"], L[0]]
-nrdtrisd: _UFunc31f[L["nrdtrisd"], L[0]]
-obl_cv: _UFunc31f[L["obl_cv"]]
-pro_cv: _UFunc31f[L["pro_cv"]]
-radian: _UFunc31f[L["radian"], L[0]]
-voigt_profile: _UFunc31f[L["voigt_profile"], L[0]]
-wright_bessel: _UFunc31f[L["wright_bessel"]]
+_beta_pdf: _UFunc31f[L["_beta_pdf"], L[0]] = ...
+_beta_ppf: _UFunc31f[L["_beta_ppf"], L[0]] = ...
+_binom_pmf: _UFunc31f[L["_binom_pmf"], L[0]] = ...
+_binom_cdf: _UFunc31f[L["_binom_cdf"], L[0]] = ...
+_binom_ppf: _UFunc31f[L["_binom_ppf"], L[0]] = ...
+_binom_sf: _UFunc31f[L["_binom_sf"], L[0]] = ...
+_binom_isf: _UFunc31f[L["_binom_isf"], L[0]] = ...
+_cauchy_ppf: _UFunc31f[L["_cauchy_ppf"], L[0]] = ...
+_cauchy_isf: _UFunc31f[L["_cauchy_isf"], L[0]] = ...
+_hypergeom_mean: _UFunc31f[L["_hypergeom_mean"], L[0]] = ...
+_hypergeom_variance: _UFunc31f[L["_hypergeom_variance"], L[0]] = ...
+_hypergeom_skewness: _UFunc31f[L["_hypergeom_skewness"], L[0]] = ...
+_invgauss_ppf: _UFunc31f[L["_invgauss_ppf"], L[0]] = ...
+_invgauss_isf: _UFunc31f[L["_invgauss_isf"], L[0]] = ...
+_landau_pdf: _UFunc31f[L["_landau_pdf"], L[0]] = ...
+_landau_cdf: _UFunc31f[L["_landau_cdf"], L[0]] = ...
+_landau_ppf: _UFunc31f[L["_landau_ppf"], L[0]] = ...
+_landau_sf: _UFunc31f[L["_landau_sf"], L[0]] = ...
+_landau_isf: _UFunc31f[L["_landau_isf"], L[0]] = ...
+_nbinom_cdf: _UFunc31f[L["_nbinom_cdf"], L[0]] = ...
+_nbinom_isf: _UFunc31f[L["_nbinom_isf"], L[0]] = ...
+_nbinom_pmf: _UFunc31f[L["_nbinom_pmf"], L[0]] = ...
+_nbinom_ppf: _UFunc31f[L["_nbinom_ppf"], L[0]] = ...
+_nbinom_sf: _UFunc31f[L["_nbinom_sf"], L[0]] = ...
+_ncf_mean: _UFunc31f[L["_ncf_mean"], L[0]] = ...
+_ncf_variance: _UFunc31f[L["_ncf_variance"], L[0]] = ...
+_ncf_skewness: _UFunc31f[L["_ncf_skewness"], L[0]] = ...
+_ncf_kurtosis_excess: _UFunc31f[L["_ncf_kurtosis_excess"], L[0]] = ...
+_nct_cdf: _UFunc31f[L["_nct_cdf"], L[0]] = ...
+_nct_ppf: _UFunc31f[L["_nct_ppf"], L[0]] = ...
+_nct_sf: _UFunc31f[L["_nct_sf"], L[0]] = ...
+_nct_isf: _UFunc31f[L["_nct_isf"], L[0]] = ...
+_ncx2_pdf: _UFunc31f[L["_ncx2_pdf"], L[0]] = ...
+_ncx2_cdf: _UFunc31f[L["_ncx2_cdf"], L[0]] = ...
+_ncx2_ppf: _UFunc31f[L["_ncx2_ppf"], L[0]] = ...
+_ncx2_sf: _UFunc31f[L["_ncx2_sf"], L[0]] = ...
+_ncx2_isf: _UFunc31f[L["_ncx2_isf"], L[0]] = ...
+bdtr: _UFunc31f[L["bdtr"], L[0]] = ...
+bdtrc: _UFunc31f[L["bdtrc"], L[0]] = ...
+bdtri: _UFunc31f[L["bdtri"], L[0]] = ...
+bdtrik: _UFunc31f[L["bdtrik"], L[0]] = ...
+bdtrin: _UFunc31f[L["bdtrin"], L[0]] = ...
+besselpoly: _UFunc31f[L["besselpoly"], L[0]] = ...
+betainc: _UFunc31f[L["betainc"], L[0]] = ...
+betaincc: _UFunc31f[L["betaincc"], L[0]] = ...
+betainccinv: _UFunc31f[L["betainccinv"], L[0]] = ...
+betaincinv: _UFunc31f[L["betaincinv"], L[0]] = ...
+btdtr: _UFunc31f[L["btdtr"], L[0]] = ...
+btdtri: _UFunc31f[L["btdtri"], L[0]] = ...
+btdtria: _UFunc31f[L["btdtria"], L[0]] = ...
+btdtrib: _UFunc31f[L["btdtrib"], L[0]] = ...
+chndtr: _UFunc31f[L["chndtr"], L[0]] = ...
+chndtridf: _UFunc31f[L["chndtridf"], L[0]] = ...
+chndtrinc: _UFunc31f[L["chndtrinc"], L[0]] = ...
+chndtrix: _UFunc31f[L["chndtrix"], L[0]] = ...
+fdtr: _UFunc31f[L["fdtr"], L[0]] = ...
+fdtrc: _UFunc31f[L["fdtrc"], L[0]] = ...
+fdtri: _UFunc31f[L["fdtri"], L[0]] = ...
+fdtridfd: _UFunc31f[L["fdtridfd"], L[0]] = ...
+gdtr: _UFunc31f[L["gdtr"], L[0]] = ...
+gdtrc: _UFunc31f[L["gdtrc"], L[0]] = ...
+gdtria: _UFunc31f[L["gdtria"], L[0]] = ...
+gdtrib: _UFunc31f[L["gdtrib"], L[0]] = ...
+gdtrix: _UFunc31f[L["gdtrix"], L[0]] = ...
+hyperu: _UFunc31f[L["hyperu"], L[0]] = ...
+log_wright_bessel: _UFunc31f[L["log_wright_bessel"]] = ...
+lpmv: _UFunc31f[L["lpmv"], L[0]] = ...
+nbdtr: _UFunc31f[L["nbdtr"], L[0]] = ...
+nbdtrc: _UFunc31f[L["nbdtrc"], L[0]] = ...
+nbdtri: _UFunc31f[L["nbdtri"], L[0]] = ...
+nbdtrik: _UFunc31f[L["nbdtrik"], L[0]] = ...
+nbdtrin: _UFunc31f[L["nbdtrin"], L[0]] = ...
+nctdtr: _UFunc31f[L["nctdtr"], L[0]] = ...
+nctdtridf: _UFunc31f[L["nctdtridf"], L[0]] = ...
+nctdtrinc: _UFunc31f[L["nctdtrinc"], L[0]] = ...
+nctdtrit: _UFunc31f[L["nctdtrit"], L[0]] = ...
+nrdtrimn: _UFunc31f[L["nrdtrimn"], L[0]] = ...
+nrdtrisd: _UFunc31f[L["nrdtrisd"], L[0]] = ...
+obl_cv: _UFunc31f[L["obl_cv"]] = ...
+pro_cv: _UFunc31f[L["pro_cv"]] = ...
+radian: _UFunc31f[L["radian"], L[0]] = ...
+voigt_profile: _UFunc31f[L["voigt_profile"], L[0]] = ...
+wright_bessel: _UFunc31f[L["wright_bessel"]] = ...
 
 # Flf->F; Dld->D
-_lambertw: np.ufunc
+_lambertw: np.ufunc = ...
 
 # fff->f; ddd->d; FFF->F; DDD->D
 # TODO
-elliprd: np.ufunc
-elliprf: np.ufunc
-elliprg: np.ufunc
+elliprd: np.ufunc = ...
+elliprf: np.ufunc = ...
+elliprg: np.ufunc = ...
 
 # fff->f; ddd->d; ffF->F; (l|d)dD->D
 # TODO
-eval_gegenbauer: np.ufunc
-eval_genlaguerre: np.ufunc
-hyp1f1: np.ufunc
+eval_gegenbauer: np.ufunc = ...
+eval_genlaguerre: np.ufunc = ...
+hyp1f1: np.ufunc = ...
 
 # fff->ff; ddd->dd
 # TODO
-mathieu_cem: np.ufunc
-mathieu_modcem1: np.ufunc
-mathieu_modcem2: np.ufunc
-mathieu_modsem1: np.ufunc
-mathieu_modsem2: np.ufunc
-mathieu_sem: np.ufunc
+mathieu_cem: np.ufunc = ...
+mathieu_modcem1: np.ufunc = ...
+mathieu_modcem2: np.ufunc = ...
+mathieu_sem: np.ufunc = ...
+mathieu_modsem1: np.ufunc = ...
+mathieu_modsem2: np.ufunc = ...
 
 # ddl->dd
-_struve_asymp_large_z: np.ufunc
-_struve_bessel_series: np.ufunc
-_struve_power_series: np.ufunc
+_struve_asymp_large_z: np.ufunc = ...
+_struve_bessel_series: np.ufunc = ...
+_struve_power_series: np.ufunc = ...
 
 # ffff->f; dddd->d
-_hypergeom_cdf: _UFunc41f[L["_hypergeom_cdf"], L[0]]
-_hypergeom_pmf: _UFunc41f[L["_hypergeom_pmf"], L[0]]
-_hypergeom_sf: _UFunc41f[L["_hypergeom_sf"], L[0]]
-_ncf_cdf: _UFunc41f[L["_ncf_cdf"], L[0]]
-_ncf_isf: _UFunc41f[L["_ncf_isf"], L[0]]
-_ncf_pdf: _UFunc41f[L["_ncf_pdf"], L[0]]
-_ncf_ppf: _UFunc41f[L["_ncf_ppf"], L[0]]
-_ncf_sf: _UFunc41f[L["_ncf_sf"], L[0]]
-_skewnorm_cdf: _UFunc41f[L["_skewnorm_cdf"], L[0]]
-_skewnorm_isf: _UFunc41f[L["_skewnorm_isf"], L[0]]
-_skewnorm_ppf: _UFunc41f[L["_skewnorm_ppf"], L[0]]
-ncfdtr: _UFunc41f[L["ncfdtr"], L[0]]
-ncfdtri: _UFunc41f[L["ncfdtri"], L[0]]
-ncfdtridfd: _UFunc41f[L["ncfdtridfd"], L[0]]
-ncfdtridfn: _UFunc41f[L["ncfdtridfn"], L[0]]
-ncfdtrinc: _UFunc41f[L["ncfdtrinc"], L[0]]
+_hypergeom_pmf: _UFunc41f[L["_hypergeom_pmf"], L[0]] = ...
+_hypergeom_cdf: _UFunc41f[L["_hypergeom_cdf"], L[0]] = ...
+_hypergeom_sf: _UFunc41f[L["_hypergeom_sf"], L[0]] = ...
+_ncf_pdf: _UFunc41f[L["_ncf_pdf"], L[0]] = ...
+_ncf_cdf: _UFunc41f[L["_ncf_cdf"], L[0]] = ...
+_ncf_ppf: _UFunc41f[L["_ncf_ppf"], L[0]] = ...
+_ncf_sf: _UFunc41f[L["_ncf_sf"], L[0]] = ...
+_ncf_isf: _UFunc41f[L["_ncf_isf"], L[0]] = ...
+_skewnorm_cdf: _UFunc41f[L["_skewnorm_cdf"], L[0]] = ...
+_skewnorm_ppf: _UFunc41f[L["_skewnorm_ppf"], L[0]] = ...
+_skewnorm_isf: _UFunc41f[L["_skewnorm_isf"], L[0]] = ...
+ncfdtr: _UFunc41f[L["ncfdtr"], L[0]] = ...
+ncfdtri: _UFunc41f[L["ncfdtri"], L[0]] = ...
+ncfdtridfd: _UFunc41f[L["ncfdtridfd"], L[0]] = ...
+ncfdtridfn: _UFunc41f[L["ncfdtridfn"], L[0]] = ...
+ncfdtrinc: _UFunc41f[L["ncfdtrinc"], L[0]] = ...
 
 # ffff->f; (l|d)ddd->d; fffF->F; dddD->D
-# TODO
-eval_jacobi: np.ufunc
-eval_sh_jacobi: np.ufunc
-hyp2f1: np.ufunc
+eval_jacobi: _UFunc41fc1[L["eval_jacobi"], L[0]] = ...
+eval_sh_jacobi: _UFunc41fc1[L["eval_sh_jacobi"], L[0]] = ...
+hyp2f1: _UFunc41fc1[L["hyp2f1"]] = ...
 
 # ffff->f; dddd->d; FFFF->F; DDDD->D
 # TODO
-elliprj: np.ufunc
+elliprj: np.ufunc = ...
 
-# (ll|ff)ff->F; (ll|dd)dd->D
-# TODO
-sph_harm: np.ufunc
+# NOTE: Deprecated in SciPy 1.15.0
+# (qq|ff)ff->F; (qq|dd)dd->D
+sph_harm: _UFuncSphHarm = ...
 
 # ffff->ff; dddd->dd
 # TODO
-obl_ang1: np.ufunc
-obl_rad1: np.ufunc
-obl_rad2: np.ufunc
-pro_ang1: np.ufunc
-pro_rad1: np.ufunc
-pro_rad2: np.ufunc
+obl_ang1: np.ufunc = ...
+obl_rad1: np.ufunc = ...
+obl_rad2: np.ufunc = ...
+pro_ang1: np.ufunc = ...
+pro_rad1: np.ufunc = ...
+pro_rad2: np.ufunc = ...
 
 # fffff->ff; ddddd->dd
 # TODO
-obl_ang1_cv: np.ufunc
-obl_rad1_cv: np.ufunc
-obl_rad2_cv: np.ufunc
-pro_ang1_cv: np.ufunc
-pro_rad1_cv: np.ufunc
-pro_rad2_cv: np.ufunc
+obl_ang1_cv: np.ufunc = ...
+obl_rad1_cv: np.ufunc = ...
+obl_rad2_cv: np.ufunc = ...
+pro_ang1_cv: np.ufunc = ...
+pro_rad1_cv: np.ufunc = ...
+pro_rad2_cv: np.ufunc = ...
 
 # fffffff->f; dd(ll|dd)ddd->d
-_ellip_harm: np.ufunc
+_ellip_harm: np.ufunc = ...