diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index e5c30bc42..144260552 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -30,7 +30,7 @@ repos:
         - flake8-pyi==22.8.2
         types: [pyi]
         args: [
-          --ignore=E301 E302 E305 E402 E501 E701 E704 F401 F811 W503 Y019 Y026 Y027 Y034 Y037 Y041,
+          --ignore=E301 E302 E305 E402 E501 E701 E704 F401 F811 W503 Y019 Y027 Y034 Y037 Y041 Y042,
           # TypeVars in private files are already private
           --per-file-ignores=_*.pyi:Y001
         ]
diff --git a/pandas-stubs/_libs/tslibs/nattype.pyi b/pandas-stubs/_libs/tslibs/nattype.pyi
index 06a3ae275..08568c24e 100644
--- a/pandas-stubs/_libs/tslibs/nattype.pyi
+++ b/pandas-stubs/_libs/tslibs/nattype.pyi
@@ -6,6 +6,7 @@ from datetime import (
 from typing import Union
 
 import numpy as np
+from typing_extensions import TypeAlias
 
 from pandas._libs.tslibs.period import Period
 
@@ -13,7 +14,9 @@ NaT: NaTType
 iNaT: int
 nat_strings: set[str]
 
-_NaTComparisonTypes = Union[datetime, timedelta, Period, np.datetime64, np.timedelta64]
+_NaTComparisonTypes: TypeAlias = Union[
+    datetime, timedelta, Period, np.datetime64, np.timedelta64
+]
 
 class _NatComparison:
     def __call__(self, other: _NaTComparisonTypes) -> bool: ...
diff --git a/pandas-stubs/_libs/tslibs/timedeltas.pyi b/pandas-stubs/_libs/tslibs/timedeltas.pyi
index 01f948b91..75ff28c87 100644
--- a/pandas-stubs/_libs/tslibs/timedeltas.pyi
+++ b/pandas-stubs/_libs/tslibs/timedeltas.pyi
@@ -7,6 +7,7 @@ from typing import (
 )
 
 import numpy as np
+from typing_extensions import TypeAlias
 
 from pandas._libs.tslibs import (
     NaTType,
@@ -16,7 +17,7 @@ from pandas._typing import npt
 
 # This should be kept consistent with the keys in the dict timedelta_abbrevs
 # in pandas/_libs/tslibs/timedeltas.pyx
-UnitChoices = Literal[
+UnitChoices: TypeAlias = Literal[
     "Y",
     "y",
     "M",
diff --git a/pandas-stubs/_typing.pyi b/pandas-stubs/_typing.pyi
index 0220a8161..2dee6ad3a 100644
--- a/pandas-stubs/_typing.pyi
+++ b/pandas-stubs/_typing.pyi
@@ -1,17 +1,8 @@
 from builtins import type as type_t
 import datetime
-from io import (
-    BufferedIOBase,
-    RawIOBase,
-    TextIOBase,
-    TextIOWrapper,
-)
-from mmap import mmap
 from os import PathLike
 from typing import (
-    IO,
     Any,
-    AnyStr,
     Callable,
     Hashable,
     Iterator,
@@ -32,6 +23,7 @@ from pandas.core.generic import NDFrame
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.indexes.base import Index
 from pandas.core.series import Series
+from typing_extensions import TypeAlias
 
 from pandas._libs.tslibs import (
     Period,
@@ -43,22 +35,28 @@ from pandas.core.dtypes.dtypes import ExtensionDtype
 
 from pandas.io.formats.format import EngFormatter
 
-ArrayLike = Union[ExtensionArray, np.ndarray]
-AnyArrayLike = Union[Index, Series, np.ndarray]
-PythonScalar = Union[str, bool, complex]
+ArrayLike: TypeAlias = Union[ExtensionArray, np.ndarray]
+AnyArrayLike: TypeAlias = Union[Index, Series, np.ndarray]
+PythonScalar: TypeAlias = Union[str, bool, complex]
 DatetimeLikeScalar = TypeVar("DatetimeLikeScalar", Period, Timestamp, Timedelta)
-PandasScalar = Union[bytes, datetime.date, datetime.datetime, datetime.timedelta]
-# Scalar = Union[PythonScalar, PandasScalar]
+PandasScalar: TypeAlias = Union[
+    bytes, datetime.date, datetime.datetime, datetime.timedelta
+]
+# Scalar: TypeAlias = Union[PythonScalar, PandasScalar]
 
-DatetimeLike = Union[datetime.date, datetime.datetime, np.datetime64, Timestamp]
+DatetimeLike: TypeAlias = Union[
+    datetime.date, datetime.datetime, np.datetime64, Timestamp
+]
 
 # dtypes
-NpDtype = Union[str, np.dtype[np.generic], type[Union[str, complex, bool, object]]]
-Dtype = Union[ExtensionDtype, NpDtype]
-AstypeArg = Union[ExtensionDtype, npt.DTypeLike]
+NpDtype: TypeAlias = Union[
+    str, np.dtype[np.generic], type[Union[str, complex, bool, object]]
+]
+Dtype: TypeAlias = Union[ExtensionDtype, NpDtype]
+AstypeArg: TypeAlias = Union[ExtensionDtype, npt.DTypeLike]
 # DtypeArg specifies all allowable dtypes in a functions its dtype argument
-DtypeArg = Union[Dtype, dict[Any, Dtype]]
-DtypeObj = Union[np.dtype[np.generic], ExtensionDtype]
+DtypeArg: TypeAlias = Union[Dtype, dict[Any, Dtype]]
+DtypeObj: TypeAlias = Union[np.dtype[np.generic], ExtensionDtype]
 
 # filenames and file-like-objects
 AnyStr_cov = TypeVar("AnyStr_cov", str, bytes, covariant=True)
@@ -91,47 +89,48 @@ class ReadCsvBuffer(ReadBuffer[AnyStr_cov], Protocol[AnyStr_cov]):
 class WriteExcelBuffer(WriteBuffer[bytes], Protocol):
     def truncate(self, size: int | None = ...) -> int: ...
 
-FilePath = Union[str, PathLike[str]]
-FilePathOrBuffer = Union[
-    FilePath, IO[AnyStr], RawIOBase, BufferedIOBase, TextIOBase, TextIOWrapper, mmap
-]
-
-Axis = Union[str, int]
-IndexLabel = Union[Hashable, Sequence[Hashable]]
-Label = Optional[Hashable]
-Level = Union[Hashable, int]
-Suffixes = tuple[Optional[str], Optional[str]]
-Ordered = Optional[bool]
-JSONSerializable = Union[PythonScalar, list, dict]
-Axes = Union[AnyArrayLike, list, dict, range]
-Renamer = Union[Mapping[Any, Label], Callable[[Any], Label]]
+FilePath: TypeAlias = Union[str, PathLike[str]]
+
+Axis: TypeAlias = Union[str, int]
+IndexLabel: TypeAlias = Union[Hashable, Sequence[Hashable]]
+Label: TypeAlias = Optional[Hashable]
+Level: TypeAlias = Union[Hashable, int]
+Suffixes: TypeAlias = tuple[Optional[str], Optional[str]]
+Ordered: TypeAlias = Optional[bool]
+JSONSerializable: TypeAlias = Union[PythonScalar, list, dict]
+Axes: TypeAlias = Union[AnyArrayLike, list, dict, range]
+Renamer: TypeAlias = Union[Mapping[Any, Label], Callable[[Any], Label]]
 T = TypeVar("T")
-FuncType = Callable[..., Any]
+FuncType: TypeAlias = Callable[..., Any]
 F = TypeVar("F", bound=FuncType)
 HashableT = TypeVar("HashableT", bound=Hashable)
 
-AggFuncTypeBase = Union[Callable, str, np.ufunc]
-AggFuncTypeDictSeries = dict[Hashable, AggFuncTypeBase]
-AggFuncTypeDictFrame = dict[Hashable, Union[AggFuncTypeBase, list[AggFuncTypeBase]]]
-AggFuncTypeSeriesToFrame = Union[
+AggFuncTypeBase: TypeAlias = Union[Callable, str, np.ufunc]
+AggFuncTypeDictSeries: TypeAlias = dict[Hashable, AggFuncTypeBase]
+AggFuncTypeDictFrame: TypeAlias = dict[
+    Hashable, Union[AggFuncTypeBase, list[AggFuncTypeBase]]
+]
+AggFuncTypeSeriesToFrame: TypeAlias = Union[
     list[AggFuncTypeBase],
     AggFuncTypeDictSeries,
 ]
-AggFuncTypeFrame = Union[
+AggFuncTypeFrame: TypeAlias = Union[
     AggFuncTypeBase,
     list[AggFuncTypeBase],
     AggFuncTypeDictFrame,
 ]
 
-num = complex
-SeriesAxisType = Literal["index", 0]  # Restricted subset of _AxisType for series
-AxisType = Literal["columns", "index", 0, 1]
+num: TypeAlias = complex
+SeriesAxisType: TypeAlias = Literal[
+    "index", 0
+]  # Restricted subset of _AxisType for series
+AxisType: TypeAlias = Literal["columns", "index", 0, 1]
 DtypeNp = TypeVar("DtypeNp", bound=np.dtype[np.generic])
-KeysArgType = Any
+KeysArgType: TypeAlias = Any
 ListLike = TypeVar("ListLike", Sequence, np.ndarray, "Series", "Index")
-ListLikeU = Union[Sequence, np.ndarray, Series, Index]
-StrLike = Union[str, np.str_]
-Scalar = Union[
+ListLikeU: TypeAlias = Union[Sequence, np.ndarray, Series, Index]
+StrLike: TypeAlias = Union[str, np.str_]
+Scalar: TypeAlias = Union[
     str,
     bytes,
     datetime.date,
@@ -146,14 +145,14 @@ Scalar = Union[
 ]
 ScalarT = TypeVar("ScalarT", bound=Scalar)
 # Refine the definitions below in 3.9 to use the specialized type.
-np_ndarray_int64 = npt.NDArray[np.int64]
-np_ndarray_int = npt.NDArray[np.signedinteger]
-np_ndarray_anyint = npt.NDArray[np.integer]
-np_ndarray_bool = npt.NDArray[np.bool_]
-np_ndarray_str = npt.NDArray[np.str_]
-
-IndexType = Union[slice, np_ndarray_int64, Index, list[int], Series[int]]
-MaskType = Union[Series[bool], np_ndarray_bool, list[bool]]
+np_ndarray_int64: TypeAlias = npt.NDArray[np.int64]
+np_ndarray_int: TypeAlias = npt.NDArray[np.signedinteger]
+np_ndarray_anyint: TypeAlias = npt.NDArray[np.integer]
+np_ndarray_bool: TypeAlias = npt.NDArray[np.bool_]
+np_ndarray_str: TypeAlias = npt.NDArray[np.str_]
+
+IndexType: TypeAlias = Union[slice, np_ndarray_int64, Index, list[int], Series[int]]
+MaskType: TypeAlias = Union[Series[bool], np_ndarray_bool, list[bool]]
 # Scratch types for generics
 S1 = TypeVar(
     "S1",
@@ -177,13 +176,13 @@ T1 = TypeVar(
 )
 T2 = TypeVar("T2", str, int)
 
-IndexingInt = Union[
+IndexingInt: TypeAlias = Union[
     int, np.int_, np.integer, np.unsignedinteger, np.signedinteger, np.int8
 ]
-TimestampConvertibleTypes = Union[
+TimestampConvertibleTypes: TypeAlias = Union[
     Timestamp, datetime.datetime, np.datetime64, np.int64, float, str
 ]
-TimedeltaConvertibleTypes = Union[
+TimedeltaConvertibleTypes: TypeAlias = Union[
     Timedelta, datetime.timedelta, np.timedelta64, np.int64, float, str
 ]
 # NDFrameT is stricter and ensures that the same subclass of NDFrame always is
@@ -196,39 +195,39 @@ IndexT = TypeVar("IndexT", bound=Index)
 
 # Interval closed type
 
-IntervalClosedType = Literal["left", "right", "both", "neither"]
+IntervalClosedType: TypeAlias = Literal["left", "right", "both", "neither"]
 
-DateTimeErrorChoices = Literal["ignore", "raise", "coerce"]
+DateTimeErrorChoices: TypeAlias = Literal["ignore", "raise", "coerce"]
 
 # Shared by functions such as drop and astype
-IgnoreRaise = Literal["ignore", "raise"]
+IgnoreRaise: TypeAlias = Literal["ignore", "raise"]
 
 # for arbitrary kwargs passed during reading/writing files
-StorageOptions = Optional[dict[str, Any]]
+StorageOptions: TypeAlias = Optional[dict[str, Any]]
 
 # compression keywords and compression
-CompressionDict = dict[str, Any]
-CompressionOptions = Optional[
+CompressionDict: TypeAlias = dict[str, Any]
+CompressionOptions: TypeAlias = Optional[
     Union[Literal["infer", "gzip", "bz2", "zip", "xz", "zstd"], CompressionDict]
 ]
-FormattersType = Union[
+FormattersType: TypeAlias = Union[
     list[Callable], tuple[Callable, ...], Mapping[Union[str, int], Callable]
 ]
-FloatFormatType = str | Callable | EngFormatter
+FloatFormatType: TypeAlias = str | Callable | EngFormatter
 # converters
-ConvertersArg = dict[Hashable, Callable[[Dtype], Dtype]]
+ConvertersArg: TypeAlias = dict[Hashable, Callable[[Dtype], Dtype]]
 
 # parse_dates
-ParseDatesArg = Union[
+ParseDatesArg: TypeAlias = Union[
     bool, list[Hashable], list[list[Hashable]], dict[Hashable, list[Hashable]]
 ]
 
 # read_xml parsers
-XMLParsers = Literal["lxml", "etree"]
+XMLParsers: TypeAlias = Literal["lxml", "etree"]
 
 # Any plain Python or numpy function
-Function = Union[np.ufunc, Callable[..., Any]]
-GroupByObjectNonScalar = Union[
+Function: TypeAlias = Union[np.ufunc, Callable[..., Any]]
+GroupByObjectNonScalar: TypeAlias = Union[
     tuple,
     list[HashableT],
     Function,
@@ -244,9 +243,9 @@ GroupByObjectNonScalar = Union[
     Grouper,
     list[Grouper],
 ]
-GroupByObject = Union[Scalar, GroupByObjectNonScalar]
+GroupByObject: TypeAlias = Union[Scalar, GroupByObjectNonScalar]
 
-StataDateFormat = Literal[
+StataDateFormat: TypeAlias = Literal[
     "tc",
     "%tc",
     "td",
@@ -263,37 +262,43 @@ StataDateFormat = Literal[
     "%ty",
 ]
 
-FillnaOptions = Literal["backfill", "bfill", "ffill", "pad"]
-ReplaceMethod = Literal["pad", "ffill", "bfill"]
-SortKind = Literal["quicksort", "mergesort", "heapsort", "stable"]
-NaPosition = Literal["first", "last"]
-MergeHow = Literal["left", "right", "outer", "inner"]
-JsonFrameOrient = Literal["split", "records", "index", "columns", "values", "table"]
-JsonSeriesOrient = Literal["split", "records", "index"]
+FillnaOptions: TypeAlias = Literal["backfill", "bfill", "ffill", "pad"]
+ReplaceMethod: TypeAlias = Literal["pad", "ffill", "bfill"]
+SortKind: TypeAlias = Literal["quicksort", "mergesort", "heapsort", "stable"]
+NaPosition: TypeAlias = Literal["first", "last"]
+MergeHow: TypeAlias = Literal["left", "right", "outer", "inner"]
+JsonFrameOrient: TypeAlias = Literal[
+    "split", "records", "index", "columns", "values", "table"
+]
+JsonSeriesOrient: TypeAlias = Literal["split", "records", "index"]
 
-TimestampConvention = Literal["start", "end", "s", "e"]
+TimestampConvention: TypeAlias = Literal["start", "end", "s", "e"]
 
-CSVEngine = Literal["c", "python", "pyarrow", "python-fwf"]
-CSVQuoting = Literal[0, 1, 2, 3]
+CSVEngine: TypeAlias = Literal["c", "python", "pyarrow", "python-fwf"]
+CSVQuoting: TypeAlias = Literal[0, 1, 2, 3]
 
-HDFCompLib = Literal["zlib", "lzo", "bzip2", "blosc"]
-ParquetEngine = Literal["auto", "pyarrow", "fastparquet"]
-FileWriteMode = Literal[
+HDFCompLib: TypeAlias = Literal["zlib", "lzo", "bzip2", "blosc"]
+ParquetEngine: TypeAlias = Literal["auto", "pyarrow", "fastparquet"]
+FileWriteMode: TypeAlias = Literal[
     "a", "w", "x", "at", "wt", "xt", "ab", "wb", "xb", "w+", "w+b", "a+", "a+b"
 ]
-ColspaceArgType = str | int | Sequence[int | str] | Mapping[Hashable, str | int]
+ColspaceArgType: TypeAlias = (
+    str | int | Sequence[int | str] | Mapping[Hashable, str | int]
+)
 
 # Windowing rank methods
-WindowingRankType = Literal["average", "min", "max"]
-WindowingEngine = Union[Literal["cython", "numba"], None]
+WindowingRankType: TypeAlias = Literal["average", "min", "max"]
+WindowingEngine: TypeAlias = Union[Literal["cython", "numba"], None]
 
 class _WindowingNumbaKwargs(TypedDict, total=False):
     nopython: bool
     nogil: bool
     parallel: bool
 
-WindowingEngineKwargs = Union[_WindowingNumbaKwargs, None]
-QuantileInterpolation = Literal["linear", "lower", "higher", "midpoint", "nearest"]
+WindowingEngineKwargs: TypeAlias = Union[_WindowingNumbaKwargs, None]
+QuantileInterpolation: TypeAlias = Literal[
+    "linear", "lower", "higher", "midpoint", "nearest"
+]
 
 class StyleExportDict(TypedDict, total=False):
     apply: Any
@@ -305,6 +310,6 @@ class StyleExportDict(TypedDict, total=False):
     hide_column_names: bool
     css: dict[str, str | int]
 
-CalculationMethod = Literal["single", "table"]
+CalculationMethod: TypeAlias = Literal["single", "table"]
 
 __all__ = ["npt", "type_t"]
diff --git a/pandas-stubs/_version.pyi b/pandas-stubs/_version.pyi
index 848884b63..65088d4dd 100644
--- a/pandas-stubs/_version.pyi
+++ b/pandas-stubs/_version.pyi
@@ -4,4 +4,4 @@ version_json: str = ...
 
 def get_versions(): ...
 
-_stub_version = Literal["1.5.0.220926"]
+_stub_version: Literal["1.5.0.220926"]
diff --git a/pandas-stubs/core/dtypes/common.pyi b/pandas-stubs/core/dtypes/common.pyi
index cdaa9f9be..3da5a0091 100644
--- a/pandas-stubs/core/dtypes/common.pyi
+++ b/pandas-stubs/core/dtypes/common.pyi
@@ -2,6 +2,7 @@ from typing import Union
 
 import numpy as np
 import pandas as pd
+from typing_extensions import TypeAlias
 
 from pandas._typing import (
     ArrayLike,
@@ -28,7 +29,7 @@ from pandas.core.dtypes.inference import (
     is_scalar as is_scalar,
 )
 
-_ArrayOrDtype = Union[ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame]
+_ArrayOrDtype: TypeAlias = Union[ArrayLike, npt.DTypeLike, pd.Series, pd.DataFrame]
 
 def is_object_dtype(arr_or_dtype: _ArrayOrDtype) -> bool: ...
 def is_sparse(arr: ArrayLike | pd.Series | pd.DataFrame) -> bool: ...
diff --git a/pandas-stubs/core/dtypes/generic.pyi b/pandas-stubs/core/dtypes/generic.pyi
index b21be6371..7ef048ddd 100644
--- a/pandas-stubs/core/dtypes/generic.pyi
+++ b/pandas-stubs/core/dtypes/generic.pyi
@@ -1,5 +1,6 @@
 from pandas import Series
 from pandas.core.arrays import ExtensionArray
+from typing_extensions import TypeAlias
 
-ABCSeries = type[Series]
-ABCExtensionArray = type[ExtensionArray]
+ABCSeries: TypeAlias = type[Series]
+ABCExtensionArray: TypeAlias = type[ExtensionArray]
diff --git a/pandas-stubs/core/frame.pyi b/pandas-stubs/core/frame.pyi
index 89c0d8c14..ac53243c1 100644
--- a/pandas-stubs/core/frame.pyi
+++ b/pandas-stubs/core/frame.pyi
@@ -64,7 +64,6 @@ from pandas._typing import (
     CompressionOptions,
     Dtype,
     FilePath,
-    FilePathOrBuffer,
     FillnaOptions,
     FloatFormatType,
     FormattersType,
@@ -1912,7 +1911,7 @@ class DataFrame(NDFrame, OpsMixin):
     @overload
     def to_json(
         self,
-        path_or_buf: FilePathOrBuffer | None,
+        path_or_buf: FilePath | WriteBuffer[str],
         orient: JsonFrameOrient | None = ...,
         date_format: Literal["epoch", "iso"] | None = ...,
         double_precision: int = ...,
@@ -1928,6 +1927,7 @@ class DataFrame(NDFrame, OpsMixin):
     @overload
     def to_json(
         self,
+        path_or_buf: None = ...,
         orient: JsonFrameOrient | None = ...,
         date_format: Literal["epoch", "iso"] | None = ...,
         double_precision: int = ...,
diff --git a/pandas-stubs/core/generic.pyi b/pandas-stubs/core/generic.pyi
index 17f4025ee..21b1f7b9b 100644
--- a/pandas-stubs/core/generic.pyi
+++ b/pandas-stubs/core/generic.pyi
@@ -29,7 +29,6 @@ from pandas._typing import (
     Dtype,
     DtypeArg,
     FilePath,
-    FilePathOrBuffer,
     FileWriteMode,
     FillnaOptions,
     HashableT,
@@ -140,7 +139,7 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
     @overload
     def to_markdown(
         self,
-        buf: FilePathOrBuffer,
+        buf: FilePath | WriteBuffer[str],
         mode: FileWriteMode | None = ...,
         index: _bool = ...,
         storage_options: StorageOptions = ...,
@@ -182,7 +181,7 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
     @overload
     def to_latex(
         self,
-        buf: FilePathOrBuffer | None,
+        buf: FilePath | WriteBuffer[str],
         columns: list[_str] | None = ...,
         col_space: int | None = ...,
         header: _bool | list[_str] = ...,
@@ -208,6 +207,7 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
     @overload
     def to_latex(
         self,
+        buf: None = ...,
         columns: list[_str] | None = ...,
         col_space: int | None = ...,
         header: _bool | list[_str] = ...,
@@ -233,7 +233,7 @@ class NDFrame(PandasObject, indexing.IndexingMixin):
     @overload
     def to_csv(
         self,
-        path_or_buf: FilePathOrBuffer,
+        path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str],
         sep: _str = ...,
         na_rep: _str = ...,
         float_format: _str | Callable[[object], _str] | None = ...,
diff --git a/pandas-stubs/core/groupby/generic.pyi b/pandas-stubs/core/groupby/generic.pyi
index d51792674..0cc15a2b9 100644
--- a/pandas-stubs/core/groupby/generic.pyi
+++ b/pandas-stubs/core/groupby/generic.pyi
@@ -23,6 +23,7 @@ from pandas.core.groupby.groupby import (  # , get_groupby as get_groupby
 )
 from pandas.core.groupby.grouper import Grouper
 from pandas.core.series import Series
+from typing_extensions import TypeAlias
 
 from pandas._typing import (
     S1,
@@ -34,7 +35,7 @@ from pandas._typing import (
     Scalar,
 )
 
-AggScalar = Union[str, Callable[..., Any]]
+AggScalar: TypeAlias = Union[str, Callable[..., Any]]
 ScalarResult = ...
 
 class NamedAgg(NamedTuple):
diff --git a/pandas-stubs/core/indexing.pyi b/pandas-stubs/core/indexing.pyi
index 0ce8f51bf..35a748fcd 100644
--- a/pandas-stubs/core/indexing.pyi
+++ b/pandas-stubs/core/indexing.pyi
@@ -5,6 +5,7 @@ from typing import (
 
 import numpy as np
 from pandas.core.indexes.api import Index
+from typing_extensions import TypeAlias
 
 from pandas._libs.indexing import _NDFrameIndexerBase
 from pandas._typing import (
@@ -13,9 +14,11 @@ from pandas._typing import (
     ScalarT,
 )
 
-_IndexSliceTuple = tuple[Union[Index, MaskType, Scalar, list[ScalarT], slice], ...]
+_IndexSliceTuple: TypeAlias = tuple[
+    Union[Index, MaskType, Scalar, list[ScalarT], slice], ...
+]
 
-_IndexSliceUnion = Union[slice, _IndexSliceTuple]
+_IndexSliceUnion: TypeAlias = Union[slice, _IndexSliceTuple]
 
 _IndexSliceUnionT = TypeVar("_IndexSliceUnionT", bound=_IndexSliceUnion)
 
diff --git a/pandas-stubs/core/resample.pyi b/pandas-stubs/core/resample.pyi
index f01aca473..548c3cd12 100644
--- a/pandas-stubs/core/resample.pyi
+++ b/pandas-stubs/core/resample.pyi
@@ -16,6 +16,7 @@ from pandas import (
 )
 from pandas.core.groupby.generic import SeriesGroupBy
 from pandas.core.groupby.groupby import BaseGroupBy
+from typing_extensions import TypeAlias
 
 from pandas._typing import (
     AxisType,
@@ -24,24 +25,30 @@ from pandas._typing import (
     npt,
 )
 
-_FrameGroupByFunc = (
+_FrameGroupByFunc: TypeAlias = (
     Callable[[DataFrame], Scalar]
     | Callable[[DataFrame], Series]
     | Callable[[DataFrame], DataFrame]
     | np.ufunc
 )
-_FrameGroupByFuncTypes = _FrameGroupByFunc | str | list[_FrameGroupByFunc | str]
-_FrameGroupByFuncArgs = (
+_FrameGroupByFuncTypes: TypeAlias = (
+    _FrameGroupByFunc | str | list[_FrameGroupByFunc | str]
+)
+_FrameGroupByFuncArgs: TypeAlias = (
     _FrameGroupByFuncTypes | Mapping[Hashable, _FrameGroupByFuncTypes]
 )
 
-_SeriesGroupByFunc = Callable[[Series], Scalar] | Callable[[Series], Series] | np.ufunc
-_SeriesGroupByFuncTypes = _SeriesGroupByFunc | str | list[_SeriesGroupByFunc | str]
-_SeriesGroupByFuncArgs = (
+_SeriesGroupByFunc: TypeAlias = (
+    Callable[[Series], Scalar] | Callable[[Series], Series] | np.ufunc
+)
+_SeriesGroupByFuncTypes: TypeAlias = (
+    _SeriesGroupByFunc | str | list[_SeriesGroupByFunc | str]
+)
+_SeriesGroupByFuncArgs: TypeAlias = (
     _SeriesGroupByFuncTypes | Mapping[Hashable, _SeriesGroupByFunc | str]
 )
 
-_Interpolation = Literal[
+_Interpolation: TypeAlias = Literal[
     "linear",
     "time",
     "index",
diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index 6184fe833..2920b8252 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -60,6 +60,7 @@ from pandas.core.window.rolling import (
     Rolling,
     Window,
 )
+from typing_extensions import TypeAlias
 import xarray as xr
 
 from pandas._libs.missing import NAType
@@ -76,7 +77,7 @@ from pandas._typing import (
     CalculationMethod,
     CompressionOptions,
     DtypeObj,
-    FilePathOrBuffer,
+    FilePath,
     FillnaOptions,
     GroupByObjectNonScalar,
     HashableT,
@@ -95,6 +96,7 @@ from pandas._typing import (
     SeriesAxisType,
     SortKind,
     TimestampConvention,
+    WriteBuffer,
     np_ndarray_anyint,
     npt,
     num,
@@ -165,7 +167,7 @@ class _LocIndexerSeries(_LocIndexer, Generic[S1]):
 
 class Series(IndexOpsMixin, NDFrame, Generic[S1]):
 
-    _ListLike = Union[ArrayLike, dict[_str, np.ndarray], list, tuple, Index]
+    _ListLike: TypeAlias = Union[ArrayLike, dict[_str, np.ndarray], list, tuple, Index]
     __hash__: ClassVar[None]
 
     @overload
@@ -337,7 +339,7 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     @overload
     def to_string(
         self,
-        buf: FilePathOrBuffer | None,
+        buf: FilePath | WriteBuffer[str],
         na_rep: _str = ...,
         formatters=...,
         float_format=...,
@@ -356,6 +358,7 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     @overload
     def to_string(
         self,
+        buf: None = ...,
         na_rep: _str = ...,
         formatters=...,
         float_format=...,
@@ -374,7 +377,7 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     @overload
     def to_json(
         self,
-        path_or_buf: FilePathOrBuffer | None,
+        path_or_buf: FilePath | WriteBuffer[str],
         orient: JsonSeriesOrient | None = ...,
         date_format: Literal["epoch", "iso"] | None = ...,
         double_precision: int = ...,
@@ -390,6 +393,7 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     @overload
     def to_json(
         self,
+        path_or_buf: None = ...,
         orient: JsonSeriesOrient | None = ...,
         date_format: Literal["epoch", "iso"] | None = ...,
         double_precision: int = ...,
diff --git a/pandas-stubs/core/tools/datetimes.pyi b/pandas-stubs/core/tools/datetimes.pyi
index 4b580ce19..abd8dbebd 100644
--- a/pandas-stubs/core/tools/datetimes.pyi
+++ b/pandas-stubs/core/tools/datetimes.pyi
@@ -18,6 +18,7 @@ from pandas.core.series import (
     Series,
     TimestampSeries,
 )
+from typing_extensions import TypeAlias
 
 from pandas._libs.tslibs import NaTType
 from pandas._typing import (
@@ -26,13 +27,13 @@ from pandas._typing import (
     IgnoreRaise,
 )
 
-ArrayConvertible = Union[list, tuple, AnyArrayLike]
-Scalar = Union[float, str]
-DatetimeScalar = Union[Scalar, datetime, np.datetime64]
+ArrayConvertible: TypeAlias = Union[list, tuple, AnyArrayLike]
+Scalar: TypeAlias = Union[float, str]
+DatetimeScalar: TypeAlias = Union[Scalar, datetime, np.datetime64]
 
-DatetimeScalarOrArrayConvertible = Union[DatetimeScalar, ArrayConvertible]
+DatetimeScalarOrArrayConvertible: TypeAlias = Union[DatetimeScalar, ArrayConvertible]
 
-DatetimeDictArg = Union[list[Scalar], tuple[Scalar, ...], AnyArrayLike]
+DatetimeDictArg: TypeAlias = Union[list[Scalar], tuple[Scalar, ...], AnyArrayLike]
 
 class YearMonthDayDict(TypedDict, total=True):
     year: DatetimeDictArg
@@ -50,7 +51,7 @@ class FulldatetimeDict(YearMonthDayDict, total=False):
     us: DatetimeDictArg
     ns: DatetimeDictArg
 
-DictConvertible = Union[FulldatetimeDict, DataFrame]
+DictConvertible: TypeAlias = Union[FulldatetimeDict, DataFrame]
 
 def should_cache(
     arg: ArrayConvertible, unique_share: float = ..., check_count: int | None = ...
diff --git a/pandas-stubs/io/formats/style_render.pyi b/pandas-stubs/io/formats/style_render.pyi
index fa139a6af..12f3ef76c 100644
--- a/pandas-stubs/io/formats/style_render.pyi
+++ b/pandas-stubs/io/formats/style_render.pyi
@@ -13,6 +13,7 @@ from typing import (
 import jinja2
 from pandas import Index
 from pandas.core.indexing import _IndexSlice
+from typing_extensions import TypeAlias
 
 from pandas._typing import (
     AxisType,
@@ -20,11 +21,11 @@ from pandas._typing import (
     Level,
 )
 
-BaseFormatter = Union[str, Callable[[object], str]]
-ExtFormatter = Union[BaseFormatter, dict[Any, Optional[BaseFormatter]]]
-CSSPair = tuple[str, Union[str, float]]
-CSSList = list[CSSPair]
-CSSProperties = Union[str, CSSList]
+BaseFormatter: TypeAlias = Union[str, Callable[[object], str]]
+ExtFormatter: TypeAlias = Union[BaseFormatter, dict[Any, Optional[BaseFormatter]]]
+CSSPair: TypeAlias = tuple[str, Union[str, float]]
+CSSList: TypeAlias = list[CSSPair]
+CSSProperties: TypeAlias = Union[str, CSSList]
 
 class CSSDict(TypedDict):
     selector: str
@@ -40,8 +41,8 @@ class StyleExportDict(TypedDict, total=False):
     hide_column_names: bool
     css: dict[str, str | int]
 
-CSSStyles = list[CSSDict]
-Subset = Union[_IndexSlice, slice, tuple[slice, ...], list[HashableT], Index]
+CSSStyles: TypeAlias = list[CSSDict]
+Subset: TypeAlias = Union[_IndexSlice, slice, tuple[slice, ...], list[HashableT], Index]
 
 _StylerT = TypeVar("_StylerT", bound=StylerRenderer)
 
diff --git a/pandas-stubs/io/sql.pyi b/pandas-stubs/io/sql.pyi
index 2f87bc4c7..128ea9831 100644
--- a/pandas-stubs/io/sql.pyi
+++ b/pandas-stubs/io/sql.pyi
@@ -13,19 +13,20 @@ from pandas.core.base import PandasObject
 from pandas.core.frame import DataFrame
 import sqlalchemy.engine
 import sqlalchemy.sql.expression
+from typing_extensions import TypeAlias
 
 from pandas._typing import (
     DtypeArg,
     npt,
 )
 
-_SQLConnection = Union[
+_SQLConnection: TypeAlias = Union[
     str,
     sqlalchemy.engine.Connectable,
     sqlite3.Connection,
 ]
 
-_SQLStatement = Union[
+_SQLStatement: TypeAlias = Union[
     str, sqlalchemy.sql.expression.Selectable, sqlalchemy.sql.expression.TextClause
 ]
 
diff --git a/pandas-stubs/plotting/_core.pyi b/pandas-stubs/plotting/_core.pyi
index 90517ccbd..33960d3d6 100644
--- a/pandas-stubs/plotting/_core.pyi
+++ b/pandas-stubs/plotting/_core.pyi
@@ -19,6 +19,7 @@ from pandas import Series
 from pandas.core.base import PandasObject
 from pandas.core.frame import DataFrame
 from scipy.stats.kde import gaussian_kde
+from typing_extensions import TypeAlias
 
 from pandas._typing import (
     ArrayLike,
@@ -30,10 +31,12 @@ class _BoxPlotT(NamedTuple):
     ax: Axes
     lines: dict[str, list[Line2D]]
 
-_SingleColor = Union[
+_SingleColor: TypeAlias = Union[
     str, list[float], tuple[float, float, float], tuple[float, float, float, float]
 ]
-_PlotAccessorColor = Union[str, list[_SingleColor], dict[HashableT, _SingleColor]]
+_PlotAccessorColor: TypeAlias = Union[
+    str, list[_SingleColor], dict[HashableT, _SingleColor]
+]
 
 @overload
 def boxplot(
diff --git a/pandas-stubs/plotting/_misc.pyi b/pandas-stubs/plotting/_misc.pyi
index cca4f1c3e..c6aefd46e 100644
--- a/pandas-stubs/plotting/_misc.pyi
+++ b/pandas-stubs/plotting/_misc.pyi
@@ -13,13 +13,14 @@ from matplotlib.table import Table
 import numpy as np
 from pandas.core.frame import DataFrame
 from pandas.core.series import Series
+from typing_extensions import TypeAlias
 
 from pandas._typing import (
     HashableT,
     npt,
 )
 
-_Color = Union[str, Sequence[float]]
+_Color: TypeAlias = Union[str, Sequence[float]]
 
 def table(
     ax: Axes,