ENH: Add typing for RandomState

Add typing for RandomState
Small fixes to Generator's typing

3 files changed, 605 insertions, 61 deletions

diff --git a/numpy/random/__init__.pyi b/numpy/random/__init__.pyi
index b99c002ae..2dd41933c 100644
--- a/numpy/random/__init__.pyi
+++ b/numpy/random/__init__.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import List
 
 from numpy.random._generator import Generator as Generator
 from numpy.random._generator import default_rng as default_rng
@@ -8,57 +8,56 @@ from numpy.random._philox import Philox as Philox
 from numpy.random._sfc64 import SFC64 as SFC64
 from numpy.random.bit_generator import BitGenerator as BitGenerator
 from numpy.random.bit_generator import SeedSequence as SeedSequence
+from numpy.random.mtrand import RandomState as RandomState
+from numpy.random.mtrand import beta as beta
+from numpy.random.mtrand import binomial as binomial
+from numpy.random.mtrand import bytes as bytes
+from numpy.random.mtrand import chisquare as chisquare
+from numpy.random.mtrand import choice as choice
+from numpy.random.mtrand import dirichlet as dirichlet
+from numpy.random.mtrand import exponential as exponential
+from numpy.random.mtrand import f as f
+from numpy.random.mtrand import gamma as gamma
+from numpy.random.mtrand import geometric as geometric
+from numpy.random.mtrand import get_state as get_state
+from numpy.random.mtrand import gumbel as gumbel
+from numpy.random.mtrand import hypergeometric as hypergeometric
+from numpy.random.mtrand import laplace as laplace
+from numpy.random.mtrand import logistic as logistic
+from numpy.random.mtrand import lognormal as lognormal
+from numpy.random.mtrand import logseries as logseries
+from numpy.random.mtrand import multinomial as multinomial
+from numpy.random.mtrand import multivariate_normal as multivariate_normal
+from numpy.random.mtrand import negative_binomial as negative_binomial
+from numpy.random.mtrand import noncentral_chisquare as noncentral_chisquare
+from numpy.random.mtrand import noncentral_f as noncentral_f
+from numpy.random.mtrand import normal as normal
+from numpy.random.mtrand import pareto as pareto
+from numpy.random.mtrand import permutation as permutation
+from numpy.random.mtrand import poisson as poisson
+from numpy.random.mtrand import power as power
+from numpy.random.mtrand import rand as rand
+from numpy.random.mtrand import randint as randint
+from numpy.random.mtrand import randn as randn
+from numpy.random.mtrand import random as random
+from numpy.random.mtrand import random_integers as random_integers
+from numpy.random.mtrand import random_sample as random_sample
+from numpy.random.mtrand import ranf as ranf
+from numpy.random.mtrand import rayleigh as rayleigh
+from numpy.random.mtrand import sample as sample
+from numpy.random.mtrand import seed as seed
+from numpy.random.mtrand import set_state as set_state
+from numpy.random.mtrand import shuffle as shuffle
+from numpy.random.mtrand import standard_cauchy as standard_cauchy
+from numpy.random.mtrand import standard_exponential as standard_exponential
+from numpy.random.mtrand import standard_gamma as standard_gamma
+from numpy.random.mtrand import standard_normal as standard_normal
+from numpy.random.mtrand import standard_t as standard_t
+from numpy.random.mtrand import triangular as triangular
+from numpy.random.mtrand import uniform as uniform
+from numpy.random.mtrand import vonmises as vonmises
+from numpy.random.mtrand import wald as wald
+from numpy.random.mtrand import weibull as weibull
+from numpy.random.mtrand import zipf as zipf
 
 __all__: List[str]
