ENH/BUG: Add tests and correct typing issues

Add tests for lower level components
Correct errors found in testing
Improve specificity of tests
Other small fixes to docs and typing

8 files changed, 1077 insertions, 40 deletions

diff --git a/numpy/random/_generator.pyi b/numpy/random/_generator.pyi
index 1396c5a32..904cbda3d 100644
--- a/numpy/random/_generator.pyi
+++ b/numpy/random/_generator.pyi
@@ -76,7 +76,7 @@ class Generator:
     def __reduce__(self) -> Tuple[Callable[[str], BitGenerator], Tuple[str], Dict[str, Any]]: ...
     @property
     def bit_generator(self) -> BitGenerator: ...
-    def bytes(self, length: int) -> str: ...
+    def bytes(self, length: int) -> bytes: ...
     @overload
     def standard_normal(  # type: ignore[misc]
         self,
@@ -279,16 +279,47 @@ class Generator:
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[uint64]]: ...
     # TODO: Use a TypeVar _T here to get away from Any output?  Should be int->ndarray[Any,dtype[int64]], ArrayLike[_T] -> Union[_T, ndarray[Any,Any]]
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: None = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> int: ...
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> ndarray[Any, dtype[int64]]: ...
+    @overload
     def choice(
         self,
         a: ArrayLike,
-        size: Optional[_ShapeLike] = ...,
+        size: None = ...,
         replace: bool = ...,
         p: Optional[_ArrayLikeFloat_co] = ...,
-        axis: Optional[int] = ...,
+        axis: int = ...,
         shuffle: bool = ...,
     ) -> Any: ...
     @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> ndarray[Any, Any]: ...
