diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index 2086b413e..3e9e46611 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -1289,12 +1289,10 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     # ignore needed for mypy as we want different results based on the arguments
     @overload  # type: ignore[override]
     def __and__(  # type: ignore[misc]
-        self, other: bool | list[bool] | np_ndarray_bool | Series[bool]
+        self, other: bool | list[bool] | list[int] | np_ndarray_bool | Series[bool]
     ) -> Series[bool]: ...
     @overload
-    def __and__(
-        self, other: int | list[int] | np_ndarray_anyint | Series[int]
-    ) -> Series[int]: ...
+    def __and__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...
     # def __array__(self, dtype: Optional[_bool] = ...) -> _np_ndarray
     def __div__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ...
     def __eq__(self, other: object) -> Series[_bool]: ...  # type: ignore[override]
@@ -1323,22 +1321,18 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     # ignore needed for mypy as we want different results based on the arguments
     @overload  # type: ignore[override]
     def __or__(  # type: ignore[misc]
-        self, other: bool | list[bool] | np_ndarray_bool | Series[bool]
+        self, other: bool | list[bool] | list[int] | np_ndarray_bool | Series[bool]
     ) -> Series[bool]: ...
     @overload
-    def __or__(
-        self, other: int | list[int] | np_ndarray_anyint | Series[int]
-    ) -> Series[int]: ...
+    def __or__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...
     def __radd__(self, other: num | _str | _ListLike | Series[S1]) -> Series[S1]: ...
     # ignore needed for mypy as we want different results based on the arguments
     @overload  # type: ignore[override]
     def __rand__(  # type: ignore[misc]
-        self, other: bool | list[bool] | np_ndarray_bool | Series[bool]
+        self, other: bool | list[bool] | list[int] | np_ndarray_bool | Series[bool]
     ) -> Series[bool]: ...
     @overload
-    def __rand__(
-        self, other: int | list[int] | np_ndarray_anyint | Series[int]
-    ) -> Series[int]: ...
+    def __rand__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...  # type: ignore[misc]
     def __rdiv__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ...
     def __rdivmod__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ...  # type: ignore[override]
     def __rfloordiv__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ...
@@ -1349,12 +1343,10 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     # ignore needed for mypy as we want different results based on the arguments
     @overload  # type: ignore[override]
     def __ror__(  # type: ignore[misc]
-        self, other: bool | list[bool] | np_ndarray_bool | Series[bool]
+        self, other: bool | list[bool] | list[int] | np_ndarray_bool | Series[bool]
     ) -> Series[bool]: ...
     @overload
-    def __ror__(
-        self, other: int | list[int] | np_ndarray_anyint | Series[int]
-    ) -> Series[int]: ...
+    def __ror__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...  # type: ignore[misc]
     def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ...
     @overload
     def __rtruediv__(self, other: TimedeltaSeries) -> Series[float]: ...
@@ -1363,12 +1355,10 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     # ignore needed for mypy as we want different results based on the arguments
     @overload  # type: ignore[override]
     def __rxor__(  # type: ignore[misc]
-        self, other: bool | list[bool] | np_ndarray_bool | Series[bool]
+        self, other: bool | list[bool] | list[int] | np_ndarray_bool | Series[bool]
     ) -> Series[bool]: ...
     @overload
-    def __rxor__(
-        self, other: int | list[int] | np_ndarray_anyint | Series[int]
-    ) -> Series[int]: ...
+    def __rxor__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...  # type: ignore[misc]
     @overload
     def __sub__(
         self, other: Timestamp | datetime | TimestampSeries
@@ -1389,12 +1379,10 @@ class Series(IndexOpsMixin, NDFrame, Generic[S1]):
     # ignore needed for mypy as we want different results based on the arguments
     @overload  # type: ignore[override]
     def __xor__(  # type: ignore[misc]
-        self, other: bool | list[bool] | np_ndarray_bool | Series[bool]
+        self, other: bool | list[bool] | list[int] | np_ndarray_bool | Series[bool]
     ) -> Series[bool]: ...
     @overload
-    def __xor__(
-        self, other: int | list[int] | np_ndarray_anyint | Series[int]
-    ) -> Series[int]: ...
+    def __xor__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ...
     def __invert__(self) -> Series[bool]: ...
     # properties
     # @property
diff --git a/pyproject.toml b/pyproject.toml
index 9f4a34d49..a24a80a41 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -49,7 +49,7 @@ pre-commit = ">=2.19.0"
 black = ">=22.12.0"
 isort = ">=5.10.1"
 openpyxl = ">=3.0.10"
-tables = { version = ">=3.7.0", python = "<3.11" }
+tables = { version = ">=3.7.0" }
 lxml = { version = ">=4.7.1,<4.9.0", python = "<3.11" }
 pyreadstat = ">=1.2.0"
 xlrd = ">=2.0.1"
diff --git a/tests/__init__.py b/tests/__init__.py
index 551ef44f4..3a43390d2 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -28,11 +28,6 @@
 )
 # This is only needed temporarily due to no wheels being available for lxml on 3.11
 
-pytables_skip = pytest.mark.skipif(
-    sys.version_info >= (3, 11), reason="pytables is not available for 3.11 yet"
-)
-# This is only needed temporarily due to no wheels being available for pytables on 3.11
-
 
 def check(actual: T, klass: type, dtype: type | None = None, attr: str = "left") -> T:
     if not isinstance(actual, klass):
@@ -40,7 +35,11 @@ def check(actual: T, klass: type, dtype: type | None = None, attr: str = "left")
     if dtype is None:
         return actual  # type: ignore[return-value]
 
-    if hasattr(actual, "__iter__"):
+    if isinstance(actual, pd.Series):
+        value = actual.iloc[0]
+    elif isinstance(actual, pd.Index):
+        value = actual[0]  # type: ignore[assignment]
+    elif hasattr(actual, "__iter__"):
         value = next(iter(actual))  # pyright: ignore[reportGeneralTypeIssues]
     else:
         assert hasattr(actual, attr)
diff --git a/tests/test_frame.py b/tests/test_frame.py
index eeb6dd924..0e55e3f1b 100644
--- a/tests/test_frame.py
+++ b/tests/test_frame.py
@@ -72,13 +72,13 @@ def test_types_init() -> None:
 
 def test_types_all() -> None:
     df = pd.DataFrame([[False, True], [False, False]], columns=["col1", "col2"])