-
-beta: Any
-binomial: Any
-bytes: Any
-chisquare: Any
-choice: Any
-dirichlet: Any
-exponential: Any
-f: Any
-gamma: Any
-geometric: Any
-get_state: Any
-gumbel: Any
-hypergeometric: Any
-laplace: Any
-logistic: Any
-lognormal: Any
-logseries: Any
-multinomial: Any
-multivariate_normal: Any
-negative_binomial: Any
-noncentral_chisquare: Any
-noncentral_f: Any
-normal: Any
-pareto: Any
-permutation: Any
-poisson: Any
-power: Any
-rand: Any
-randint: Any
-randn: Any
-random: Any
-random_integers: Any
-random_sample: Any
-ranf: Any
-rayleigh: Any
-sample: Any
-seed: Any
-set_state: Any
-shuffle: Any
-standard_cauchy: Any
-standard_exponential: Any
-standard_gamma: Any
-standard_normal: Any
-standard_t: Any
-triangular: Any
-uniform: Any
-vonmises: Any
-wald: Any
-weibull: Any
-zipf: Any
-RandomState: Any
diff --git a/numpy/random/_generator.pyi b/numpy/random/_generator.pyi
index aadc4d0f8..1396c5a32 100644
--- a/numpy/random/_generator.pyi
+++ b/numpy/random/_generator.pyi
@@ -3,7 +3,6 @@ from typing import Any, Callable, Dict, Literal, Optional, Sequence, Tuple, Type
 
 from numpy import (
     bool_,
-    double,
     dtype,
     float32,
     float64,
@@ -13,7 +12,6 @@ from numpy import (
     int64,
     int_,
     ndarray,
-    single,
     uint,
     uint8,
     uint16,
@@ -70,11 +68,9 @@ _DTypeLikeFloat64 = Union[
 ]
 
 class Generator:
-    # COMPLETE
     def __init__(self, bit_generator: BitGenerator) -> None: ...
     def __repr__(self) -> str: ...
     def __str__(self) -> str: ...
-    # Pickling support:
     def __getstate__(self) -> Dict[str, Any]: ...
     def __setstate__(self, state: Dict[str, Any]) -> None: ...
     def __reduce__(self) -> Tuple[Callable[[str], BitGenerator], Tuple[str], Dict[str, Any]]: ...
@@ -102,7 +98,7 @@ class Generator:
     @overload
     def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
-    def standard_cauchy(self, size: Optional[_ShapeLike] = ...) -> ndarray[Any, dtype[float64]]: ...
+    def standard_cauchy(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_exponential(  # type: ignore[misc]
         self,
@@ -325,7 +321,7 @@ class Generator:
         size: Optional[_ShapeLike] = ...,
         dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
         out: Optional[ndarray[Any, dtype[Union[float32, float64]]]] = ...,
-    ) -> ndarray[Any, dtype[float64]]: ...
+    ) -> ndarray[Any, dtype[Union[float32, float64]]]: ...
     @overload
     def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
@@ -455,7 +451,6 @@ class Generator:
         right: _ArrayLikeFloat_co,
         size: Optional[_ShapeLike] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
-    # Complicated, discrete distributions:
     @overload
     def binomial(self, n: int, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
@@ -502,7 +497,6 @@ class Generator:
     def logseries(
         self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
     ) -> ndarray[Any, dtype[int64]]: ...
-    # Multivariate distributions:
     def multivariate_normal(
         self,
         mean: _ArrayLikeFloat_co,
diff --git a/numpy/random/mtrand.pyi b/numpy/random/mtrand.pyi
new file mode 100644
index 000000000..c668e7edf
--- /dev/null
+++ b/numpy/random/mtrand.pyi
@@ -0,0 +1,551 @@
+import sys
+from typing import Any, Callable, Dict, Literal, Optional, Sequence, Tuple, Type, Union, overload
+
+from numpy import (
+    bool_,
+    dtype,
+    float32,
+    float64,
+    int8,
+    int16,
+    int32,
+    int64,
+    int_,
+    ndarray,
+    uint,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+)
+from numpy.random import BitGenerator, SeedSequence
+from numpy.typing import (
+    ArrayLike,
+    _ArrayLikeFloat_co,
+    _ArrayLikeInt_co,
+    _BoolCodes,
+    _DoubleCodes,
+    _DTypeLikeBool,
+    _DTypeLikeInt,
+    _DTypeLikeUInt,
+    _Float32Codes,
+    _Float64Codes,
+    _Int8Codes,
+    _Int16Codes,
+    _Int32Codes,
+    _Int64Codes,
+    _IntCodes,
+    _ShapeLike,
+    _SingleCodes,
+    _SupportsDType,
+    _UInt8Codes,
+    _UInt16Codes,
+    _UInt32Codes,
+    _UInt64Codes,
+    _UIntCodes,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+_DTypeLikeFloat32 = Union[
+    dtype[float32],
+    _SupportsDType[dtype[float32]],
+    Type[float32],
+    _Float32Codes,
+    _SingleCodes,
+]
+
+_DTypeLikeFloat64 = Union[
+    dtype[float64],
+    _SupportsDType[dtype[float64]],
+    Type[float],
+    Type[float64],
+    _Float64Codes,
+    _DoubleCodes,
+]
+
+class RandomState:
+    _bit_generator: BitGenerator
+    def __init__(self, seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __getstate__(self) -> Dict[str, Any]: ...
+    def __setstate__(self, state: Dict[str, Any]) -> None: ...
+    def __reduce__(self) -> Tuple[Callable[[str], BitGenerator], Tuple[str], Dict[str, Any]]: ...
+    def seed(self, seed: Optional[_ArrayLikeFloat_co] = ...) -> None: ...
+    @overload
+    def get_state(self, legacy: Literal[False] = ...) -> Dict[str, Any]: ...
+    @overload
+    def get_state(
+        self, legacy: Literal[True] = ...
+    ) -> Union[Dict[str, Any], Tuple[str, ndarray[Any, dtype[uint32]], int, int, float]]: ...
+    def set_state(
+        self, state: Union[Dict[str, Any], Tuple[str, ndarray[Any, dtype[uint32]], int, int, float]]
+    ) -> None: ...
+    @overload
+    def random_sample(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def random_sample(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def random(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def random(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def beta(self, a: float, b: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def beta(
+        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def exponential(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def exponential(
+        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_exponential(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_exponential(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def tomaxint(self, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def tomaxint(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: Optional[int] = ...,
+        size: None = ...,
+        dtype: _DTypeLikeBool = ...,
+    ) -> bool: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: Optional[int] = ...,
+        size: None = ...,
+        dtype: Union[_DTypeLikeInt, _DTypeLikeUInt] = ...,
+    ) -> int: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[bool_], Type[bool], Type[bool_], _BoolCodes, _SupportsDType[dtype[bool_]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[bool_]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[int_], Type[int], Type[int_], _IntCodes, _SupportsDType[dtype[int_]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[uint], Type[uint], _UIntCodes, _SupportsDType[dtype[uint]]] = ...,
+    ) -> ndarray[Any, dtype[uint]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[int8], Type[int8], _Int8Codes, _SupportsDType[dtype[int8]]] = ...,
+    ) -> ndarray[Any, dtype[int8]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[int16], Type[int16], _Int16Codes, _SupportsDType[dtype[int16]]] = ...,
+    ) -> ndarray[Any, dtype[int16]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[int32], Type[int32], _Int32Codes, _SupportsDType[dtype[int32]]] = ...,
+    ) -> ndarray[Any, dtype[Union[int32]]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Optional[
+            Union[dtype[int64], Type[int64], _Int64Codes, _SupportsDType[dtype[int64]]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[int64]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[uint8], Type[uint8], _UInt8Codes, _SupportsDType[dtype[uint8]]] = ...,
+    ) -> ndarray[Any, dtype[uint8]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[uint16], Type[uint16], _UInt16Codes, _SupportsDType[dtype[uint16]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[Union[uint16]]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[uint32], Type[uint32], _UInt32Codes, _SupportsDType[dtype[uint32]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[uint32]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[uint64], Type[uint64], _UInt64Codes, _SupportsDType[dtype[uint64]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[uint64]]: ...
+    def bytes(self, length: int) -> str: ...
+    def choice(
+        self,
+        a: ArrayLike,
+        size: Optional[_ShapeLike] = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+    ) -> Any: ...
+    @overload
+    def uniform(self, low: float = ..., high: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def uniform(
+        self,
+        low: _ArrayLikeFloat_co = ...,
+        high: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def rand(self, *args: None) -> float: ...
+    @overload
+    def rand(self, *args: Sequence[int]) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def randn(self, *args: None) -> float: ...
+    @overload
+    def randn(self, *args: Sequence[int]) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def random_integers(self, low: int, high: Optional[int] = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def random_integers(
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def standard_normal(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self, size: _ShapeLike = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def normal(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def normal(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_gamma(  # type: ignore[misc]
+        self,
+        shape: float,
+        size: None = ...,
+    ) -> float: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def f(self, dfnum: float, dfden: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def f(
+        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def noncentral_f(self, dfnum: float, dfden: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_f(
+        self,
+        dfnum: _ArrayLikeFloat_co,
+        dfden: _ArrayLikeFloat_co,
+        nonc: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def chisquare(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def chisquare(
+        self, df: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def noncentral_chisquare(self, df: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_chisquare(
+        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_t(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: None = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: _ShapeLike = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def vonmises(self, mu: float, kappa: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def vonmises(
+        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def pareto(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def pareto(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def weibull(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def weibull(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def power(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def power(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_cauchy(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def laplace(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def laplace(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def gumbel(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def gumbel(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def logistic(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def logistic(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def lognormal(self, mean: float = ..., sigma: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def lognormal(
+        self,
+        mean: _ArrayLikeFloat_co = ...,
+        sigma: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def rayleigh(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def rayleigh(
+        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def wald(self, mean: float, scale: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def wald(
+        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def triangular(self, left: float, mode: float, right: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def triangular(
+        self,
+        left: _ArrayLikeFloat_co,
+        mode: _ArrayLikeFloat_co,
+        right: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def binomial(self, n: int, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def binomial(
+        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def negative_binomial(self, n: float, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def negative_binomial(
+        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def poisson(self, lam: float = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def poisson(
+        self, lam: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def zipf(self, a: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def zipf(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def geometric(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def geometric(
+        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def hypergeometric(
+        self,
+        ngood: _ArrayLikeInt_co,
+        nbad: _ArrayLikeInt_co,
+        nsample: _ArrayLikeInt_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def logseries(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def logseries(
+        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    def multivariate_normal(
+        self,
+        mean: _ArrayLikeFloat_co,
+        cov: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+        check_valid: Literal["warn", "raise", "ignore"] = ...,
+        tol: float = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    def multinomial(
+        self, n: _ArrayLikeInt_co, pvals: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    def multivariate_hypergeometric(
+        self,
+        colors: _ArrayLikeInt_co,
+        nsample: int,
+        size: Optional[_ShapeLike] = ...,
+        method: Literal["marginals", "count"] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    def dirichlet(
+        self, alpha: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    def shuffle(self, x: ArrayLike) -> Sequence[Any]: ...
+    @overload
+    def permutation(self, x: int) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def permutation(self, x: ArrayLike) -> ndarray[Any, Any]: ...
+
+_rand: RandomState
+
+beta = _rand.beta
+binomial = _rand.binomial
+bytes = _rand.bytes
+chisquare = _rand.chisquare
+choice = _rand.choice
+dirichlet = _rand.dirichlet
+exponential = _rand.exponential
+f = _rand.f
+gamma = _rand.gamma
+get_state = _rand.get_state
+geometric = _rand.geometric
+gumbel = _rand.gumbel
+hypergeometric = _rand.hypergeometric
+laplace = _rand.laplace
+logistic = _rand.logistic
+lognormal = _rand.lognormal
+logseries = _rand.logseries
+multinomial = _rand.multinomial
+multivariate_normal = _rand.multivariate_normal
+negative_binomial = _rand.negative_binomial
+noncentral_chisquare = _rand.noncentral_chisquare
+noncentral_f = _rand.noncentral_f
+normal = _rand.normal
+pareto = _rand.pareto
+permutation = _rand.permutation
+poisson = _rand.poisson
+power = _rand.power
+rand = _rand.rand
+randint = _rand.randint
+randn = _rand.randn
+random = _rand.random
+random_integers = _rand.random_integers
+random_sample = _rand.random_sample
+rayleigh = _rand.rayleigh
+seed = _rand.seed
+set_state = _rand.set_state
+shuffle = _rand.shuffle
+standard_cauchy = _rand.standard_cauchy
+standard_exponential = _rand.standard_exponential
+standard_gamma = _rand.standard_gamma
+standard_normal = _rand.standard_normal
+standard_t = _rand.standard_t
+triangular = _rand.triangular
+uniform = _rand.uniform
+vonmises = _rand.vonmises
+wald = _rand.wald
+weibull = _rand.weibull
+zipf = _rand.zipf
+# Two legacy that are trivial wrappers around random_sample
+sample = _rand.random_sample
+ranf = _rand.random_sample