+    @overload
     def uniform(self, low: float = ..., high: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def uniform(
@@ -523,6 +554,8 @@ class Generator:
     def permuted(
         self, x: ArrayLike, *, axis: Optional[int] = ..., out: Optional[ndarray[Any, Any]] = ...
     ) -> ndarray[Any, Any]: ...
-    def shuffle(self, x: ArrayLike, axis: int = ...) -> Sequence[Any]: ...
+    def shuffle(self, x: ArrayLike, axis: int = ...) -> None: ...
 
-def default_rng(seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> Generator: ...
+def default_rng(
+    seed: Union[None, _ArrayLikeInt_co, SeedSequence, BitGenerator, Generator] = ...
+) -> Generator: ...
diff --git a/numpy/random/bit_generator.pyi b/numpy/random/bit_generator.pyi
index 80a2e829b..7f066dbfa 100644
--- a/numpy/random/bit_generator.pyi
+++ b/numpy/random/bit_generator.pyi
@@ -18,8 +18,8 @@ from typing import (
     overload,
 )
 
-from numpy import dtype, ndarray, uint32, uint64, unsignedinteger
-from numpy.typing import DTypeLike, _ArrayLikeInt_co, _DTypeLikeUInt, _ShapeLike, _SupportsDType
+from numpy import dtype, ndarray, uint32, uint64
+from numpy.typing import _ArrayLikeInt_co, _ShapeLike, _SupportsDType, _UInt64Codes, _UInt32Codes
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -28,11 +28,17 @@ else:
 
 _T = TypeVar("_T")
 
-_UIntType = TypeVar("_UIntType", uint64, uint32)
-_DTypeLike = Union[
-    Type[_UIntType],
-    dtype[_UIntType],
-    _SupportsDType[dtype[_UIntType]],
+_DTypeLikeUint32 = Union[
+    dtype[uint32],
+    _SupportsDType[dtype[uint32]],
+    Type[uint32],
+    _UInt32Codes,
+]
+_DTypeLikeUint64 = Union[
+    dtype[uint64],
+    _SupportsDType[dtype[uint64]],
+    Type[uint64],
+    _UInt64Codes,
 ]
 
 class _SeedSeqState(TypedDict):
@@ -50,30 +56,19 @@ class _Interface(NamedTuple):
     bit_generator: Any
 
 class ISeedSequence(abc.ABC):
-    @overload
-    @abc.abstractmethod
-    def generate_state(
-        self, n_words: int, dtype: _DTypeLike[_UIntType] = ...
-    ) -> ndarray[Any, dtype[_UIntType]]: ...
-    @overload
     @abc.abstractmethod
     def generate_state(
-        self, n_words: int, dtype: _DTypeLikeUInt = ...
-    ) -> ndarray[Any, dtype[unsignedinteger[Any]]]: ...
+        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
+    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
 
 class ISpawnableSeedSequence(ISeedSequence):
     @abc.abstractmethod
     def spawn(self: _T, n_children: int) -> List[_T]: ...
 
 class SeedlessSeedSequence(ISpawnableSeedSequence):
-    @overload
-    def generate_state(
-        self, n_words: int, dtype: _DTypeLike[_UIntType] = ...
-    ) -> ndarray[Any, dtype[_UIntType]]: ...
-    @overload
     def generate_state(
-        self, n_words: int, dtype: _DTypeLikeUInt = ...
-    ) -> ndarray[Any, dtype[unsignedinteger[Any]]]: ...
+        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
+    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
     def spawn(self: _T, n_children: int) -> List[_T]: ...
 
 class SeedSequence(ISpawnableSeedSequence):
@@ -84,7 +79,7 @@ class SeedSequence(ISpawnableSeedSequence):
     pool: ndarray[Any, dtype[uint32]]
     def __init__(
         self,
-        entropy: Union[None, int, Sequence[int]] = ...,
+        entropy: Union[None, int, Sequence[int], _ArrayLikeInt_co] = ...,
         *,
         spawn_key: Sequence[int] = ...,
         pool_size: int = ...,
@@ -95,7 +90,9 @@ class SeedSequence(ISpawnableSeedSequence):
     def state(
         self,
     ) -> _SeedSeqState: ...
-    def generate_state(self, n_words: int, dtype: DTypeLike = ...) -> ndarray[Any, Any]: ...
+    def generate_state(
+        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
+    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
     def spawn(self, n_children: int) -> List[SeedSequence]: ...
 
 class BitGenerator(abc.ABC):
diff --git a/numpy/random/mtrand.pyi b/numpy/random/mtrand.pyi
index c668e7edf..f05635390 100644
--- a/numpy/random/mtrand.pyi
+++ b/numpy/random/mtrand.pyi
@@ -229,7 +229,7 @@ class RandomState:
             dtype[uint64], Type[uint64], _UInt64Codes, _SupportsDType[dtype[uint64]]
         ] = ...,
     ) -> ndarray[Any, dtype[uint64]]: ...
-    def bytes(self, length: int) -> str: ...
+    def bytes(self, length: int) -> bytes: ...
     def choice(
         self,
         a: ArrayLike,
diff --git a/numpy/random/mtrand.pyx b/numpy/random/mtrand.pyx
index 1fd68111e..40b3ea100 100644
--- a/numpy/random/mtrand.pyx
+++ b/numpy/random/mtrand.pyx
@@ -784,7 +784,7 @@ cdef class RandomState:
 
         Returns
         -------
-        out : str
+        out : bytes
             String of length `length`.
 
         See Also
diff --git a/numpy/typing/tests/data/fail/random.py b/numpy/typing/tests/data/fail/random.py
index e69de29bb..c4d1e3e3e 100644
--- a/numpy/typing/tests/data/fail/random.py
+++ b/numpy/typing/tests/data/fail/random.py
@@ -0,0 +1,61 @@
+import numpy as np
+from typing import Any, List
+
+SEED_FLOAT: float = 457.3
+SEED_ARR_FLOAT: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0, 2, 3, 4])
+SEED_ARRLIKE_FLOAT: List[float] = [1.0, 2.0, 3.0, 4.0]
+SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
+SEED_STR: str = "String seeding not allowed"
+# default rng
+np.random.default_rng(SEED_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_STR)  # E: incompatible type
+
+# Seed Sequence
+np.random.SeedSequence(SEED_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_SEED_SEQ)  # E: incompatible type
+np.random.SeedSequence(SEED_STR)  # E: incompatible type
+
+seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence()
+seed_seq.spawn(11.5)  # E: incompatible type
+seed_seq.generate_state(3.14)  # E: incompatible type
+seed_seq.generate_state(3, np.uint8)  # E: incompatible type
+seed_seq.generate_state(3, "uint8")  # E: incompatible type
+seed_seq.generate_state(3, "u1")  # E: incompatible type
+seed_seq.generate_state(3, np.uint16)  # E: incompatible type
+seed_seq.generate_state(3, "uint16")  # E: incompatible type
+seed_seq.generate_state(3, "u2")  # E: incompatible type
+seed_seq.generate_state(3, np.int32)  # E: incompatible type
+seed_seq.generate_state(3, "int32")  # E: incompatible type
+seed_seq.generate_state(3, "i4")  # E: incompatible type
+
+# Bit Generators
+np.random.MT19937(SEED_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_STR)  # E: incompatible type
+
+np.random.PCG64(SEED_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_STR)  # E: incompatible type
+
+np.random.Philox(SEED_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_STR)  # E: incompatible type
+
+np.random.SFC64(SEED_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_STR)  # E: incompatible type
+
+# Generator
+np.random.Generator(None)  # E: incompatible type
+np.random.Generator(12333283902830213)  # E: incompatible type
+np.random.Generator("OxFEEDF00D")  # E: incompatible type
+np.random.Generator([123, 234])  # E: incompatible type
+np.random.Generator(np.array([123, 234], dtype="u4"))  # E: incompatible type
diff --git a/numpy/typing/tests/data/pass/random.py b/numpy/typing/tests/data/pass/random.py
index f5233b0e1..fa3585a90 100644
--- a/numpy/typing/tests/data/pass/random.py
+++ b/numpy/typing/tests/data/pass/random.py
@@ -1,17 +1,30 @@
+from __future__ import annotations
+
+from typing import Any, List, Dict
+
 import numpy as np
-from typing import Any, List
 
 SEED_NONE = None
 SEED_INT = 4579435749574957634658964293569
 SEED_ARR: np.ndarray[Any, np.dtype[np.int64]] = np.array([1, 2, 3, 4], dtype=np.int64)
 SEED_ARRLIKE: List[int] = [1, 2, 3, 4]
+SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
+SEED_MT19937: np.random.MT19937 = np.random.MT19937(0)
+SEED_PCG64: np.random.PCG64 = np.random.PCG64(0)
+SEED_PHILOX: np.random.Philox = np.random.Philox(0)
+SEED_SFC64: np.random.SFC64 = np.random.SFC64(0)
 
 # default rng
 np.random.default_rng()
 np.random.default_rng(SEED_NONE)
 np.random.default_rng(SEED_INT)
 np.random.default_rng(SEED_ARR)
-np.random.default_rng(SEED_ARR)
+np.random.default_rng(SEED_ARRLIKE)
+np.random.default_rng(SEED_SEED_SEQ)
+np.random.default_rng(SEED_MT19937)
+np.random.default_rng(SEED_PCG64)
+np.random.default_rng(SEED_PHILOX)
+np.random.default_rng(SEED_SFC64)
 
 # Seed Sequence
 np.random.SeedSequence(SEED_NONE)
@@ -24,18 +37,461 @@ np.random.MT19937(SEED_NONE)
 np.random.MT19937(SEED_INT)
 np.random.MT19937(SEED_ARR)
 np.random.MT19937(SEED_ARRLIKE)
+np.random.MT19937(SEED_SEED_SEQ)
 
 np.random.PCG64(SEED_NONE)
 np.random.PCG64(SEED_INT)
 np.random.PCG64(SEED_ARR)
 np.random.PCG64(SEED_ARRLIKE)
+np.random.PCG64(SEED_SEED_SEQ)
 
 np.random.Philox(SEED_NONE)
 np.random.Philox(SEED_INT)
 np.random.Philox(SEED_ARR)
 np.random.Philox(SEED_ARRLIKE)
+np.random.Philox(SEED_SEED_SEQ)
 
 np.random.SFC64(SEED_NONE)
 np.random.SFC64(SEED_INT)
 np.random.SFC64(SEED_ARR)
 np.random.SFC64(SEED_ARRLIKE)
+np.random.SFC64(SEED_SEED_SEQ)
+
+seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence(SEED_NONE)
+seed_seq.spawn(10)
+seed_seq.generate_state(3)
+seed_seq.generate_state(3, "u4")
+seed_seq.generate_state(3, "uint32")
+seed_seq.generate_state(3, "u8")
+seed_seq.generate_state(3, "uint64")
+seed_seq.generate_state(3, np.uint32)
+seed_seq.generate_state(3, np.uint64)
+
+
+def_gen: np.random.Generator = np.random.default_rng()
+
+D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1])
+D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5])
+D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9])
+D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
+I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
+I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
+D_arr_like_0p1: List[float] = [0.1]
+D_arr_like_0p5: List[float] = [0.5]
+D_arr_like_0p9: List[float] = [0.9]
+D_arr_like_1p5: List[float] = [1.5]
+I_arr_like_10: List[int] = [10]
+I_arr_like_20: List[int] = [20]
+D_2D_like: List[List[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
+
+def_gen.standard_normal()
+def_gen.standard_normal(size=None)
+def_gen.standard_normal(size=1)
+
+def_gen.random()
+def_gen.random(size=None)
+def_gen.random(size=1)
+
+def_gen.standard_cauchy()
+def_gen.standard_cauchy(size=None)
+def_gen.standard_cauchy(size=1)
+
+def_gen.standard_exponential()
+def_gen.standard_exponential(size=None)
+def_gen.standard_exponential(size=1)
+
+def_gen.zipf(1.5)
+def_gen.zipf(1.5, size=None)
+def_gen.zipf(1.5, size=1)
+def_gen.zipf(D_arr_1p5)
+def_gen.zipf(D_arr_1p5, size=1)
+def_gen.zipf(D_arr_like_1p5)
+def_gen.zipf(D_arr_like_1p5, size=1)
+
+def_gen.weibull(0.5)
+def_gen.weibull(0.5, size=None)
+def_gen.weibull(0.5, size=1)
+def_gen.weibull(D_arr_0p5)
+def_gen.weibull(D_arr_0p5, size=1)
+def_gen.weibull(D_arr_like_0p5)
+def_gen.weibull(D_arr_like_0p5, size=1)
+
+def_gen.standard_t(0.5)
+def_gen.standard_t(0.5, size=None)
+def_gen.standard_t(0.5, size=1)
+def_gen.standard_t(D_arr_0p5)
+def_gen.standard_t(D_arr_0p5, size=1)
+def_gen.standard_t(D_arr_like_0p5)
+def_gen.standard_t(D_arr_like_0p5, size=1)
+
+def_gen.poisson(0.5)
+def_gen.poisson(0.5, size=None)
+def_gen.poisson(0.5, size=1)
+def_gen.poisson(D_arr_0p5)
+def_gen.poisson(D_arr_0p5, size=1)
+def_gen.poisson(D_arr_like_0p5)
+def_gen.poisson(D_arr_like_0p5, size=1)
+
+def_gen.power(0.5)
+def_gen.power(0.5, size=None)
+def_gen.power(0.5, size=1)
+def_gen.power(D_arr_0p5)
+def_gen.power(D_arr_0p5, size=1)
+def_gen.power(D_arr_like_0p5)
+def_gen.power(D_arr_like_0p5, size=1)
+
+def_gen.pareto(0.5)
+def_gen.pareto(0.5, size=None)
+def_gen.pareto(0.5, size=1)
+def_gen.pareto(D_arr_0p5)
+def_gen.pareto(D_arr_0p5, size=1)
+def_gen.pareto(D_arr_like_0p5)
+def_gen.pareto(D_arr_like_0p5, size=1)
+
+def_gen.chisquare(0.5)
+def_gen.chisquare(0.5, size=None)
+def_gen.chisquare(0.5, size=1)
+def_gen.chisquare(D_arr_0p5)
+def_gen.chisquare(D_arr_0p5, size=1)
+def_gen.chisquare(D_arr_like_0p5)
+def_gen.chisquare(D_arr_like_0p5, size=1)
+
+def_gen.exponential(0.5)
+def_gen.exponential(0.5, size=None)
+def_gen.exponential(0.5, size=1)
+def_gen.exponential(D_arr_0p5)
+def_gen.exponential(D_arr_0p5, size=1)
+def_gen.exponential(D_arr_like_0p5)
+def_gen.exponential(D_arr_like_0p5, size=1)
+
+def_gen.geometric(0.5)
+def_gen.geometric(0.5, size=None)
+def_gen.geometric(0.5, size=1)
+def_gen.geometric(D_arr_0p5)
+def_gen.geometric(D_arr_0p5, size=1)
+def_gen.geometric(D_arr_like_0p5)
+def_gen.geometric(D_arr_like_0p5, size=1)
+
+def_gen.logseries(0.5)
+def_gen.logseries(0.5, size=None)
+def_gen.logseries(0.5, size=1)
+def_gen.logseries(D_arr_0p5)
+def_gen.logseries(D_arr_0p5, size=1)
+def_gen.logseries(D_arr_like_0p5)
+def_gen.logseries(D_arr_like_0p5, size=1)
+
+def_gen.rayleigh(0.5)
+def_gen.rayleigh(0.5, size=None)
+def_gen.rayleigh(0.5, size=1)
+def_gen.rayleigh(D_arr_0p5)
+def_gen.rayleigh(D_arr_0p5, size=1)
+def_gen.rayleigh(D_arr_like_0p5)
+def_gen.rayleigh(D_arr_like_0p5, size=1)
+
+def_gen.standard_gamma(0.5)
+def_gen.standard_gamma(0.5, size=None)
+def_gen.standard_gamma(0.5, size=1)
+def_gen.standard_gamma(D_arr_0p5)
+def_gen.standard_gamma(D_arr_0p5, size=1)
+def_gen.standard_gamma(D_arr_like_0p5)
+def_gen.standard_gamma(D_arr_like_0p5, size=1)
+
+def_gen.vonmises(0.5, 0.5)
+def_gen.vonmises(0.5, 0.5, size=None)
+def_gen.vonmises(0.5, 0.5, size=1)
+def_gen.vonmises(D_arr_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_0p5)
+def_gen.vonmises(D_arr_0p5, 0.5, size=1)
+def_gen.vonmises(0.5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.wald(0.5, 0.5)
+def_gen.wald(0.5, 0.5, size=None)
+def_gen.wald(0.5, 0.5, size=1)
+def_gen.wald(D_arr_0p5, 0.5)
+def_gen.wald(0.5, D_arr_0p5)
+def_gen.wald(D_arr_0p5, 0.5, size=1)
+def_gen.wald(0.5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, 0.5)
+def_gen.wald(0.5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.uniform(0.5, 0.5)
+def_gen.uniform(0.5, 0.5, size=None)
+def_gen.uniform(0.5, 0.5, size=1)
+def_gen.uniform(D_arr_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_0p5)
+def_gen.uniform(D_arr_0p5, 0.5, size=1)
+def_gen.uniform(0.5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.beta(0.5, 0.5)
+def_gen.beta(0.5, 0.5, size=None)
+def_gen.beta(0.5, 0.5, size=1)
+def_gen.beta(D_arr_0p5, 0.5)
+def_gen.beta(0.5, D_arr_0p5)
+def_gen.beta(D_arr_0p5, 0.5, size=1)
+def_gen.beta(0.5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, 0.5)
+def_gen.beta(0.5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.f(0.5, 0.5)
+def_gen.f(0.5, 0.5, size=None)
+def_gen.f(0.5, 0.5, size=1)
+def_gen.f(D_arr_0p5, 0.5)
+def_gen.f(0.5, D_arr_0p5)
+def_gen.f(D_arr_0p5, 0.5, size=1)
+def_gen.f(0.5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, 0.5)
+def_gen.f(0.5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gamma(0.5, 0.5)
+def_gen.gamma(0.5, 0.5, size=None)
+def_gen.gamma(0.5, 0.5, size=1)
+def_gen.gamma(D_arr_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_0p5)
+def_gen.gamma(D_arr_0p5, 0.5, size=1)
+def_gen.gamma(0.5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gumbel(0.5, 0.5)
+def_gen.gumbel(0.5, 0.5, size=None)
+def_gen.gumbel(0.5, 0.5, size=1)
+def_gen.gumbel(D_arr_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_0p5)
+def_gen.gumbel(D_arr_0p5, 0.5, size=1)
+def_gen.gumbel(0.5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.laplace(0.5, 0.5)
+def_gen.laplace(0.5, 0.5, size=None)
+def_gen.laplace(0.5, 0.5, size=1)
+def_gen.laplace(D_arr_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_0p5)
+def_gen.laplace(D_arr_0p5, 0.5, size=1)
+def_gen.laplace(0.5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.logistic(0.5, 0.5)
+def_gen.logistic(0.5, 0.5, size=None)
+def_gen.logistic(0.5, 0.5, size=1)
+def_gen.logistic(D_arr_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_0p5)
+def_gen.logistic(D_arr_0p5, 0.5, size=1)
+def_gen.logistic(0.5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.lognormal(0.5, 0.5)
+def_gen.lognormal(0.5, 0.5, size=None)
+def_gen.lognormal(0.5, 0.5, size=1)
+def_gen.lognormal(D_arr_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_0p5)
+def_gen.lognormal(D_arr_0p5, 0.5, size=1)
+def_gen.lognormal(0.5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.noncentral_chisquare(0.5, 0.5)
+def_gen.noncentral_chisquare(0.5, 0.5, size=None)
+def_gen.noncentral_chisquare(0.5, 0.5, size=1)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.normal(0.5, 0.5)
+def_gen.normal(0.5, 0.5, size=None)
+def_gen.normal(0.5, 0.5, size=1)
+def_gen.normal(D_arr_0p5, 0.5)
+def_gen.normal(0.5, D_arr_0p5)
+def_gen.normal(D_arr_0p5, 0.5, size=1)
+def_gen.normal(0.5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, 0.5)
+def_gen.normal(0.5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.triangular(0.1, 0.5, 0.9)
+def_gen.triangular(0.1, 0.5, 0.9, size=None)
+def_gen.triangular(0.1, 0.5, 0.9, size=1)
+def_gen.triangular(D_arr_0p1, 0.5, 0.9)
+def_gen.triangular(0.1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.triangular(0.5, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.noncentral_f(0.1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=None)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.binomial(10, 0.5)
+def_gen.binomial(10, 0.5, size=None)
+def_gen.binomial(10, 0.5, size=1)
+def_gen.binomial(I_arr_10, 0.5)
+def_gen.binomial(10, D_arr_0p5)
+def_gen.binomial(I_arr_10, 0.5, size=1)
+def_gen.binomial(10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, 0.5)
+def_gen.binomial(10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.negative_binomial(10, 0.5)
+def_gen.negative_binomial(10, 0.5, size=None)
+def_gen.negative_binomial(10, 0.5, size=1)
+def_gen.negative_binomial(I_arr_10, 0.5)
+def_gen.negative_binomial(10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_10, 0.5, size=1)
+def_gen.negative_binomial(10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, 0.5)
+def_gen.negative_binomial(10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.hypergeometric(20, 20, 10)
+def_gen.hypergeometric(20, 20, 10, size=None)
+def_gen.hypergeometric(20, 20, 10, size=1)
+def_gen.hypergeometric(I_arr_20, 20, 10)
+def_gen.hypergeometric(20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)
+def_gen.hypergeometric(20, I_arr_20, 10, size=1)
+def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10)
+def_gen.hypergeometric(20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)
+
+
+def_gen.bit_generator
+
+def_gen.bytes(2)
+
+def_gen.choice(5)
+def_gen.choice(5, 3)
+def_gen.choice(5, 3, replace=True)
+def_gen.choice(5, 3, p=[1 / 5] * 5)
+def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False)
+
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"])
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))
+
+def_gen.dirichlet([0.5, 0.5])
+def_gen.dirichlet(np.array([0.5, 0.5]))
+def_gen.dirichlet(np.array([0.5, 0.5]), size=3)
+
+def_gen.multinomial(20, [1 / 6.0] * 6)
+def_gen.multinomial(20, np.array([0.5, 0.5]))
+def_gen.multinomial(20, [1 / 6.0] * 6, size=2)
+def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2))
+def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2))
+
+def_gen.multivariate_hypergeometric([3, 5, 7], 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7))
+def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count")
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals")
+
+def_gen.multivariate_normal([0.0], [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+def_gen.multivariate_normal(np.array([0.0]), [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+
+def_gen.permutation(10)
+def_gen.permutation([1, 2, 3, 4])
+def_gen.permutation(np.array([1, 2, 3, 4]))
+def_gen.permutation(D_2D, axis=1)
+def_gen.permuted(D_2D)
+def_gen.permuted(D_2D_like)
+def_gen.permuted(D_2D, axis=1)
+def_gen.permuted(D_2D, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D, axis=1, out=D_2D)
+
+def_gen.shuffle(np.arange(10))
+def_gen.shuffle([1, 2, 3, 4, 5])
+def_gen.shuffle(D_2D, axis=1)
+
+def_gen.__str__()
+def_gen.__repr__()
+def_gen_state: Dict[str, Any]
+def_gen_state = def_gen.__getstate__()
+def_gen.__setstate__(def_gen_state)
diff --git a/numpy/typing/tests/data/reveal/random.py b/numpy/typing/tests/data/reveal/random.py
index 9e26f495f..cd1ac014b 100644
--- a/numpy/typing/tests/data/reveal/random.py
+++ b/numpy/typing/tests/data/reveal/random.py
@@ -1,15 +1,502 @@
+from __future__ import annotations
+
+from typing import Any, List
+
 import numpy as np
 
 def_rng = np.random.default_rng()
+seed_seq = np.random.SeedSequence()
 mt19937 = np.random.MT19937()
-pcg64 = np.random.MT19937()
+pcg64 = np.random.PCG64()
 sfc64 = np.random.SFC64()
 philox = np.random.Philox()
+seedless_seq = np.random.bit_generator.SeedlessSeedSequence()
+
+reveal_type(def_rng)  # E: numpy.random._generator.Generator
+reveal_type(mt19937)  # E: numpy.random._mt19937.MT19937
+reveal_type(pcg64)  # E: numpy.random._pcg64.PCG64
+reveal_type(sfc64)  # E: numpy.random._sfc64.SFC64
+reveal_type(philox)  # E: numpy.random._philox.Philox
+reveal_type(seed_seq)  # E: numpy.random.bit_generator.SeedSequence
+reveal_type(seedless_seq)  # E: numpy.random.bit_generator.SeedlessSeedSequence
+
+mt19937_jumped = mt19937.jumped()
+mt19937_jumped3 = mt19937.jumped(3)
+mt19937_raw = mt19937.random_raw()
+mt19937_raw_arr = mt19937.random_raw(5)
+
+reveal_type(mt19937_jumped)  # E: numpy.random._mt19937.MT19937
+reveal_type(mt19937_jumped3)  # E: numpy.random._mt19937.MT19937
+reveal_type(mt19937_raw)  # E: int
+reveal_type(mt19937_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(mt19937.lock)  # E: threading.Lock
+
+pcg64_jumped = pcg64.jumped()
+pcg64_jumped3 = pcg64.jumped(3)
+pcg64_adv = pcg64.advance(3)
+pcg64_raw = pcg64.random_raw()
+pcg64_raw_arr = pcg64.random_raw(5)
+
+reveal_type(pcg64_jumped)  # E: numpy.random._pcg64.PCG64
+reveal_type(pcg64_jumped3)  # E: numpy.random._pcg64.PCG64
+reveal_type(pcg64_adv)  # E: numpy.random._pcg64.PCG64
+reveal_type(pcg64_raw)  # E: int
+reveal_type(pcg64_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(pcg64.lock)  # E: threading.Lock
+
+philox_jumped = philox.jumped()
+philox_jumped3 = philox.jumped(3)
+philox_adv = philox.advance(3)
+philox_raw = philox.random_raw()
+philox_raw_arr = philox.random_raw(5)
+
+reveal_type(philox_jumped)  # E: numpy.random._philox.Philox
+reveal_type(philox_jumped3)  # E: numpy.random._philox.Philox
+reveal_type(philox_adv)  # E: numpy.random._philox.Philox
+reveal_type(philox_raw)  # E: int
+reveal_type(philox_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(philox.lock)  # E: threading.Lock
+
+sfc64_raw = sfc64.random_raw()
+sfc64_raw_arr = sfc64.random_raw(5)
+
+reveal_type(sfc64_raw)  # E: int
+reveal_type(sfc64_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(sfc64.lock)  # E: threading.Lock
+
+reveal_type(seed_seq.pool)  # numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(seed_seq.entropy)  # E:Union[None, int, Sequence[int]]
+reveal_type(seed_seq.spawn(1))  # E: list[numpy.random.bit_generator.SeedSequence]
+reveal_type(seed_seq.generate_state(8, "uint32"))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.unsignedinteger[numpy.typing._32Bit], numpy.unsignedinteger[numpy.typing._64Bit]]]]
+reveal_type(seed_seq.generate_state(8, "uint64"))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.unsignedinteger[numpy.typing._32Bit], numpy.unsignedinteger[numpy.typing._64Bit]]]]
+
+
+def_gen: np.random.Generator = np.random.default_rng()
+
+D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1])
+D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5])
+D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9])
+D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
+I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
+I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
+D_arr_like_0p1: List[float] = [0.1]
+D_arr_like_0p5: List[float] = [0.5]
+D_arr_like_0p9: List[float] = [0.9]
+D_arr_like_1p5: List[float] = [1.5]
+I_arr_like_10: List[int] = [10]
+I_arr_like_20: List[int] = [20]
+D_2D_like: List[List[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
+
+reveal_type(def_gen.standard_normal())  # E: float
+reveal_type(def_gen.standard_normal(size=None))  # E: float
+reveal_type(def_gen.standard_normal(size=1))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.random())  # E: float
+reveal_type(def_gen.random(size=None))  # E: float
+reveal_type(def_gen.random(size=1))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.standard_cauchy())  # E: float
+reveal_type(def_gen.standard_cauchy(size=None))  # E: float
+reveal_type(def_gen.standard_cauchy(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.standard_exponential())  # E: float
+reveal_type(def_gen.standard_exponential(size=None))  # E: float
+reveal_type(def_gen.standard_exponential(size=1))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.zipf(1.5))  # E: int
+reveal_type(def_gen.zipf(1.5, size=None))  # E: int
+reveal_type(def_gen.zipf(1.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.zipf(D_arr_1p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.zipf(D_arr_1p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.zipf(D_arr_like_1p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.zipf(D_arr_like_1p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.weibull(0.5))  # E: float
+reveal_type(def_gen.weibull(0.5, size=None))  # E: float
+reveal_type(def_gen.weibull(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.standard_t(0.5))  # E: float
+reveal_type(def_gen.standard_t(0.5, size=None))  # E: float
+reveal_type(def_gen.standard_t(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.poisson(0.5))  # E: int
+reveal_type(def_gen.poisson(0.5, size=None))  # E: int
+reveal_type(def_gen.poisson(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.poisson(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.poisson(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.poisson(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.poisson(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.power(0.5))  # E: float
+reveal_type(def_gen.power(0.5, size=None))  # E: float
+reveal_type(def_gen.power(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.pareto(0.5))  # E: float
+reveal_type(def_gen.pareto(0.5, size=None))  # E: float
+reveal_type(def_gen.pareto(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.chisquare(0.5))  # E: float
+reveal_type(def_gen.chisquare(0.5, size=None))  # E: float
+reveal_type(def_gen.chisquare(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.exponential(0.5))  # E: float
+reveal_type(def_gen.exponential(0.5, size=None))  # E: float
+reveal_type(def_gen.exponential(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.geometric(0.5))  # E: int
+reveal_type(def_gen.geometric(0.5, size=None))  # E: int
+reveal_type(def_gen.geometric(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.geometric(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.geometric(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.geometric(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.geometric(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.logseries(0.5))  # E: int
+reveal_type(def_gen.logseries(0.5, size=None))  # E: int
+reveal_type(def_gen.logseries(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.logseries(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.logseries(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.logseries(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.logseries(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.rayleigh(0.5))  # E: float
+reveal_type(def_gen.rayleigh(0.5, size=None))  # E: float
+reveal_type(def_gen.rayleigh(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.standard_gamma(0.5))  # E: float
+reveal_type(def_gen.standard_gamma(0.5, size=None))  # E: float
+reveal_type(def_gen.standard_gamma(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.floating[numpy.typing._32Bit], numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.vonmises(0.5, 0.5))  # E: float
+reveal_type(def_gen.vonmises(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.vonmises(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.wald(0.5, 0.5))  # E: float
+reveal_type(def_gen.wald(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.wald(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.uniform(0.5, 0.5))  # E: float
+reveal_type(def_gen.uniform(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.uniform(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.beta(0.5, 0.5))  # E: float
+reveal_type(def_gen.beta(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.beta(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.f(0.5, 0.5))  # E: float
+reveal_type(def_gen.f(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.f(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.gamma(0.5, 0.5))  # E: float
+reveal_type(def_gen.gamma(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.gamma(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.gumbel(0.5, 0.5))  # E: float
+reveal_type(def_gen.gumbel(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.gumbel(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.laplace(0.5, 0.5))  # E: float
+reveal_type(def_gen.laplace(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.laplace(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.logistic(0.5, 0.5))  # E: float
+reveal_type(def_gen.logistic(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.logistic(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.lognormal(0.5, 0.5))  # E: float
+reveal_type(def_gen.lognormal(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.lognormal(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.noncentral_chisquare(0.5, 0.5))  # E: float
+reveal_type(def_gen.noncentral_chisquare(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.noncentral_chisquare(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.normal(0.5, 0.5))  # E: float
+reveal_type(def_gen.normal(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.normal(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.triangular(0.1, 0.5, 0.9))  # E: float
+reveal_type(def_gen.triangular(0.1, 0.5, 0.9, size=None))  # E: float
+reveal_type(def_gen.triangular(0.1, 0.5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, 0.5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(0.1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(0.5, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9))  # E: float
+reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=None))  # E: float
+reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.binomial(10, 0.5))  # E: int
+reveal_type(def_gen.binomial(10, 0.5, size=None))  # E: int
+reveal_type(def_gen.binomial(10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(I_arr_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(I_arr_10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(I_arr_like_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(I_arr_10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(I_arr_10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.negative_binomial(10, 0.5))  # E: int
+reveal_type(def_gen.negative_binomial(10, 0.5, size=None))  # E: int
+reveal_type(def_gen.negative_binomial(10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(I_arr_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(I_arr_10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(I_arr_like_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.hypergeometric(20, 20, 10))  # E: int
+reveal_type(def_gen.hypergeometric(20, 20, 10, size=None))  # E: int
+reveal_type(def_gen.hypergeometric(20, 20, 10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(I_arr_20, 20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(20, I_arr_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(20, I_arr_20, 10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(20, I_arr_like_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(I_arr_20, I_arr_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+
+reveal_type(def_gen.bit_generator)  # E: BitGenerator
+
+reveal_type(def_gen.bytes(2))  # E: bytes
+
+reveal_type(def_gen.choice(5))  # E: int
+reveal_type(def_gen.choice(5, 3))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.choice(5, 3, replace=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.choice(5, 3, p=[1 / 5] * 5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"]))  # E: Any
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4])))  # E: numpy.ndarray[Any, Any]
+
+reveal_type(def_gen.dirichlet([0.5, 0.5]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.dirichlet(np.array([0.5, 0.5])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.dirichlet(np.array([0.5, 0.5]), size=3))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.multinomial(20, [1 / 6.0] * 6))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multinomial(20, np.array([0.5, 0.5])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multinomial(20, [1 / 6.0] * 6, size=2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+
+reveal_type(def_gen.multivariate_normal([0.0], [[1.0]]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_normal([0.0], np.array([[1.0]])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_normal(np.array([0.0]), [[1.0]]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_normal([0.0], np.array([[1.0]])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
 
+reveal_type(def_gen.permutation(10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]
+reveal_type(def_gen.permutation([1, 2, 3, 4]))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permutation(np.array([1, 2, 3, 4])))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permutation(D_2D, axis=1))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D_like))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D, axis=1))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D, out=D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D_like, out=D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D_like, out=D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D, axis=1, out=D_2D))  # E: numpy.ndarray[Any, Any]
 
-reveal_type(def_rng)  # E: np.random.MT19937
-reveal_type(mt19937)  # E: np.random.Generator
-reveal_type(pcg64)  # E: np.random.MT19937
-reveal_type(sfc64)  # E: np.random.SFC64
-reveal_type(philox)  # E: np.random.Philox
+reveal_type(def_gen.shuffle(np.arange(10)))  # E: None
+reveal_type(def_gen.shuffle([1, 2, 3, 4, 5]))  # E: None
+reveal_type(def_gen.shuffle(D_2D, axis=1))  # E: None
+reveal_type(def_gen.shuffle(D_2D_like, axis=1))  # E: None
 
+reveal_type(np.random.Generator(pcg64))  # E: Generator
+reveal_type(def_gen.__str__())  # E: str
+reveal_type(def_gen.__repr__())  # E: str
+def_gen_state = def_gen.__getstate__()
+reveal_type(def_gen_state)  # E: builtins.dict[builtins.str, Any]
+reveal_type(def_gen.__setstate__(def_gen_state))  # E: None
diff --git a/numpy/typing/tests/test_typing.py b/numpy/typing/tests/test_typing.py
index e80282420..70355dcd9 100644
--- a/numpy/typing/tests/test_typing.py
+++ b/numpy/typing/tests/test_typing.py
@@ -48,8 +48,11 @@ def run_mypy() -> None:
 
     The mypy results are cached in `OUTPUT_MYPY` for further use.
 
+    The cache refresh can be skipped using
+
+    NUMPY_TYPING_TEST_CLEAR_CACHE=0 pytest numpy/typing/tests
     """
-    if os.path.isdir(CACHE_DIR):
+    if os.path.isdir(CACHE_DIR) and bool(os.environ.get("NUMPY_TYPING_TEST_CLEAR_CACHE", True)):
         shutil.rmtree(CACHE_DIR)
 
     for directory in (PASS_DIR, REVEAL_DIR, FAIL_DIR, MISC_DIR):