-    check(assert_type(df.all(), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(df.all(), "pd.Series[bool]"), pd.Series, np.bool_)
     check(assert_type(df.all(axis=None), bool), np.bool_)
 
 
 def test_types_any() -> None:
     df = pd.DataFrame([[False, True], [False, False]], columns=["col1", "col2"])
-    check(assert_type(df.any(), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(df.any(), "pd.Series[bool]"), pd.Series, np.bool_)
     check(assert_type(df.any(axis=None), bool), np.bool_)
 
 
@@ -496,7 +496,7 @@ def gethead(s: pd.Series, y: int) -> pd.Series:
     check(assert_type(df.apply(gethead, args=(4,)), pd.DataFrame), pd.DataFrame)
 
     # Check various return types for default result_type (None) with default axis (0)
-    check(assert_type(df.apply(returns_scalar), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(df.apply(returns_scalar), "pd.Series[int]"), pd.Series, np.int64)
     check(assert_type(df.apply(returns_series), pd.DataFrame), pd.DataFrame)
     check(assert_type(df.apply(returns_listlike_of_3), pd.DataFrame), pd.DataFrame)
     check(assert_type(df.apply(returns_dict), pd.Series), pd.Series)
@@ -507,7 +507,7 @@ def gethead(s: pd.Series, y: int) -> pd.Series:
         # to pass a result_type of "expand" to a scalar return
         assert_type(df.apply(returns_scalar, result_type="expand"), "pd.Series[int]"),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         assert_type(df.apply(returns_series, result_type="expand"), pd.DataFrame),
@@ -530,7 +530,7 @@ def gethead(s: pd.Series, y: int) -> pd.Series:
         # to pass a result_type of "reduce" to a scalar return
         assert_type(df.apply(returns_scalar, result_type="reduce"), "pd.Series[int]"),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         # Note that technically it does not make sense
@@ -548,7 +548,9 @@ def gethead(s: pd.Series, y: int) -> pd.Series:
 
     # Check various return types for default result_type (None) with axis=1
     check(
-        assert_type(df.apply(returns_scalar, axis=1), "pd.Series[int]"), pd.Series, int
+        assert_type(df.apply(returns_scalar, axis=1), "pd.Series[int]"),
+        pd.Series,
+        np.int64,
     )
     check(assert_type(df.apply(returns_series, axis=1), pd.DataFrame), pd.DataFrame)
     check(assert_type(df.apply(returns_listlike_of_3, axis=1), pd.Series), pd.Series)
@@ -562,7 +564,7 @@ def gethead(s: pd.Series, y: int) -> pd.Series:
             df.apply(returns_scalar, axis=1, result_type="expand"), "pd.Series[int]"
         ),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         assert_type(
@@ -589,7 +591,7 @@ def gethead(s: pd.Series, y: int) -> pd.Series:
             df.apply(returns_scalar, axis=1, result_type="reduce"), "pd.Series[int]"
         ),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         # Note that technically it does not make sense
@@ -668,33 +670,35 @@ def gethead(s: pd.Series, y: int) -> pd.Series:
     # Test various other positional/keyword argument combinations
     # to ensure all overloads are supported
     check(
-        assert_type(df.apply(returns_scalar, axis=0), "pd.Series[int]"), pd.Series, int
+        assert_type(df.apply(returns_scalar, axis=0), "pd.Series[int]"),
+        pd.Series,
+        np.int64,
     )
     check(
         assert_type(
             df.apply(returns_scalar, axis=0, result_type=None), "pd.Series[int]"
         ),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         assert_type(df.apply(returns_scalar, 0, False, None), "pd.Series[int]"),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         assert_type(
             df.apply(returns_scalar, 0, False, result_type=None), "pd.Series[int]"
         ),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         assert_type(
             df.apply(returns_scalar, 0, raw=False, result_type=None), "pd.Series[int]"
         ),
         pd.Series,
-        int,
+        np.int64,
     )
 
 
@@ -863,7 +867,7 @@ def test_types_groupby_methods() -> None:
     check(
         assert_type(df.groupby("col1").value_counts(normalize=False), "pd.Series[int]"),
         pd.Series,
-        int,
+        np.int64,
     )
     check(
         assert_type(
@@ -948,12 +952,12 @@ def test_types_groupby_any() -> None:
     check(
         assert_type(df.groupby("col1")["col2"].any(), "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
     check(
         assert_type(df.groupby("col1")["col2"].any(), "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
 
 
@@ -2277,7 +2281,7 @@ def test_series_groupby_and_value_counts() -> None:
     )
     c1 = df.groupby("Animal")["Max Speed"].value_counts()
     c2 = df.groupby("Animal")["Max Speed"].value_counts(normalize=True)
-    check(assert_type(c1, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(c1, "pd.Series[int]"), pd.Series, np.int64)
     check(assert_type(c2, "pd.Series[float]"), pd.Series, float)
 
 
diff --git a/tests/test_indexes.py b/tests/test_indexes.py
index 5c2bb46f3..83265320b 100644
--- a/tests/test_indexes.py
+++ b/tests/test_indexes.py
@@ -87,7 +87,7 @@ def test_column_getitem() -> None:
 
     column = df.columns[0]
     check(assert_type(column, Scalar), str)
-    check(assert_type(df[column], pd.Series), pd.Series, int)
+    check(assert_type(df[column], pd.Series), pd.Series, np.int64)
 
 
 def test_column_contains() -> None:
@@ -843,7 +843,7 @@ def test_getitem() -> None:
     iri = pd.RangeIndex(0, 10)
     check(assert_type(iri, pd.RangeIndex), pd.RangeIndex, int)
     check(assert_type(iri[0], int), int)
-    check(assert_type(iri[[0, 2, 4]], pd.Index), pd.Index, int)
+    check(assert_type(iri[[0, 2, 4]], pd.Index), pd.Index, np.int64)
 
     mi = pd.MultiIndex.from_product([["a", "b"], ["c", "d"]], names=["ab", "cd"])
     check(assert_type(mi, pd.MultiIndex), pd.MultiIndex)
diff --git a/tests/test_io.py b/tests/test_io.py
index b6d82f9bc..5b3bb845b 100644
--- a/tests/test_io.py
+++ b/tests/test_io.py
@@ -66,10 +66,7 @@
 from pandas.io.sas.sas_xport import XportReader
 from pandas.io.stata import StataReader
 
-from . import (
-    lxml_skip,
-    pytables_skip,
-)
+from . import lxml_skip
 
 DF = DataFrame({"a": [1, 2, 3], "b": [0.0, 0.0, 0.0]})
 CWD = os.path.split(os.path.abspath(__file__))[0]
@@ -290,14 +287,12 @@ def test_sas_xport() -> None:
         pass
 
 
-@pytables_skip
 def test_hdf():
     with ensure_clean() as path:
         check(assert_type(DF.to_hdf(path, "df"), None), type(None))
         check(assert_type(read_hdf(path), Union[DataFrame, Series]), DataFrame)
 
 
-@pytables_skip
 def test_hdfstore():
     with ensure_clean() as path:
         store = HDFStore(path, model="w")
@@ -341,7 +336,6 @@ def test_hdfstore():
         store.close()
 
 
-@pytables_skip
 def test_read_hdf_iterator():
     with ensure_clean() as path:
         check(assert_type(DF.to_hdf(path, "df", format="table"), None), type(None))
@@ -356,7 +350,6 @@ def test_read_hdf_iterator():
         ti.close()
 
 
-@pytables_skip
 def test_hdf_context_manager():
     with ensure_clean() as path:
         check(assert_type(DF.to_hdf(path, "df", format="table"), None), type(None))
@@ -365,7 +358,6 @@ def test_hdf_context_manager():
             check(assert_type(store.get("df"), Union[DataFrame, Series]), DataFrame)
 
 
-@pytables_skip
 def test_hdf_series():
     s = DF["a"]
     with ensure_clean() as path:
diff --git a/tests/test_pandas.py b/tests/test_pandas.py
index b14465fcf..c787b5fec 100644
--- a/tests/test_pandas.py
+++ b/tests/test_pandas.py
@@ -240,10 +240,10 @@ def test_types_json_normalize() -> None:
 def test_isna() -> None:
     # https://github.com/pandas-dev/pandas-stubs/issues/264
     s1 = pd.Series([1, np.nan, 3.2])
-    check(assert_type(pd.isna(s1), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.isna(s1), "pd.Series[bool]"), pd.Series, np.bool_)
 
     s2 = pd.Series([1, 3.2])
-    check(assert_type(pd.notna(s2), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.notna(s2), "pd.Series[bool]"), pd.Series, np.bool_)
 
     df1 = pd.DataFrame({"a": [1, 2, 1, 2], "b": [1, 1, 2, np.nan]})
     check(assert_type(pd.isna(df1), "pd.DataFrame"), pd.DataFrame)
@@ -890,7 +890,7 @@ def test_cut() -> None:
     check(assert_type(s0r, pd.Series), pd.Series, pd.Interval)
     check(assert_type(s1r, pd.DatetimeIndex), pd.DatetimeIndex, pd.Timestamp)
     s0rlf, s1rlf = pd.cut(s1, bins=10, labels=False, retbins=True)
-    check(assert_type(s0rlf, pd.Series), pd.Series, int)
+    check(assert_type(s0rlf, pd.Series), pd.Series, np.int64)
     check(assert_type(s1rlf, pd.DatetimeIndex), pd.DatetimeIndex, pd.Timestamp)
     s0rls, s1rls = pd.cut(s1, bins=4, labels=["1", "2", "3", "4"], retbins=True)
     check(assert_type(s0rls, pd.Series), pd.Series, str)
diff --git a/tests/test_scalars.py b/tests/test_scalars.py
index ac2625f34..a064d5208 100644
--- a/tests/test_scalars.py
+++ b/tests/test_scalars.py
@@ -50,6 +50,11 @@
     PeriodSeries: TypeAlias = pd.Series
     OffsetSeries: TypeAlias = pd.Series
 
+if TYPE_CHECKING or PD_LTE_15:
+    _TimeDeltaDivResultType = np.int64
+else:
+    _TimeDeltaDivResultType = np.longlong
+
 
 def test_interval() -> None:
     interval_i = pd.Interval(0, 1, closed="left")
@@ -736,7 +741,11 @@ def test_timedelta_mul_div() -> None:
     check(assert_type(td // md_series_float, TimedeltaSeries), pd.Series, pd.Timedelta)
     check(assert_type(td // md_int64_index, pd.TimedeltaIndex), pd.TimedeltaIndex)
     check(assert_type(td // md_float_index, pd.TimedeltaIndex), pd.TimedeltaIndex)
-    check(assert_type(td // md_timedelta_series, "pd.Series[int]"), pd.Series, int)
+    check(
+        assert_type(td // md_timedelta_series, "pd.Series[int]"),
+        pd.Series,
+        _TimeDeltaDivResultType,
+    )
 
     check(assert_type(pd.NaT // td, float), float)
     # Note: None of the reverse floordiv work
@@ -880,10 +889,10 @@ def test_timedelta_cmp() -> None:
     assert (gt_a != le_a).all()
 
     gt_s = check(
-        assert_type(td > c_timedelta_series, "pd.Series[bool]"), pd.Series, bool
+        assert_type(td > c_timedelta_series, "pd.Series[bool]"), pd.Series, np.bool_
     )
     le_s = check(
-        assert_type(td <= c_timedelta_series, "pd.Series[bool]"), pd.Series, bool
+        assert_type(td <= c_timedelta_series, "pd.Series[bool]"), pd.Series, np.bool_
     )
     assert (gt_s != le_s).all()
 
@@ -912,10 +921,10 @@ def test_timedelta_cmp() -> None:
     assert (gt_a != le_a).all()
 
     eq_s = check(
-        assert_type(c_timedelta_series > td, "pd.Series[bool]"), pd.Series, bool
+        assert_type(c_timedelta_series > td, "pd.Series[bool]"), pd.Series, np.bool_
     )
     ne_s = check(
-        assert_type(c_timedelta_series <= td, "pd.Series[bool]"), pd.Series, bool
+        assert_type(c_timedelta_series <= td, "pd.Series[bool]"), pd.Series, np.bool_
     )
     assert (eq_s != ne_s).all()
 
@@ -948,10 +957,10 @@ def test_timedelta_cmp() -> None:
     assert (lt_a != ge_a).all()
 
     eq_s = check(
-        assert_type(td < c_timedelta_series, "pd.Series[bool]"), pd.Series, bool
+        assert_type(td < c_timedelta_series, "pd.Series[bool]"), pd.Series, np.bool_
     )
     ne_s = check(
-        assert_type(td >= c_timedelta_series, "pd.Series[bool]"), pd.Series, bool
+        assert_type(td >= c_timedelta_series, "pd.Series[bool]"), pd.Series, np.bool_
     )
     assert (eq_s != ne_s).all()
 
@@ -980,10 +989,10 @@ def test_timedelta_cmp() -> None:
     assert (lt_a != ge_a).all()
 
     eq_s = check(
-        assert_type(c_timedelta_series < td, "pd.Series[bool]"), pd.Series, bool
+        assert_type(c_timedelta_series < td, "pd.Series[bool]"), pd.Series, np.bool_
     )
     ne_s = check(
-        assert_type(c_timedelta_series >= td, "pd.Series[bool]"), pd.Series, bool
+        assert_type(c_timedelta_series >= td, "pd.Series[bool]"), pd.Series, np.bool_
     )
     assert (eq_s != ne_s).all()
 
@@ -1016,10 +1025,10 @@ def test_timedelta_cmp() -> None:
     assert (eq_a != ne_a).all()
 
     eq_s = check(
-        assert_type(td == c_timedelta_series, "pd.Series[bool]"), pd.Series, bool
+        assert_type(td == c_timedelta_series, "pd.Series[bool]"), pd.Series, np.bool_
     )
     ne_s = check(
-        assert_type(td != c_timedelta_series, "pd.Series[bool]"), pd.Series, bool
+        assert_type(td != c_timedelta_series, "pd.Series[bool]"), pd.Series, np.bool_
     )
     assert (eq_s != ne_s).all()
 
@@ -1066,10 +1075,10 @@ def test_timedelta_cmp_rhs() -> None:
     assert (eq_a != ne_a).all()
 
     eq_s = check(
-        assert_type(c_timedelta_series == td, "pd.Series[bool]"), pd.Series, bool
+        assert_type(c_timedelta_series == td, "pd.Series[bool]"), pd.Series, np.bool_
     )
     ne_s = check(
-        assert_type(c_timedelta_series != td, "pd.Series[bool]"), pd.Series, bool
+        assert_type(c_timedelta_series != td, "pd.Series[bool]"), pd.Series, np.bool_
     )
     assert (eq_s != ne_s).all()
 
@@ -1275,11 +1284,11 @@ def test_timestamp_cmp() -> None:
     check(assert_type(ts > c_np_ndarray_dt64, np_ndarray_bool), np.ndarray, np.bool_)
     check(assert_type(ts <= c_np_ndarray_dt64, np_ndarray_bool), np.ndarray, np.bool_)
 
-    check(assert_type(ts > c_series_timestamp, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts <= c_series_timestamp, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(ts > c_series_timestamp, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts <= c_series_timestamp, "pd.Series[bool]"), pd.Series, np.bool_)
 
-    check(assert_type(ts > c_series_dt64, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts <= c_series_dt64, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(ts > c_series_dt64, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts <= c_series_dt64, "pd.Series[bool]"), pd.Series, np.bool_)
 
     check(assert_type(c_np_dt64 > ts, Any), np.bool_)
     check(assert_type(c_np_dt64 <= ts, Any), np.bool_)
@@ -1294,8 +1303,8 @@ def test_timestamp_cmp() -> None:
     check(assert_type(c_np_ndarray_dt64 > ts, np_ndarray_bool), np.ndarray, np.bool_)
     check(assert_type(c_np_ndarray_dt64 <= ts, np_ndarray_bool), np.ndarray, np.bool_)
 
-    check(assert_type(c_series_dt64 > ts, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(c_series_dt64 <= ts, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(c_series_dt64 > ts, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(c_series_dt64 <= ts, "pd.Series[bool]"), pd.Series, np.bool_)
 
     gte = check(assert_type(ts >= c_timestamp, bool), bool)
     lt = check(assert_type(ts < c_timestamp, bool), bool)
@@ -1315,11 +1324,11 @@ def test_timestamp_cmp() -> None:
     check(assert_type(ts >= c_np_ndarray_dt64, np_ndarray_bool), np.ndarray, np.bool_)
     check(assert_type(ts < c_np_ndarray_dt64, np_ndarray_bool), np.ndarray, np.bool_)
 
-    check(assert_type(ts >= c_series_timestamp, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts < c_series_timestamp, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(ts >= c_series_timestamp, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts < c_series_timestamp, "pd.Series[bool]"), pd.Series, np.bool_)
 
-    check(assert_type(ts >= c_series_dt64, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts < c_series_dt64, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(ts >= c_series_dt64, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts < c_series_dt64, "pd.Series[bool]"), pd.Series, np.bool_)
 
     gte = check(assert_type(c_dt_datetime >= ts, bool), bool)
     lt = check(assert_type(c_dt_datetime < ts, bool), bool)
@@ -1334,8 +1343,8 @@ def test_timestamp_cmp() -> None:
     check(assert_type(c_np_ndarray_dt64 >= ts, np_ndarray_bool), np.ndarray, np.bool_)
     check(assert_type(c_np_ndarray_dt64 < ts, np_ndarray_bool), np.ndarray, np.bool_)
 
-    check(assert_type(c_series_dt64 >= ts, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(c_series_dt64 < ts, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(c_series_dt64 >= ts, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(c_series_dt64 < ts, "pd.Series[bool]"), pd.Series, np.bool_)
 
     eq = check(assert_type(ts == c_timestamp, bool), bool)
     ne = check(assert_type(ts != c_timestamp, bool), bool)
@@ -1366,15 +1375,19 @@ def test_timestamp_cmp() -> None:
     assert (eq_arr != ne_arr).all()
 
     eq_s = check(
-        assert_type(ts == c_series_timestamp, "pd.Series[bool]"), pd.Series, bool
+        assert_type(ts == c_series_timestamp, "pd.Series[bool]"), pd.Series, np.bool_
     )
     ne_s = check(
-        assert_type(ts != c_series_timestamp, "pd.Series[bool]"), pd.Series, bool
+        assert_type(ts != c_series_timestamp, "pd.Series[bool]"), pd.Series, np.bool_
     )
     assert (eq_s != ne_s).all()
 
-    eq_s = check(assert_type(ts == c_series_dt64, "pd.Series[bool]"), pd.Series, bool)
-    ne_s = check(assert_type(ts != c_series_dt64, "pd.Series[bool]"), pd.Series, bool)
+    eq_s = check(
+        assert_type(ts == c_series_dt64, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    ne_s = check(
+        assert_type(ts != c_series_dt64, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (eq_s != ne_s).all()
 
 
@@ -1415,8 +1428,12 @@ def test_timestamp_eq_ne_rhs() -> None:
     ne_a = check(assert_type(c_np_ndarray_dt64 == ts, Any), np.ndarray, np.bool_)
     assert (eq_a != ne_a).all()
 
-    eq_s = check(assert_type(c_series_dt64 == ts, "pd.Series[bool]"), pd.Series, bool)
-    ne_s = check(assert_type(c_series_dt64 != ts, "pd.Series[bool]"), pd.Series, bool)
+    eq_s = check(
+        assert_type(c_series_dt64 == ts, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    ne_s = check(
+        assert_type(c_series_dt64 != ts, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (eq_s != ne_s).all()
 
 
@@ -1621,18 +1638,18 @@ def test_types_timestamp_series_comparisons() -> None:
     tssr = tss <= ts
     tssr2 = tss >= ts
     tssr3 = tss == ts
-    check(assert_type(tssr, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(tssr2, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(tssr3, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(tssr, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(tssr2, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(tssr3, "pd.Series[bool]"), pd.Series, np.bool_)
     # GH 265
     data = pd.date_range("2022-01-01", "2022-01-31", freq="D")
     s = pd.Series(data)
     ts2 = pd.Timestamp("2022-01-15")
     check(assert_type(s, TimestampSeries), pd.Series, pd.Timestamp)
-    check(assert_type(ts2 <= s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts2 >= s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts2 < s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts2 > s, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(ts2 <= s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts2 >= s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts2 < s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts2 > s, "pd.Series[bool]"), pd.Series, np.bool_)
 
 
 def test_timestamp_types_pydatetime() -> None:
@@ -1827,8 +1844,12 @@ def test_period_cmp() -> None:
     )
     assert (eq_a != ne_q).all()
 
-    eq_s = check(assert_type(p == c_period_series, "pd.Series[bool]"), pd.Series, bool)
-    ne_s = check(assert_type(p != c_period_series, "pd.Series[bool]"), pd.Series, bool)
+    eq_s = check(
+        assert_type(p == c_period_series, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    ne_s = check(
+        assert_type(p != c_period_series, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (eq_s != ne_s).all()
 
     eq = check(assert_type(c_period == p, bool), bool)
@@ -1843,8 +1864,12 @@ def test_period_cmp() -> None:
     )
     assert (eq_a != ne_a).all()
 
-    eq_s = check(assert_type(c_period_series == p, "pd.Series[bool]"), pd.Series, bool)
-    ne_s = check(assert_type(c_period_series != p, "pd.Series[bool]"), pd.Series, bool)
+    eq_s = check(
+        assert_type(c_period_series == p, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    ne_s = check(
+        assert_type(c_period_series != p, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (eq_s != ne_s).all()
 
     gt = check(assert_type(p > c_period, bool), bool)
@@ -1857,8 +1882,12 @@ def test_period_cmp() -> None:
     )
     assert (gt_a != le_a).all()
 
-    gt_s = check(assert_type(p > c_period_series, "pd.Series[bool]"), pd.Series, bool)
-    le_s = check(assert_type(p <= c_period_series, "pd.Series[bool]"), pd.Series, bool)
+    gt_s = check(
+        assert_type(p > c_period_series, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    le_s = check(
+        assert_type(p <= c_period_series, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (gt_s != le_s).all()
 
     gt = check(assert_type(c_period > p, bool), bool)
@@ -1871,8 +1900,12 @@ def test_period_cmp() -> None:
     )
     assert (gt_a != le_a).all()
 
-    gt_s = check(assert_type(c_period_series > p, "pd.Series[bool]"), pd.Series, bool)
-    le_s = check(assert_type(c_period_series <= p, "pd.Series[bool]"), pd.Series, bool)
+    gt_s = check(
+        assert_type(c_period_series > p, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    le_s = check(
+        assert_type(c_period_series <= p, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (gt_s != le_s).all()
 
     lt = check(assert_type(p < c_period, bool), bool)
@@ -1885,8 +1918,12 @@ def test_period_cmp() -> None:
     )
     assert (lt_a != ge_a).all()
 
-    lt_s = check(assert_type(p < c_period_series, "pd.Series[bool]"), pd.Series, bool)
-    ge_s = check(assert_type(p >= c_period_series, "pd.Series[bool]"), pd.Series, bool)
+    lt_s = check(
+        assert_type(p < c_period_series, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    ge_s = check(
+        assert_type(p >= c_period_series, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (lt_s != ge_s).all()
 
     lt = check(assert_type(c_period < p, bool), bool)
@@ -1899,8 +1936,12 @@ def test_period_cmp() -> None:
     )
     assert (lt_a != ge_a).all()
 
-    lt_s = check(assert_type(c_period_series < p, "pd.Series[bool]"), pd.Series, bool)
-    ge_s = check(assert_type(c_period_series >= p, "pd.Series[bool]"), pd.Series, bool)
+    lt_s = check(
+        assert_type(c_period_series < p, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    ge_s = check(
+        assert_type(c_period_series >= p, "pd.Series[bool]"), pd.Series, np.bool_
+    )
     assert (lt_s != ge_s).all()
 
 
diff --git a/tests/test_series.py b/tests/test_series.py
index abc14c62a..05fe07776 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -96,7 +96,7 @@ def test_types_csv() -> None:
 
 def test_types_copy() -> None:
     s = pd.Series(data=[1, 2, 3, 4])
-    check(assert_type(s.copy(), pd.Series), pd.Series, int)
+    check(assert_type(s.copy(), pd.Series), pd.Series, np.int64)
 
 
 def test_types_select() -> None:
@@ -127,8 +127,8 @@ def test_multiindex_loc() -> None:
     s = pd.Series(
         [1, 2, 3, 4], index=pd.MultiIndex.from_product([[1, 2], ["a", "b"]]), dtype=int
     )
-    check(assert_type(s.loc[1, :], "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s.loc[pd.Index([1]), :], "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.loc[1, :], "pd.Series[int]"), pd.Series, np.int_)
+    check(assert_type(s.loc[pd.Index([1]), :], "pd.Series[int]"), pd.Series, np.int_)
     check(assert_type(s.loc[1, "a"], int), np.int_)
 
 
@@ -386,7 +386,7 @@ def test_types_idxmax() -> None:
 
 def test_types_value_counts() -> None:
     s = pd.Series(["a", "b"])
-    check(assert_type(s.value_counts(), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.value_counts(), "pd.Series[int]"), pd.Series, np.int64)
 
 
 def test_types_unique() -> None:
@@ -425,7 +425,7 @@ def get_depth(url: str) -> int:
         return len(url)
 
     ss = s.astype(str)
-    check(assert_type(ss.apply(get_depth), pd.Series), pd.Series, int)
+    check(assert_type(ss.apply(get_depth), pd.Series), pd.Series, np.int64)
 
 
 def test_types_element_wise_arithmetic() -> None:
@@ -512,12 +512,12 @@ def test_types_groupby() -> None:
 
 def test_types_groupby_methods() -> None:
     s = pd.Series([4, 2, 1, 8], index=["a", "b", "a", "b"], dtype=int)
-    check(assert_type(s.groupby(level=0).sum(), "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s.groupby(level=0).prod(), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.groupby(level=0).sum(), "pd.Series[int]"), pd.Series, np.int_)
+    check(assert_type(s.groupby(level=0).prod(), "pd.Series[int]"), pd.Series, np.int_)
     check(assert_type(s.groupby(level=0).sem(), "pd.Series[float]"), pd.Series, float)
     check(assert_type(s.groupby(level=0).std(), "pd.Series[float]"), pd.Series, float)
     check(assert_type(s.groupby(level=0).var(), "pd.Series[float]"), pd.Series, float)
-    check(assert_type(s.groupby(level=0).tail(), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.groupby(level=0).tail(), "pd.Series[int]"), pd.Series, np.int_)
     check(assert_type(s.groupby(level=0).unique(), pd.Series), pd.Series)
 
 
@@ -626,13 +626,13 @@ def test_types_between() -> None:
     s1 = pd.Series([1, 2, 3])
     s2 = pd.Series([0, 1, 2])
     s3 = pd.Series([2, 3, 4])
-    check(assert_type(s1.between(0, 2), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(s1.between(0, 2), "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type(s1.between([0, 1, 2], [2, 3, 4]), "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
-    check(assert_type(s1.between(s2, s3), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(s1.between(s2, s3), "pd.Series[bool]"), pd.Series, np.bool_)
 
 
 def test_types_agg() -> None:
@@ -851,7 +851,7 @@ def test_series_index_isin() -> None:
 def test_series_invert() -> None:
     s1 = pd.Series([True, False, True])
     s2 = ~s1
-    check(assert_type(s2, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(s2, "pd.Series[bool]"), pd.Series, np.bool_)
     s3 = pd.Series([1, 2, 3])
     check(assert_type(s3[s2], pd.Series), pd.Series)
     check(assert_type(s3.loc[s2], pd.Series), pd.Series)
@@ -918,21 +918,29 @@ def test_types_replace() -> None:
 def test_cat_accessor() -> None:
     # GH 43
     s = pd.Series(pd.Categorical(["a", "b", "a"], categories=["a", "b"]))
-    check(assert_type(s.cat.codes, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.cat.codes, "pd.Series[int]"), pd.Series, np.int8)
     # GH 139
     ser = pd.Series([1, 2, 3], name="A").astype("category")
-    check(assert_type(ser.cat.set_categories([1, 2, 3]), pd.Series), pd.Series, int)
+    check(
+        assert_type(ser.cat.set_categories([1, 2, 3]), pd.Series), pd.Series, np.int64
+    )
     check(
         assert_type(ser.cat.reorder_categories([2, 3, 1], ordered=True), pd.Series),
         pd.Series,
-        int,
+        np.int64,
+    )
+    check(
+        assert_type(ser.cat.rename_categories([1, 2, 3]), pd.Series),
+        pd.Series,
+        np.int64,
     )
-    check(assert_type(ser.cat.rename_categories([1, 2, 3]), pd.Series), pd.Series, int)
-    check(assert_type(ser.cat.remove_unused_categories(), pd.Series), pd.Series, int)
-    check(assert_type(ser.cat.remove_categories([2]), pd.Series), pd.Series, int)
-    check(assert_type(ser.cat.add_categories([4]), pd.Series), pd.Series, int)
-    check(assert_type(ser.cat.as_ordered(), pd.Series), pd.Series, int)
-    check(assert_type(ser.cat.as_unordered(), pd.Series), pd.Series, int)
+    check(
+        assert_type(ser.cat.remove_unused_categories(), pd.Series), pd.Series, np.int64
+    )
+    check(assert_type(ser.cat.remove_categories([2]), pd.Series), pd.Series, np.int64)
+    check(assert_type(ser.cat.add_categories([4]), pd.Series), pd.Series, np.int64)
+    check(assert_type(ser.cat.as_ordered(), pd.Series), pd.Series, np.int64)
+    check(assert_type(ser.cat.as_unordered(), pd.Series), pd.Series, np.int64)
 
 
 def test_cat_ctor_values() -> None:
@@ -950,7 +958,7 @@ def test_iloc_getitem_ndarray() -> None:
     # GH 86
     indices_i8 = np.array([0, 1, 2, 3], dtype=np.int8)
     indices_i16 = np.array([0, 1, 2, 3], dtype=np.int16)
-    indices_i32 = np.array([0, 1, 2, 3], dtype=np.int32)
+    indices_i32 = np.array([0, 1, 2, 3], dtype=np.int_)
     indices_i64 = np.array([0, 1, 2, 3], dtype=np.int64)
 
     indices_u8 = np.array([0, 1, 2, 3], dtype=np.uint8)
@@ -976,7 +984,7 @@ def test_iloc_setitem_ndarray() -> None:
     # GH 86
     indices_i8 = np.array([0, 1, 2, 3], dtype=np.int8)
     indices_i16 = np.array([0, 1, 2, 3], dtype=np.int16)
-    indices_i32 = np.array([0, 1, 2, 3], dtype=np.int32)
+    indices_i32 = np.array([0, 1, 2, 3], dtype=np.int_)
     indices_i64 = np.array([0, 1, 2, 3], dtype=np.int64)
 
     indices_u8 = np.array([0, 1, 2, 3], dtype=np.uint8)
@@ -1031,31 +1039,33 @@ def test_string_accessors():
     check(assert_type(s.str.casefold(), pd.Series), pd.Series)
     check(assert_type(s.str.cat(sep="X"), str), str)
     check(assert_type(s.str.center(10), pd.Series), pd.Series)
-    check(assert_type(s.str.contains("a"), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.count("pp"), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.str.contains("a"), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.count("pp"), "pd.Series[int]"), pd.Series, np.int64)
     check(assert_type(s.str.decode("utf-8"), pd.Series), pd.Series)
     check(assert_type(s.str.encode("latin-1"), pd.Series), pd.Series)
-    check(assert_type(s.str.endswith("e"), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.endswith(("e", "f")), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(s.str.endswith("e"), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(
+        assert_type(s.str.endswith(("e", "f")), "pd.Series[bool]"), pd.Series, np.bool_
+    )
     check(assert_type(s3.str.extract(r"([ab])?(\d)"), pd.DataFrame), pd.DataFrame)
     check(assert_type(s3.str.extractall(r"([ab])?(\d)"), pd.DataFrame), pd.DataFrame)
     check(assert_type(s.str.find("p"), pd.Series), pd.Series)
     check(assert_type(s.str.findall("pp"), pd.Series), pd.Series)
-    check(assert_type(s.str.fullmatch("apple"), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(s.str.fullmatch("apple"), "pd.Series[bool]"), pd.Series, np.bool_)
     check(assert_type(s.str.get(2), pd.Series), pd.Series)
     check(assert_type(s.str.get_dummies(), pd.DataFrame), pd.DataFrame)
     check(assert_type(s.str.index("p"), pd.Series), pd.Series)
-    check(assert_type(s.str.isalnum(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.isalpha(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.isdecimal(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.isdigit(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.isnumeric(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.islower(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.isspace(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.istitle(), "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s.str.isupper(), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(s.str.isalnum(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.isalpha(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.isdecimal(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.isdigit(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.isnumeric(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.islower(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.isspace(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.istitle(), "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s.str.isupper(), "pd.Series[bool]"), pd.Series, np.bool_)
     check(assert_type(s2.str.join("-"), pd.Series), pd.Series)
-    check(assert_type(s.str.len(), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.str.len(), "pd.Series[int]"), pd.Series, np.int64)
     check(assert_type(s.str.ljust(80), pd.Series), pd.Series)
     check(assert_type(s.str.lower(), pd.Series), pd.Series)
     check(assert_type(s.str.lstrip("a"), pd.Series), pd.Series)
@@ -1079,11 +1089,11 @@ def test_string_accessors():
     check(assert_type(s.str.split("a"), pd.Series), pd.Series)
     # GH 194
     check(assert_type(s.str.split("a", expand=True), pd.DataFrame), pd.DataFrame)
-    check(assert_type(s.str.startswith("a"), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(s.str.startswith("a"), "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type(s.str.startswith(("a", "b")), "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
     check(assert_type(s.str.strip(), pd.Series), pd.Series)
     check(assert_type(s.str.swapcase(), pd.Series), pd.Series)
@@ -1149,70 +1159,78 @@ def test_series_overloads_extract():
 def test_relops() -> None:
     # GH 175
     s: str = "abc"
-    check(assert_type(pd.Series([s]) > s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([s]) < s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([s]) <= s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([s]) >= s, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([s]) > s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([s]) < s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([s]) <= s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([s]) >= s, "pd.Series[bool]"), pd.Series, np.bool_)
 
     b: bytes = b"def"
-    check(assert_type(pd.Series([b]) > b, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([b]) < b, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([b]) <= b, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([b]) >= b, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([b]) > b, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([b]) < b, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([b]) <= b, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([b]) >= b, "pd.Series[bool]"), pd.Series, np.bool_)
 
     dtd = datetime.date(2022, 7, 31)
-    check(assert_type(pd.Series([dtd]) > dtd, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dtd]) < dtd, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dtd]) <= dtd, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dtd]) >= dtd, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([dtd]) > dtd, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([dtd]) < dtd, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([dtd]) <= dtd, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([dtd]) >= dtd, "pd.Series[bool]"), pd.Series, np.bool_)
 
     dtdt = datetime.datetime(2022, 7, 31, 8, 32, 21)
-    check(assert_type(pd.Series([dtdt]) > dtdt, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dtdt]) < dtdt, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dtdt]) <= dtdt, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dtdt]) >= dtdt, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([dtdt]) > dtdt, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([dtdt]) < dtdt, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(
+        assert_type(pd.Series([dtdt]) <= dtdt, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    check(
+        assert_type(pd.Series([dtdt]) >= dtdt, "pd.Series[bool]"), pd.Series, np.bool_
+    )
 
     dttd = datetime.timedelta(seconds=10)
-    check(assert_type(pd.Series([dttd]) > dttd, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dttd]) < dttd, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dttd]) <= dttd, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([dttd]) >= dttd, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([dttd]) > dttd, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([dttd]) < dttd, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(
+        assert_type(pd.Series([dttd]) <= dttd, "pd.Series[bool]"), pd.Series, np.bool_
+    )
+    check(
+        assert_type(pd.Series([dttd]) >= dttd, "pd.Series[bool]"), pd.Series, np.bool_
+    )
 
     bo: bool = True
-    check(assert_type(pd.Series([bo]) > bo, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([bo]) < bo, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([bo]) <= bo, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([bo]) >= bo, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([bo]) > bo, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([bo]) < bo, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([bo]) <= bo, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([bo]) >= bo, "pd.Series[bool]"), pd.Series, np.bool_)
 
     ai: int = 10
-    check(assert_type(pd.Series([ai]) > ai, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ai]) < ai, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ai]) <= ai, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ai]) >= ai, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([ai]) > ai, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ai]) < ai, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ai]) <= ai, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ai]) >= ai, "pd.Series[bool]"), pd.Series, np.bool_)
 
     af: float = 3.14
-    check(assert_type(pd.Series([af]) > af, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([af]) < af, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([af]) <= af, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([af]) >= af, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([af]) > af, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([af]) < af, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([af]) <= af, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([af]) >= af, "pd.Series[bool]"), pd.Series, np.bool_)
 
     ac: complex = 1 + 2j
-    check(assert_type(pd.Series([ac]) > ac, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ac]) < ac, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ac]) <= ac, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ac]) >= ac, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([ac]) > ac, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ac]) < ac, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ac]) <= ac, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ac]) >= ac, "pd.Series[bool]"), pd.Series, np.bool_)
 
     ts = pd.Timestamp("2022-07-31 08:35:12")
-    check(assert_type(pd.Series([ts]) > ts, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ts]) < ts, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ts]) <= ts, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([ts]) >= ts, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([ts]) > ts, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ts]) < ts, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ts]) <= ts, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([ts]) >= ts, "pd.Series[bool]"), pd.Series, np.bool_)
 
     td = pd.Timedelta(seconds=10)
-    check(assert_type(pd.Series([td]) > td, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([td]) < td, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([td]) <= td, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(pd.Series([td]) >= td, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(pd.Series([td]) > td, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([td]) < td, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([td]) <= td, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(pd.Series([td]) >= td, "pd.Series[bool]"), pd.Series, np.bool_)
 
 
 def test_resample() -> None:
@@ -1246,7 +1264,7 @@ def test_neg() -> None:
     sr = pd.Series([1, 2, 3])
     sr_int = pd.Series([1, 2, 3], dtype=int)
     check(assert_type(-sr, pd.Series), pd.Series)
-    check(assert_type(-sr_int, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(-sr_int, "pd.Series[int]"), pd.Series, np.int_)
 
 
 def test_getattr() -> None:
@@ -1283,93 +1301,100 @@ def test_where() -> None:
     def cond1(x: int) -> bool:
         return x % 2 == 0
 
-    check(assert_type(s.where(cond1, other=0), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.where(cond1, other=0), "pd.Series[int]"), pd.Series, np.int_)
 
     def cond2(x: pd.Series[int]) -> pd.Series[bool]:
         return x > 1
 
-    check(assert_type(s.where(cond2, other=0), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.where(cond2, other=0), "pd.Series[int]"), pd.Series, np.int_)
 
     cond3 = pd.Series([False, True, True])
-    check(assert_type(s.where(cond3, other=0), "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s.where(cond3, other=0), "pd.Series[int]"), pd.Series, np.int_)
 
 
 def test_bitwise_operators() -> None:
     s = pd.Series([1, 2, 3, 4], dtype=int)
     s2 = pd.Series([9, 10, 11, 12], dtype=int)
     # for issue #348 (bitwise operators on Series should support int)
-    check(assert_type(s & 3, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(3 & s, "pd.Series[int]"), pd.Series, int)
+    # The bitwise integers return platform-dependent numpy integers in the Series
+    check(assert_type(s & 3, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(3 & s, "pd.Series[int]"), pd.Series, np.integer)
 
-    check(assert_type(s | 3, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(3 | s, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s | 3, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(3 | s, "pd.Series[int]"), pd.Series, np.integer)
 
-    check(assert_type(s ^ 3, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(3 ^ s, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s ^ 3, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(3 ^ s, "pd.Series[int]"), pd.Series, np.integer)
 
-    check(assert_type(s & [1, 2, 3, 4], "pd.Series[int]"), pd.Series, int)
-    check(assert_type([1, 2, 3, 4] & s, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s & s2, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s2 & s, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s & [1, 2, 3, 4], "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type([1, 2, 3, 4] & s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s & s2, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s2 & s, "pd.Series[int]"), pd.Series, np.integer)
 
-    check(assert_type(s | [1, 2, 3, 4], "pd.Series[int]"), pd.Series, int)
-    check(assert_type([1, 2, 3, 4] | s, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s | s2, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s2 | s, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s | [1, 2, 3, 4], "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type([1, 2, 3, 4] | s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s | s2, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s2 | s, "pd.Series[int]"), pd.Series, np.integer)
 
-    check(assert_type(s ^ [1, 2, 3, 4], "pd.Series[int]"), pd.Series, int)
-    check(assert_type([1, 2, 3, 4] ^ s, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s ^ s2, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s2 ^ s, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s ^ [1, 2, 3, 4], "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type([1, 2, 3, 4] ^ s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s ^ s2, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s2 ^ s, "pd.Series[int]"), pd.Series, np.integer)
 
 
 def test_logical_operators() -> None:
     # GH 380
     df = pd.DataFrame({"a": [1, 2, 3], "b": [2, 3, 4]})
     check(
-        assert_type((df["a"] >= 2) & (df["b"] >= 2), "pd.Series[bool]"), pd.Series, bool
+        assert_type((df["a"] >= 2) & (df["b"] >= 2), "pd.Series[bool]"),
+        pd.Series,
+        np.bool_,
     )
     check(
-        assert_type((df["a"] >= 2) | (df["b"] >= 2), "pd.Series[bool]"), pd.Series, bool
+        assert_type((df["a"] >= 2) | (df["b"] >= 2), "pd.Series[bool]"),
+        pd.Series,
+        np.bool_,
     )
     check(
-        assert_type((df["a"] >= 2) ^ (df["b"] >= 2), "pd.Series[bool]"), pd.Series, bool
+        assert_type((df["a"] >= 2) ^ (df["b"] >= 2), "pd.Series[bool]"),
+        pd.Series,
+        np.bool_,
     )
-    check(assert_type((df["a"] >= 2) & True, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type((df["a"] >= 2) & True, "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type((df["a"] >= 2) & [True, False, True], "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
-    check(assert_type((df["a"] >= 2) | True, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type((df["a"] >= 2) | True, "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type((df["a"] >= 2) | [True, False, True], "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
-    check(assert_type((df["a"] >= 2) ^ True, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type((df["a"] >= 2) ^ True, "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type((df["a"] >= 2) ^ [True, False, True], "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
-    check(assert_type(True & (df["a"] >= 2), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(True & (df["a"] >= 2), "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type([True, False, True] & (df["a"] >= 2), "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
-    check(assert_type(True | (df["a"] >= 2), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(True | (df["a"] >= 2), "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type([True, False, True] | (df["a"] >= 2), "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
-    check(assert_type(True ^ (df["a"] >= 2), "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(True ^ (df["a"] >= 2), "pd.Series[bool]"), pd.Series, np.bool_)
     check(
         assert_type([True, False, True] ^ (df["a"] >= 2), "pd.Series[bool]"),
         pd.Series,
-        bool,
+        np.bool_,
     )
 
 
diff --git a/tests/test_timefuncs.py b/tests/test_timefuncs.py
index 8ed724666..ab7fc0d9f 100644
--- a/tests/test_timefuncs.py
+++ b/tests/test_timefuncs.py
@@ -104,18 +104,18 @@ def test_types_timestamp_series_comparisons() -> None:
     tssr = tss <= ts
     tssr2 = tss >= ts
     tssr3 = tss == ts
-    check(assert_type(tssr, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(tssr2, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(tssr3, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(tssr, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(tssr2, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(tssr3, "pd.Series[bool]"), pd.Series, np.bool_)
     # GH 265
     data = pd.date_range("2022-01-01", "2022-01-31", freq="D")
     s = pd.Series(data)
     ts2 = pd.Timestamp("2022-01-15")
     check(assert_type(s, "TimestampSeries"), pd.Series, pd.Timestamp)
-    check(assert_type(ts2 <= s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts2 >= s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts2 < s, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(ts2 > s, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(ts2 <= s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts2 >= s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts2 < s, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(ts2 > s, "pd.Series[bool]"), pd.Series, np.bool_)
 
 
 def test_types_pydatetime() -> None:
@@ -163,7 +163,7 @@ def test_timestamp_timedelta_series_arithmetic() -> None:
     r4 = pd.Timedelta(5, "days") / r1
     check(assert_type(r4, "pd.Series[float]"), pd.Series, float)
     sb = pd.Series([1, 2]) == pd.Series([1, 3])
-    check(assert_type(sb, "pd.Series[bool]"), pd.Series, bool)
+    check(assert_type(sb, "pd.Series[bool]"), pd.Series, np.bool_)
     r5 = sb * r1
     check(assert_type(r5, "TimedeltaSeries"), pd.Series, pd.Timedelta)
     r6 = r1 * 4
@@ -343,29 +343,29 @@ def test_series_dt_accessors() -> None:
     check(assert_type(s0.dt.date, "pd.Series[dt.date]"), pd.Series, dt.date)
     check(assert_type(s0.dt.time, "pd.Series[dt.time]"), pd.Series, dt.time)
     check(assert_type(s0.dt.timetz, "pd.Series[dt.time]"), pd.Series, dt.time)
-    check(assert_type(s0.dt.year, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.month, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.day, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.hour, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.minute, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.second, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.microsecond, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.nanosecond, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.dayofweek, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.day_of_week, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.weekday, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.dayofyear, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.day_of_year, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.quarter, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.is_month_start, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s0.dt.is_month_end, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s0.dt.is_quarter_start, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s0.dt.is_quarter_end, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s0.dt.is_year_start, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s0.dt.is_year_end, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s0.dt.is_leap_year, "pd.Series[bool]"), pd.Series, bool)
-    check(assert_type(s0.dt.daysinmonth, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s0.dt.days_in_month, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s0.dt.year, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.month, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.day, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.hour, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.minute, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.second, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.microsecond, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.nanosecond, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.dayofweek, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.day_of_week, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.weekday, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.dayofyear, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.day_of_year, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.quarter, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.is_month_start, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s0.dt.is_month_end, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s0.dt.is_quarter_start, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s0.dt.is_quarter_end, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s0.dt.is_year_start, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s0.dt.is_year_end, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s0.dt.is_leap_year, "pd.Series[bool]"), pd.Series, np.bool_)
+    check(assert_type(s0.dt.daysinmonth, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s0.dt.days_in_month, "pd.Series[int]"), pd.Series, np.integer)
     assert assert_type(s0.dt.tz, Optional[dt.tzinfo]) is None
     check(assert_type(s0.dt.freq, Optional[str]), str)
     check(assert_type(s0.dt.isocalendar(), pd.DataFrame), pd.DataFrame)
@@ -430,7 +430,7 @@ def test_series_dt_accessors() -> None:
 
     s1 = pd.Series(i1)
 
-    check(assert_type(s1.dt.qyear, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s1.dt.qyear, "pd.Series[int]"), pd.Series, np.integer)
     check(assert_type(s1.dt.start_time, "TimestampSeries"), pd.Series, pd.Timestamp)
     check(assert_type(s1.dt.end_time, "TimestampSeries"), pd.Series, pd.Timestamp)
 
@@ -441,10 +441,10 @@ def test_series_dt_accessors() -> None:
 
     s2 = pd.Series(i2)
 
-    check(assert_type(s2.dt.days, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s2.dt.seconds, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s2.dt.microseconds, "pd.Series[int]"), pd.Series, int)
-    check(assert_type(s2.dt.nanoseconds, "pd.Series[int]"), pd.Series, int)
+    check(assert_type(s2.dt.days, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s2.dt.seconds, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s2.dt.microseconds, "pd.Series[int]"), pd.Series, np.integer)
+    check(assert_type(s2.dt.nanoseconds, "pd.Series[int]"), pd.Series, np.integer)
     check(assert_type(s2.dt.components, pd.DataFrame), pd.DataFrame)
     check(assert_type(s2.dt.to_pytimedelta(), np.ndarray), np.ndarray)
     check(assert_type(s2.dt.total_seconds(), "pd.Series[float]"), pd.Series, float)
@@ -461,20 +461,20 @@ def test_datetimeindex_accessors() -> None:
     check(assert_type(i0.date, np.ndarray), np.ndarray, dt.date)
     check(assert_type(i0.time, np.ndarray), np.ndarray, dt.time)
     check(assert_type(i0.timetz, np.ndarray), np.ndarray, dt.time)
-    check(assert_type(i0.year, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.month, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.day, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.hour, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.minute, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.second, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.microsecond, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.nanosecond, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.dayofweek, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.day_of_week, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.weekday, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.dayofyear, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.day_of_year, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.quarter, NumericIndex), NumericIndex, int)
+    check(assert_type(i0.year, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.month, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.day, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.hour, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.minute, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.second, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.microsecond, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.nanosecond, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.dayofweek, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.day_of_week, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.weekday, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.dayofyear, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.day_of_year, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.quarter, NumericIndex), NumericIndex, np.integer)
     check(assert_type(i0.is_month_start, npt.NDArray[np.bool_]), np.ndarray, np.bool_)
     check(assert_type(i0.is_month_end, npt.NDArray[np.bool_]), np.ndarray, np.bool_)
     check(assert_type(i0.is_quarter_start, npt.NDArray[np.bool_]), np.ndarray, np.bool_)
@@ -482,8 +482,8 @@ def test_datetimeindex_accessors() -> None:
     check(assert_type(i0.is_year_start, npt.NDArray[np.bool_]), np.ndarray, np.bool_)
     check(assert_type(i0.is_year_end, npt.NDArray[np.bool_]), np.ndarray, np.bool_)
     check(assert_type(i0.is_leap_year, npt.NDArray[np.bool_]), np.ndarray, np.bool_)
-    check(assert_type(i0.daysinmonth, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.days_in_month, NumericIndex), NumericIndex, int)
+    check(assert_type(i0.daysinmonth, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.days_in_month, NumericIndex), NumericIndex, np.integer)
     check(assert_type(i0.tz, Optional[dt.tzinfo]), type(None))
     check(assert_type(i0.freq, Optional[BaseOffset]), BaseOffset)
     check(assert_type(i0.isocalendar(), pd.DataFrame), pd.DataFrame)
@@ -521,10 +521,10 @@ def test_timedeltaindex_accessors() -> None:
     # GH 292
     i0 = pd.date_range("1/1/2021", "1/5/2021") - pd.Timestamp("1/3/2019")
     check(assert_type(i0, pd.TimedeltaIndex), pd.TimedeltaIndex)
-    check(assert_type(i0.days, pd.Index), pd.Index, int)
-    check(assert_type(i0.seconds, pd.Index), pd.Index, int)
-    check(assert_type(i0.microseconds, pd.Index), pd.Index, int)
-    check(assert_type(i0.nanoseconds, pd.Index), pd.Index, int)
+    check(assert_type(i0.days, pd.Index), pd.Index, np.integer)
+    check(assert_type(i0.seconds, pd.Index), pd.Index, np.integer)
+    check(assert_type(i0.microseconds, pd.Index), pd.Index, np.integer)
+    check(assert_type(i0.nanoseconds, pd.Index), pd.Index, np.integer)
     check(assert_type(i0.components, pd.DataFrame), pd.DataFrame)
     check(assert_type(i0.to_pytimedelta(), np.ndarray), np.ndarray)
     check(assert_type(i0.total_seconds(), pd.Index), pd.Index, float)
@@ -543,20 +543,20 @@ def test_periodindex_accessors() -> None:
     i0 = pd.period_range(start="2022-06-01", periods=10)
     check(assert_type(i0, pd.PeriodIndex), pd.PeriodIndex, pd.Period)
 
-    check(assert_type(i0.year, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.month, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.day, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.hour, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.minute, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.second, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.dayofweek, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.day_of_week, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.weekday, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.dayofyear, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.day_of_year, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.quarter, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.daysinmonth, NumericIndex), NumericIndex, int)
-    check(assert_type(i0.days_in_month, NumericIndex), NumericIndex, int)
+    check(assert_type(i0.year, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.month, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.day, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.hour, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.minute, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.second, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.dayofweek, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.day_of_week, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.weekday, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.dayofyear, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.day_of_year, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.quarter, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.daysinmonth, NumericIndex), NumericIndex, np.integer)
+    check(assert_type(i0.days_in_month, NumericIndex), NumericIndex, np.integer)
     check(assert_type(i0.freq, Optional[BaseOffset]), BaseOffset)
     check(assert_type(i0.strftime("%Y"), pd.Index), pd.Index, str)
     check(assert_type(i0.asfreq("D"), pd.PeriodIndex), pd.PeriodIndex, pd.Period)