diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index ed7688f229ca8..3f99329bef747 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -1634,14 +1634,14 @@ a method of the returned object, including ``sum``, ``mean``, ``std``, ``sem``,
    ts.resample("5Min").max()
 
 
-For downsampling, ``closed`` can be set to 'left' or 'right' to specify which
+For downsampling, ``inclusive`` can be set to 'left' or 'right' to specify which
 end of the interval is closed:
 
 .. ipython:: python
 
-   ts.resample("5Min", closed="right").mean()
+   ts.resample("5Min", inclusive="right").mean()
 
-   ts.resample("5Min", closed="left").mean()
+   ts.resample("5Min", inclusive="left").mean()
 
 Parameters like ``label`` are used to manipulate the resulting labels.
 ``label`` specifies whether the result is labeled with the beginning or
@@ -1655,7 +1655,7 @@ the end of the interval.
 
 .. warning::
 
-    The default values for ``label`` and ``closed`` is '**left**' for all
+    The default values for ``label`` and ``inclusive`` is '**left**' for all
     frequency offsets except for 'M', 'A', 'Q', 'BM', 'BA', 'BQ', and 'W'
     which all have a default of 'right'.
 
@@ -1669,7 +1669,7 @@ the end of the interval.
         s.iloc[2] = pd.NaT
         s.dt.day_name()
 
-        # default: label='left', closed='left'
+        # default: label='left', inclusive='left'
         s.resample("B").last().dt.day_name()
 
     Notice how the value for Sunday got pulled back to the previous Friday.
@@ -1678,7 +1678,7 @@ the end of the interval.
 
     .. ipython:: python
 
-        s.resample("B", label="right", closed="right").last().dt.day_name()
+        s.resample("B", label="right", inclusive="right").last().dt.day_name()
 
 The ``axis`` parameter can be set to 0 or 1 and allows you to resample the
 specified axis for a ``DataFrame``.
diff --git a/doc/source/user_guide/window.rst b/doc/source/user_guide/window.rst
index e08fa81c5fa09..17ce97b01a8df 100644
--- a/doc/source/user_guide/window.rst
+++ b/doc/source/user_guide/window.rst
@@ -196,7 +196,7 @@ This can also be applied to datetime-like indices.
 Rolling window endpoints
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-The inclusion of the interval endpoints in rolling window calculations can be specified with the ``closed``
+The inclusion of the interval endpoints in rolling window calculations can be specified with the ``inclusive``
 parameter:
 
 =============  ====================
@@ -225,10 +225,10 @@ from present information back to past information. This allows the rolling windo
        ],
    )
 
-   df["right"] = df.rolling("2s", closed="right").x.sum()  # default
-   df["both"] = df.rolling("2s", closed="both").x.sum()
-   df["left"] = df.rolling("2s", closed="left").x.sum()
-   df["neither"] = df.rolling("2s", closed="neither").x.sum()
+   df["right"] = df.rolling("2s", inclusive="right").x.sum()  # default
+   df["both"] = df.rolling("2s", inclusive="both").x.sum()
+   df["left"] = df.rolling("2s", inclusive="left").x.sum()
+   df["neither"] = df.rolling("2s", inclusive="neither").x.sum()
 
    df
 
@@ -264,7 +264,7 @@ and we want to use an expanding window where ``use_expanding`` is ``True`` other
    In [2]: from pandas.api.indexers import BaseIndexer
 
    In [3]: class CustomIndexer(BaseIndexer):
-      ...:     def get_window_bounds(self, num_values, min_periods, center, closed):
+      ...:     def get_window_bounds(self, num_values, min_periods, center, inclusive):
       ...:         start = np.empty(num_values, dtype=np.int64)
       ...:         end = np.empty(num_values, dtype=np.int64)
       ...:         for i in range(num_values):
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 9042c16362726..82869210f3150 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -11398,8 +11398,8 @@ def asfreq(
     def resample(
         self,
         rule,
-        axis: Axis = 0,
-        closed: str | None = None,
+        axis=0,
+        inclusive: str | None = None,
         label: str | None = None,
         convention: str = "start",
         kind: str | None = None,
@@ -11414,7 +11414,7 @@ def resample(
         return super().resample(
             rule=rule,
             axis=axis,
-            closed=closed,
+            inclusive=inclusive,
             label=label,
             convention=convention,
             kind=kind,
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 8ed3ba02991bc..c1c47bf954af4 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -8406,8 +8406,8 @@ def between_time(
     def resample(
         self,
         rule,
-        axis: Axis = 0,
-        closed: str | None = None,
+        axis=0,
+        inclusive: str | None = None,
         label: str | None = None,
         convention: str = "start",
         kind: str | None = None,
@@ -8435,7 +8435,7 @@ def resample(
             Which axis to use for up- or down-sampling. For `Series` this parameter
             is unused and defaults to 0. Must be
             `DatetimeIndex`, `TimedeltaIndex` or `PeriodIndex`.
-        closed : {{'right', 'left'}}, default None
+        inclusive : {{'right', 'left'}}, default None
             Which side of bin interval is closed. The default is 'left'
             for all frequency offsets except for 'M', 'A', 'Q', 'BM',
             'BA', 'BQ', and 'W' which all have a default of 'right'.
@@ -8570,7 +8570,7 @@ def resample(
         Downsample the series into 3 minute bins as above, but close the right
         side of the bin interval.
 
-        >>> series.resample('3T', label='right', closed='right').sum()
+        >>> series.resample('3T', label='right', inclusive='right').sum()
         2000-01-01 00:00:00     0
         2000-01-01 00:03:00     6
         2000-01-01 00:06:00    15
@@ -8832,7 +8832,7 @@ def resample(
             self,
             freq=rule,
             label=label,
-            closed=closed,
+            inclusive=inclusive,
             axis=axis,
             kind=kind,
             loffset=loffset,
@@ -11950,7 +11950,7 @@ def rolling(
         win_type: str | None = None,
         on: str | None = None,
         axis: Axis = 0,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
         method: str = "single",
     ) -> Window | Rolling:
@@ -11965,7 +11965,7 @@ def rolling(
                 win_type=win_type,
                 on=on,
                 axis=axis,
-                closed=closed,
+                inclusive=inclusive,
                 step=step,
                 method=method,
             )
@@ -11978,7 +11978,7 @@ def rolling(
             win_type=win_type,
             on=on,
             axis=axis,
-            closed=closed,
+            inclusive=inclusive,
             step=step,
             method=method,
         )
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 16ee154156616..c479d2467c2ca 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -2762,7 +2762,7 @@ def resample(self, rule, *args, **kwargs):
         Downsample the series into 3 minute bins as above, but close the right
         side of the bin interval.
 
-        >>> df.groupby('a').resample('3T', closed='right').sum()
+        >>> df.groupby('a').resample('3T', inclusive='right').sum()
                                  a  b
         a
         0   1999-12-31 23:57:00  0  1
@@ -2773,7 +2773,7 @@ def resample(self, rule, *args, **kwargs):
         the bin interval, but label each bin using the right edge instead of
         the left.
 
-        >>> df.groupby('a').resample('3T', closed='right', label='right').sum()
+        >>> df.groupby('a').resample('3T', inclusive='right', label='right').sum()
                                  a  b
         a
         0   2000-01-01 00:00:00  0  1
diff --git a/pandas/core/indexers/objects.py b/pandas/core/indexers/objects.py
index c15cbf368c159..9cc5de9c95d25 100644
--- a/pandas/core/indexers/objects.py
+++ b/pandas/core/indexers/objects.py
@@ -25,8 +25,8 @@
     min_periods passed from the top level rolling API
 center : bool, default None
     center passed from the top level rolling API
-closed : str, default None
-    closed passed from the top level rolling API
+inclusive : str, default None
+    inclusive passed from the top level rolling API
 step : int, default None
     step passed from the top level rolling API
     .. versionadded:: 1.5
@@ -64,7 +64,7 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
@@ -80,7 +80,7 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
@@ -91,9 +91,9 @@ def get_window_bounds(
 
         end = np.arange(1 + offset, num_values + 1 + offset, step, dtype="int64")
         start = end - self.window_size
-        if closed in ["left", "both"]:
+        if inclusive in ["left", "both"]:
             start -= 1
-        if closed in ["left", "neither"]:
+        if inclusive in ["left", "neither"]:
             end -= 1
 
         end = np.clip(end, 0, num_values)
@@ -111,7 +111,7 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
@@ -124,7 +124,7 @@ def get_window_bounds(
             self.window_size,
             min_periods,
             center,  # type: ignore[arg-type]
-            closed,
+            inclusive,
             self.index_array,  # type: ignore[arg-type]
         )
 
@@ -150,7 +150,7 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
@@ -160,11 +160,11 @@ def get_window_bounds(
             return np.empty(0, dtype="int64"), np.empty(0, dtype="int64")
 
         # if windows is variable, default is 'right', otherwise default is 'both'
-        if closed is None:
-            closed = "right" if self.index is not None else "both"
+        if inclusive is None:
+            inclusive = "right" if self.index is not None else "both"
 
-        right_closed = closed in ["right", "both"]
-        left_closed = closed in ["left", "both"]
+        right_closed = inclusive in ["right", "both"]
+        left_closed = inclusive in ["left", "both"]
 
         if self.index[num_values - 1] < self.index[0]:
             index_growth_sign = -1
@@ -226,7 +226,7 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
@@ -267,15 +267,15 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
         if center:
             raise ValueError("Forward-looking windows can't have center=True")
-        if closed is not None:
+        if inclusive is not None:
             raise ValueError(
-                "Forward-looking windows don't support setting the closed argument"
+                "Forward-looking windows don't support setting the inclusive argument"
             )
         if step is None:
             step = 1
@@ -333,7 +333,7 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
@@ -356,7 +356,7 @@ def get_window_bounds(
                 **self.indexer_kwargs,
             )
             start, end = indexer.get_window_bounds(
-                len(indices), min_periods, center, closed, step
+                len(indices), min_periods, center, inclusive, step
             )
             start = start.astype(np.int64)
             end = end.astype(np.int64)
@@ -391,7 +391,7 @@ def get_window_bounds(
         num_values: int = 0,
         min_periods: int | None = None,
         center: bool | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index e3d81e01ac94c..74f2aebfef3f7 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -134,7 +134,7 @@ class Resampler(BaseGroupBy, PandasObject):
     _attributes = [
         "freq",
         "axis",
-        "closed",
+        "inclusive",
         "label",
         "convention",
         "loffset",
@@ -1291,7 +1291,7 @@ def _adjust_binner_for_upsample(self, binner):
 
         The range of a new index should not be outside specified range
         """
-        if self.closed == "right":
+        if self.inclusive == "right":
             binner = binner[1:]
         else:
             binner = binner[:-1]
@@ -1540,14 +1540,14 @@ class TimeGrouper(Grouper):
     Parameters
     ----------
     freq : pandas date offset or offset alias for identifying bin edges
-    closed : closed end of interval; 'left' or 'right'
+    inclusive : inclusive end of interval; 'left' or 'right'
     label : interval boundary to use for labeling; 'left' or 'right'
     convention : {'start', 'end', 'e', 's'}
         If axis is PeriodIndex
     """
 
     _attributes = Grouper._attributes + (
-        "closed",
+        "inclusive",
         "label",
         "how",
         "loffset",
@@ -1560,7 +1560,7 @@ class TimeGrouper(Grouper):
     def __init__(
         self,
         freq="Min",
-        closed: Literal["left", "right"] | None = None,
+        inclusive: Literal["left", "right"] | None = None,
         label: Literal["left", "right"] | None = None,
         how="mean",
         axis=0,
@@ -1579,8 +1579,8 @@ def __init__(
         # otherwise silently use the default if misspelled
         if label not in {None, "left", "right"}:
             raise ValueError(f"Unsupported value {label} for `label`")
-        if closed not in {None, "left", "right"}:
-            raise ValueError(f"Unsupported value {closed} for `closed`")
+        if inclusive not in {None, "left", "right"}:
+            raise ValueError(f"Unsupported value {inclusive} for `inclusive`")
         if convention not in {None, "start", "end", "e", "s"}:
             raise ValueError(f"Unsupported value {convention} for `convention`")
 
@@ -1589,8 +1589,8 @@ def __init__(
         end_types = {"M", "A", "Q", "BM", "BA", "BQ", "W"}
         rule = freq.rule_code
         if rule in end_types or ("-" in rule and rule[: rule.find("-")] in end_types):
-            if closed is None:
-                closed = "right"
+            if inclusive is None:
+                inclusive = "right"
             if label is None:
                 label = "right"
         else:
@@ -1601,17 +1601,17 @@ def __init__(
             # the current ``Timestamp`` minus ``freq`` to the current
             # ``Timestamp`` with a right close.
             if origin in ["end", "end_day"]:
-                if closed is None:
-                    closed = "right"
+                if inclusive is None:
+                    inclusive = "right"
                 if label is None:
                     label = "right"
             else:
-                if closed is None:
-                    closed = "left"
+                if inclusive is None:
+                    inclusive = "left"
                 if label is None:
                     label = "left"
 
-        self.closed = closed
+        self.inclusive = inclusive
         self.label = label
         self.kind = kind
         self.convention = convention if convention is not None else "e"
@@ -1722,7 +1722,7 @@ def _get_time_bins(self, ax: DatetimeIndex):
             ax.min(),
             ax.max(),
             self.freq,
-            closed=self.closed,
+            inclusive=self.inclusive,
             origin=self.origin,
             offset=self.offset,
         )
@@ -1748,10 +1748,10 @@ def _get_time_bins(self, ax: DatetimeIndex):
 
         # general version, knowing nothing about relative frequencies
         bins = lib.generate_bins_dt64(
-            ax_values, bin_edges, self.closed, hasnans=ax.hasnans
+            ax_values, bin_edges, self.inclusive, hasnans=ax.hasnans
         )
 
-        if self.closed == "right":
+        if self.inclusive == "right":
             labels = binner
             if self.label == "right":
                 labels = labels[1:]
@@ -1774,7 +1774,7 @@ def _adjust_bin_edges(self, binner, ax_values):
         # Some hacks for > daily data, see #1471, #1458, #1483
 
         if self.freq != "D" and is_superperiod(self.freq, "D"):
-            if self.closed == "right":
+            if self.inclusive == "right":
                 # GH 21459, GH 9119: Adjust the bins relative to the wall time
                 bin_edges = binner.tz_localize(None)
                 bin_edges = bin_edges + timedelta(1) - Nano(1)
@@ -1803,7 +1803,7 @@ def _get_time_delta_bins(self, ax: TimedeltaIndex):
 
         start, end = ax.min(), ax.max()
 
-        if self.closed == "right":
+        if self.inclusive == "right":
             end += self.freq
 
         labels = binner = timedelta_range(
@@ -1811,10 +1811,10 @@ def _get_time_delta_bins(self, ax: TimedeltaIndex):
         )
 
         end_stamps = labels
-        if self.closed == "left":
+        if self.inclusive == "left":
             end_stamps += self.freq
 
-        bins = ax.searchsorted(end_stamps, side=self.closed)
+        bins = ax.searchsorted(end_stamps, side=self.inclusive)
 
         if self.offset:
             # GH 10530 & 31809
@@ -1886,7 +1886,7 @@ def _get_period_bins(self, ax: PeriodIndex):
                 start,
                 end,
                 self.freq,
-                closed=self.closed,
+                inclusive=self.inclusive,
                 origin=self.origin,
                 offset=self.offset,
             )
@@ -1946,7 +1946,7 @@ def _get_timestamp_range_edges(
     first: Timestamp,
     last: Timestamp,
     freq: BaseOffset,
-    closed: Literal["right", "left"] = "left",
+    inclusive: Literal["right", "left"] = "left",
     origin="start_day",
     offset: Timedelta | None = None,
 ) -> tuple[Timestamp, Timestamp]:
@@ -1955,7 +1955,7 @@ def _get_timestamp_range_edges(
     the provided offset. Adjust the `last` Timestamp to the following
     Timestamp that resides on the provided offset. Input Timestamps that
     already reside on the offset will be adjusted depending on the type of
-    offset and the `closed` parameter.
+    offset and the `inclusive` parameter.
 
     Parameters
     ----------
@@ -1965,7 +1965,7 @@ def _get_timestamp_range_edges(
         The ending Timestamp of the range to be adjusted.
     freq : pd.DateOffset
         The dateoffset to which the Timestamps will be adjusted.
-    closed : {'right', 'left'}, default "left"
+    inclusive : {'right', 'left'}, default "left"
         Which side of bin interval is closed.
     origin : {'epoch', 'start', 'start_day'} or Timestamp, default 'start_day'
         The timestamp on which to adjust the grouping. The timezone of origin must
@@ -2001,7 +2001,7 @@ def _get_timestamp_range_edges(
                 origin = origin.tz_localize(None)
 
         first, last = _adjust_dates_anchored(
-            first, last, freq, closed=closed, origin=origin, offset=offset
+            first, last, freq, inclusive=inclusive, origin=origin, offset=offset
         )
         if isinstance(freq, Day):
             first = first.tz_localize(index_tz)
@@ -2010,7 +2010,7 @@ def _get_timestamp_range_edges(
         first = first.normalize()
         last = last.normalize()
 
-        if closed == "left":
+        if inclusive == "left":
             first = Timestamp(freq.rollback(first))
         else:
             first = Timestamp(first - freq)
@@ -2024,7 +2024,7 @@ def _get_period_range_edges(
     first: Period,
     last: Period,
     freq: BaseOffset,
-    closed: Literal["right", "left"] = "left",
+    inclusive: Literal["right", "left"] = "left",
     origin="start_day",
     offset: Timedelta | None = None,
 ) -> tuple[Period, Period]:
@@ -2040,7 +2040,7 @@ def _get_period_range_edges(
         The ending Period of the range to be adjusted.
     freq : pd.DateOffset
         The freq to which the Periods will be adjusted.
-    closed : {'right', 'left'}, default "left"
+    inclusive : {'right', 'left'}, default "left"
         Which side of bin interval is closed.
     origin : {'epoch', 'start', 'start_day'}, Timestamp, default 'start_day'
         The timestamp on which to adjust the grouping. The timezone of origin must
@@ -2068,7 +2068,7 @@ def _get_period_range_edges(
     adjust_last = freq.is_on_offset(last_ts)
 
     first_ts, last_ts = _get_timestamp_range_edges(
-        first_ts, last_ts, freq, closed=closed, origin=origin, offset=offset
+        first_ts, last_ts, freq, inclusive=inclusive, origin=origin, offset=offset
     )
 
     first = (first_ts + int(adjust_first) * freq).to_period(freq)
@@ -2098,7 +2098,7 @@ def _adjust_dates_anchored(
     first: Timestamp,
     last: Timestamp,
     freq: Tick,
-    closed: Literal["right", "left"] = "right",
+    inclusive: Literal["right", "left"] = "right",
     origin="start_day",
     offset: Timedelta | None = None,
 ) -> tuple[Timestamp, Timestamp]:
@@ -2117,7 +2117,7 @@ def _adjust_dates_anchored(
     elif origin in ["end", "end_day"]:
         origin = last if origin == "end" else last.ceil("D")
         sub_freq_times = (origin.value - first.value) // freq.nanos
-        if closed == "left":
+        if inclusive == "left":
             sub_freq_times += 1
         first = origin - sub_freq_times * freq
         origin_nanos = first.value
@@ -2136,7 +2136,7 @@ def _adjust_dates_anchored(
     foffset = (first.value - origin_nanos) % freq.nanos
     loffset = (last.value - origin_nanos) % freq.nanos
 
-    if closed == "right":
+    if inclusive == "right":
         if foffset > 0:
             # roll back
             fresult_int = first.value - foffset
diff --git a/pandas/core/series.py b/pandas/core/series.py
index e80a798eb1898..192f08bb3043d 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -5835,8 +5835,8 @@ def asfreq(
     def resample(
         self,
         rule,
-        axis: Axis = 0,
-        closed: str | None = None,
+        axis=0,
+        inclusive: str | None = None,
         label: str | None = None,
         convention: str = "start",
         kind: str | None = None,
@@ -5851,7 +5851,7 @@ def resample(
         return super().resample(
             rule=rule,
             axis=axis,
-            closed=closed,
+            inclusive=inclusive,
             label=label,
             convention=convention,
             kind=kind,
diff --git a/pandas/core/window/ewm.py b/pandas/core/window/ewm.py
index 32559d0d88bcf..97922f94e5d57 100644
--- a/pandas/core/window/ewm.py
+++ b/pandas/core/window/ewm.py
@@ -369,7 +369,7 @@ def __init__(
             min_periods=1 if min_periods is None else max(int(min_periods), 1),
             on=None,
             center=False,
-            closed=None,
+            inclusive=None,
             method=method,
             axis=axis,
             selection=selection,
@@ -780,7 +780,7 @@ def cov_func(x, y):
                 num_values=len(x_array),
                 min_periods=min_periods,
                 center=self.center,
-                closed=self.closed,
+                inclusive=self.inclusive,
                 step=self.step,
             )
             result = window_aggregations.ewmcov(
@@ -854,7 +854,7 @@ def cov_func(x, y):
                 num_values=len(x_array),
                 min_periods=min_periods,
                 center=self.center,
-                closed=self.closed,
+                inclusive=self.inclusive,
                 step=self.step,
             )
 
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 3fc48b121419a..daa5e3eae09b8 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -127,7 +127,7 @@ def __init__(
         win_type: str | None = None,
         axis: Axis = 0,
         on: str | Index | None = None,
-        closed: str | None = None,
+        inclusive: str | None = None,
         step: int | None = None,
         method: str = "single",
         *,
@@ -135,7 +135,7 @@ def __init__(
     ) -> None:
         self.obj = obj
         self.on = on
-        self.closed = closed
+        self.inclusive = inclusive
         self.step = step
         self.window = window
         self.min_periods = min_periods
@@ -205,13 +205,13 @@ def _validate(self) -> None:
                 raise ValueError(
                     f"min_periods {self.min_periods} must be <= window {self.window}"
                 )
-        if self.closed is not None and self.closed not in [
+        if self.inclusive is not None and self.inclusive not in [
             "right",
             "both",
             "left",
             "neither",
         ]:
-            raise ValueError("closed must be 'right', 'left', 'both' or 'neither'")
+            raise ValueError("inclusive must be 'right', 'left', 'both' or 'neither'")
         if not isinstance(self.obj, (ABCSeries, ABCDataFrame)):
             raise TypeError(f"invalid type: {type(self)}")
         if isinstance(self.window, BaseIndexer):
@@ -378,7 +378,7 @@ def __iter__(self):
             num_values=len(obj),
             min_periods=self.min_periods,
             center=self.center,
-            closed=self.closed,
+            inclusive=self.inclusive,
             step=self.step,
         )
         self._check_window_bounds(start, end, len(obj))
@@ -647,7 +647,7 @@ def calc(x):
                     num_values=len(x),
                     min_periods=min_periods,
                     center=self.center,
-                    closed=self.closed,
+                    inclusive=self.inclusive,
                     step=self.step,
                 )
                 self._check_window_bounds(start, end, len(x))
@@ -686,7 +686,7 @@ def _numba_apply(
             num_values=len(values),
             min_periods=min_periods,
             center=self.center,
-            closed=self.closed,
+            inclusive=self.inclusive,
             step=self.step,
         )
         self._check_window_bounds(start, end, len(values))
@@ -935,7 +935,7 @@ class Window(BaseWindow):
 
         If a BaseIndexer subclass, the window boundaries
         based on the defined ``get_window_bounds`` method. Additional rolling
-        keyword arguments, namely ``min_periods``, ``center``, ``closed`` and
+        keyword arguments, namely ``min_periods``, ``center``, ``inclusive`` and
         ``step`` will be passed to ``get_window_bounds``.
 
     min_periods : int, default None
@@ -976,7 +976,7 @@ class Window(BaseWindow):
 
         For `Series` this parameter is unused and defaults to 0.
 
-    closed : str, default None
+    inclusive : str, default None
         If ``'right'``, the first point in the window is excluded from calculations.
 
         If ``'left'``, the last point in the window is excluded from calculations.
@@ -1150,7 +1150,7 @@ class Window(BaseWindow):
         "win_type",
         "axis",
         "on",
-        "closed",
+        "inclusive",
         "step",
         "method",
     ]
@@ -1724,7 +1724,7 @@ def cov_func(x, y):
                 num_values=len(x_array),
                 min_periods=min_periods,
                 center=self.center,
-                closed=self.closed,
+                inclusive=self.inclusive,
                 step=self.step,
             )
             self._check_window_bounds(start, end, len(x_array))
@@ -1772,7 +1772,7 @@ def corr_func(x, y):
                 num_values=len(x_array),
                 min_periods=min_periods,
                 center=self.center,
-                closed=self.closed,
+                inclusive=self.inclusive,
                 step=self.step,
             )
             self._check_window_bounds(start, end, len(x_array))
@@ -1813,7 +1813,7 @@ class Rolling(RollingAndExpandingMixin):
         "win_type",
         "axis",
         "on",
-        "closed",
+        "inclusive",
         "step",
         "method",
     ]
diff --git a/pandas/tests/frame/methods/test_asof.py b/pandas/tests/frame/methods/test_asof.py
index 0b27fe591f794..ce0bd24e6b13a 100644
--- a/pandas/tests/frame/methods/test_asof.py
+++ b/pandas/tests/frame/methods/test_asof.py
@@ -66,7 +66,7 @@ def test_subset(self, date_range_frame):
 
         # B gives df.asof
         result = df.asof(dates, subset="B")
-        expected = df.resample("25s", closed="right").ffill().reindex(dates)
+        expected = df.resample("25s", inclusive="right").ffill().reindex(dates)
         expected.iloc[20:] = 9
         # no "missing", so "B" can retain int dtype (df["A"].dtype platform-dependent)
         expected["B"] = expected["B"].astype(df["B"].dtype)
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 970d4f155ecfc..bfe7f4b44faf4 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -65,7 +65,7 @@ def test_custom_grouper(index):
     for f in funcs:
         g._cython_agg_general(f, alt=None, numeric_only=True)
 
-    b = Grouper(freq=Minute(5), closed="right", label="right")
+    b = Grouper(freq=Minute(5), inclusive="right", label="right")
     g = s.groupby(b)
     # check all cython functions work
     g.ohlc()  # doesn't use _cython_agg_general
@@ -89,7 +89,7 @@ def test_custom_grouper(index):
 
 
 def test_custom_grouper_df(index):
-    b = Grouper(freq=Minute(5), closed="right", label="right")
+    b = Grouper(freq=Minute(5), inclusive="right", label="right")
     dti = index
     df = DataFrame(np.random.rand(len(dti), 10), index=dti, dtype="float64")
     r = df.groupby(b).agg(np.sum)
@@ -103,7 +103,7 @@ def test_custom_grouper_df(index):
     [("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
 )
 @pytest.mark.parametrize(
-    "closed, expected",
+    "inclusive, expected",
     [
         (
             "right",
@@ -123,10 +123,10 @@ def test_custom_grouper_df(index):
         ),
     ],
 )
-def test_resample_basic(series, closed, expected):
+def test_resample_basic(series, inclusive, expected):
     s = series
     expected = expected(s)
-    result = s.resample("5min", closed=closed, label="right").mean()
+    result = s.resample("5min", inclusive=inclusive, label="right").mean()
     tm.assert_series_equal(result, expected)
 
 
@@ -155,7 +155,7 @@ def test_resample_integerarray():
 def test_resample_basic_grouper(series):
     s = series
     result = s.resample("5Min").last()
-    grouper = Grouper(freq=Minute(5), closed="left", label="left")
+    grouper = Grouper(freq=Minute(5), inclusive="left", label="left")
     expected = s.groupby(grouper).agg(lambda x: x[-1])
     tm.assert_series_equal(result, expected)
 
@@ -166,7 +166,7 @@ def test_resample_basic_grouper(series):
 )
 @pytest.mark.parametrize(
     "keyword,value",
-    [("label", "righttt"), ("closed", "righttt"), ("convention", "starttt")],
+    [("label", "righttt"), ("inclusive", "righttt"), ("convention", "starttt")],
 )
 def test_resample_string_kwargs(series, keyword, value):
     # see gh-19303
@@ -194,7 +194,7 @@ def test_resample_how(series, downsample_method):
     expected.index = date_range("1/1/2000", periods=4, freq="5min", name="index")
 
     result = getattr(
-        s.resample("5min", closed="right", label="right"), downsample_method
+        s.resample("5min", inclusive="right", label="right"), downsample_method
     )()
     tm.assert_series_equal(result, expected)
 
@@ -222,7 +222,7 @@ def _ohlc(group):
         columns=["open", "high", "low", "close"],
     )
 
-    result = s.resample("5min", closed="right", label="right").ohlc()
+    result = s.resample("5min", inclusive="right", label="right").ohlc()
     tm.assert_frame_equal(result, expected)
 
 
@@ -635,7 +635,7 @@ def test_resample_dup_index():
 def test_resample_reresample():
     dti = date_range(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq="D")
     s = Series(np.random.rand(len(dti)), dti)
-    bs = s.resample("B", closed="right", label="right").mean()
+    bs = s.resample("B", inclusive="right", label="right").mean()
     result = bs.resample("8H").mean()
     assert len(result) == 22
     assert isinstance(result.index.freq, offsets.DateOffset)
@@ -668,7 +668,7 @@ def _ohlc(group):
     rng = date_range("1/1/2000 00:00:00", "1/1/2000 5:59:50", freq="10s")
     ts = Series(np.random.randn(len(rng)), index=rng)
 
-    resampled = ts.resample("5min", closed="right", label="right").ohlc()
+    resampled = ts.resample("5min", inclusive="right", label="right").ohlc()
 
     assert (resampled.loc["1/1/2000 00:00"] == ts[0]).all()
 
@@ -723,8 +723,8 @@ def test_resample_anchored_ticks(freq):
     rng = date_range("1/1/2000 04:00:00", periods=86400, freq="s")
     ts = Series(np.random.randn(len(rng)), index=rng)
     ts[:2] = np.nan  # so results are the same
-    result = ts[2:].resample(freq, closed="left", label="left").mean()
-    expected = ts.resample(freq, closed="left", label="left").mean()
+    result = ts[2:].resample(freq, inclusive="left", label="left").mean()
+    expected = ts.resample(freq, inclusive="left", label="left").mean()
     tm.assert_series_equal(result, expected)
 
 
@@ -951,8 +951,8 @@ def test_resample_daily_anchored():
     ts = Series(np.random.randn(len(rng)), index=rng)
     ts[:2] = np.nan  # so results are the same
 
-    result = ts[2:].resample("D", closed="left", label="left").mean()
-    expected = ts.resample("D", closed="left", label="left").mean()
+    result = ts[2:].resample("D", inclusive="left", label="left").mean()
+    expected = ts.resample("D", inclusive="left", label="left").mean()
     tm.assert_series_equal(result, expected)
 
 
@@ -1083,7 +1083,7 @@ def test_resample_anchored_intraday(simple_date_range_series):
     assert expected.index.freq == "M"
     tm.assert_frame_equal(result, expected)
 
-    result = df.resample("M", closed="left").mean()
+    result = df.resample("M", inclusive="left").mean()
     exp = df.shift(1, freq="D").resample("M", kind="period").mean()
     exp = exp.to_timestamp(how="end")
 
@@ -1102,8 +1102,10 @@ def test_resample_anchored_intraday(simple_date_range_series):
     expected.index._freq = lib.no_default
     tm.assert_frame_equal(result, expected)
 
-    result = df.resample("Q", closed="left").mean()
-    expected = df.shift(1, freq="D").resample("Q", kind="period", closed="left").mean()
+    result = df.resample("Q", inclusive="left").mean()
+    expected = (
+        df.shift(1, freq="D").resample("Q", kind="period", inclusive="left").mean()
+    )
     expected = expected.to_timestamp(how="end")
     expected.index += Timedelta(1, "ns") - Timedelta(1, "D")
     expected.index._data.freq = "Q"
@@ -1146,7 +1148,7 @@ def test_corner_cases():
     rng = date_range("1/1/2000", periods=12, freq="t")
     ts = Series(np.random.randn(len(rng)), index=rng)
 
-    result = ts.resample("5t", closed="right", label="left").mean()
+    result = ts.resample("5t", inclusive="right", label="left").mean()
     ex_index = date_range("1999-12-31 23:55", periods=4, freq="5t")
     tm.assert_index_equal(result.index, ex_index)
 
diff --git a/pandas/tests/resample/test_deprecated.py b/pandas/tests/resample/test_deprecated.py
index 126ca05ca1546..af5ca6e27a8b9 100644
--- a/pandas/tests/resample/test_deprecated.py
+++ b/pandas/tests/resample/test_deprecated.py
@@ -112,7 +112,7 @@ def test_resample_loffset(loffset):
 
     with tm.assert_produces_warning(FutureWarning):
         result = s.resample(
-            "5min", closed="right", label="right", loffset=loffset
+            "5min", inclusive="right", label="right", loffset=loffset
         ).mean()
     idx = date_range("1/1/2000", periods=4, freq="5min")
     expected = Series(
@@ -141,7 +141,7 @@ def test_resample_loffset_upsample():
 
     with tm.assert_produces_warning(FutureWarning):
         result = s.resample(
-            "5min", closed="right", label="right", loffset=timedelta(minutes=1)
+            "5min", inclusive="right", label="right", loffset=timedelta(minutes=1)
         ).ffill()
     idx = date_range("1/1/2000", periods=4, freq="5min")
     expected = Series([s[0], s[5], s[10], s[-1]], index=idx + timedelta(minutes=1))
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index 4da1f4c589c56..08f15fda4a12a 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -497,7 +497,7 @@ def test_resample_tz_localized(self):
         )
         s = Series([1, 2], index=idx)
 
-        result = s.resample("D", closed="right", label="right").mean()
+        result = s.resample("D", inclusive="right", label="right").mean()
         ex_index = date_range("2001-09-21", periods=1, freq="D", tz="Australia/Sydney")
         expected = Series([1.5], index=ex_index)
 
@@ -538,12 +538,12 @@ def test_closed_left_corner(self):
         )
         s[0] = np.nan
 
-        result = s.resample("10min", closed="left", label="right").mean()
-        exp = s[1:].resample("10min", closed="left", label="right").mean()
+        result = s.resample("10min", inclusive="left", label="right").mean()
+        exp = s[1:].resample("10min", inclusive="left", label="right").mean()
         tm.assert_series_equal(result, exp)
 
-        result = s.resample("10min", closed="left", label="left").mean()
-        exp = s[1:].resample("10min", closed="left", label="left").mean()
+        result = s.resample("10min", inclusive="left", label="left").mean()
+        exp = s[1:].resample("10min", inclusive="left", label="left").mean()
 
         ex_index = date_range(start="1/1/2012 9:30", freq="10min", periods=3)
 
@@ -566,7 +566,7 @@ def test_resample_weekly_bug_1726(self):
         df = DataFrame(data, columns=["open", "high", "low", "close", "vol"], index=ind)
 
         # it works!
-        df.resample("W-MON", closed="left", label="left").first()
+        df.resample("W-MON", inclusive="left", label="left").first()
 
     def test_resample_with_dst_time_change(self):
         # GH 15549
@@ -576,7 +576,7 @@ def test_resample_with_dst_time_change(self):
             .tz_convert("America/Chicago")
         )
         df = DataFrame([1, 2], index=index)
-        result = df.resample("12h", closed="right", label="right").last().ffill()
+        result = df.resample("12h", inclusive="right", label="right").last().ffill()
 
         expected_index_values = [
             "2016-03-09 12:00:00-06:00",
@@ -634,7 +634,7 @@ def test_default_right_closed_label(self, from_freq, to_freq):
 
         resampled = df.resample(to_freq).mean()
         tm.assert_frame_equal(
-            resampled, df.resample(to_freq, closed="right", label="right").mean()
+            resampled, df.resample(to_freq, inclusive="right", label="right").mean()
         )
 
     @pytest.mark.parametrize(
@@ -647,7 +647,7 @@ def test_default_left_closed_label(self, from_freq, to_freq):
 
         resampled = df.resample(to_freq).mean()
         tm.assert_frame_equal(
-            resampled, df.resample(to_freq, closed="left", label="left").mean()
+            resampled, df.resample(to_freq, inclusive="left", label="left").mean()
         )
 
     def test_all_values_single_bin(self):
diff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py
index c5cd777962df3..c0cd207f46e20 100644
--- a/pandas/tests/resample/test_resample_api.py
+++ b/pandas/tests/resample/test_resample_api.py
@@ -29,13 +29,13 @@ def test_str():
 
     r = test_series.resample("H")
     assert (
-        "DatetimeIndexResampler [freq=<Hour>, axis=0, closed=left, "
+        "DatetimeIndexResampler [freq=<Hour>, axis=0, inclusive=left, "
         "label=left, convention=start, origin=start_day]" in str(r)
     )
 
     r = test_series.resample("H", origin="2000-01-01")
     assert (
-        "DatetimeIndexResampler [freq=<Hour>, axis=0, closed=left, "
+        "DatetimeIndexResampler [freq=<Hour>, axis=0, inclusive=left, "
         "label=left, convention=start, origin=2000-01-01 00:00:00]" in str(r)
     )
 
@@ -737,7 +737,7 @@ def test_resample_agg_readonly():
 
 
 @pytest.mark.parametrize(
-    "start,end,freq,data,resample_freq,origin,closed,exp_data,exp_end,exp_periods",
+    "start,end,freq,data,resample_freq,origin,inclusive,exp_data,exp_end,exp_periods",
     [
         (
             "2000-10-01 23:30:00",
@@ -796,7 +796,7 @@ def test_end_and_end_day_origin(
     data,
     resample_freq,
     origin,
-    closed,
+    inclusive,
     exp_data,
     exp_end,
     exp_periods,
@@ -804,7 +804,7 @@ def test_end_and_end_day_origin(
     rng = date_range(start, end, freq=freq)
     ts = Series(data, index=rng)
 
-    res = ts.resample(resample_freq, origin=origin, closed=closed).sum()
+    res = ts.resample(resample_freq, origin=origin, inclusive=inclusive).sum()
     expected = Series(
         exp_data,
         index=date_range(end=exp_end, freq=resample_freq, periods=exp_periods),
diff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py
index 4498f11d77313..9c2df043de8ce 100644
--- a/pandas/tests/resample/test_time_grouper.py
+++ b/pandas/tests/resample/test_time_grouper.py
@@ -18,7 +18,7 @@
 
 
 def test_apply():
-    grouper = Grouper(freq="A", label="right", closed="right")
+    grouper = Grouper(freq="A", label="right", inclusive="right")
 
     grouped = test_series.groupby(grouper)
 
@@ -38,7 +38,7 @@ def test_count():
 
     expected = test_series.groupby(lambda x: x.year).count()
 
-    grouper = Grouper(freq="A", label="right", closed="right")
+    grouper = Grouper(freq="A", label="right", inclusive="right")
     result = test_series.groupby(grouper).count()
     expected.index = result.index
     tm.assert_series_equal(result, expected)
@@ -49,7 +49,7 @@ def test_count():
 
 
 def test_numpy_reduction():
-    result = test_series.resample("A", closed="right").prod()
+    result = test_series.resample("A", inclusive="right").prod()
 
     expected = test_series.groupby(lambda x: x.year).agg(np.prod)
     expected.index = result.index
@@ -267,7 +267,7 @@ def test_repr():
     result = repr(Grouper(key="A", freq="H"))
     expected = (
         "TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, dropna=True, "
-        "closed='left', label='left', how='mean', "
+        "inclusive='left', label='left', how='mean', "
         "convention='e', origin='start_day')"
     )
     assert result == expected
@@ -275,7 +275,7 @@ def test_repr():
     result = repr(Grouper(key="A", freq="H", origin="2000-01-01"))
     expected = (
         "TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, dropna=True, "
-        "closed='left', label='left', how='mean', "
+        "inclusive='left', label='left', how='mean', "
         "convention='e', origin=Timestamp('2000-01-01 00:00:00'))"
     )
     assert result == expected
diff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py
index ad1c361373189..6e3f02b77d712 100644
--- a/pandas/tests/resample/test_timedelta.py
+++ b/pandas/tests/resample/test_timedelta.py
@@ -197,7 +197,7 @@ def test_resample_closed_right():
     # GH#45414
     idx = pd.Index([pd.Timedelta(seconds=120 + i * 30) for i in range(10)])
     ser = Series(range(10), index=idx)
-    result = ser.resample("T", closed="right", label="right").sum()
+    result = ser.resample("T", inclusive="right", label="right").sum()
     expected = Series(
         [0, 3, 7, 11, 15, 9],
         index=pd.TimedeltaIndex(
diff --git a/pandas/tests/window/test_api.py b/pandas/tests/window/test_api.py
index 6495f7411938c..8b497420330c5 100644
--- a/pandas/tests/window/test_api.py
+++ b/pandas/tests/window/test_api.py
@@ -358,7 +358,7 @@ def test_dont_modify_attributes_after_methods(
 ):
     # GH 39554
     roll_obj = Series(range(1)).rolling(
-        1, center=center, closed=closed, min_periods=min_periods, step=step
+        1, center=center, inclusive=closed, min_periods=min_periods, step=step
     )
     expected = {attr: getattr(roll_obj, attr) for attr in roll_obj._attributes}
     getattr(roll_obj, arithmetic_win_operators)()
diff --git a/pandas/tests/window/test_base_indexer.py b/pandas/tests/window/test_base_indexer.py
index eb5278c2b33ea..49fe4d1de13ba 100644
--- a/pandas/tests/window/test_base_indexer.py
+++ b/pandas/tests/window/test_base_indexer.py
@@ -46,7 +46,7 @@ def test_indexer_constructor_arg():
     df = DataFrame({"values": range(5)})
 
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+        def get_window_bounds(self, num_values, min_periods, center, inclusive, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
@@ -68,14 +68,14 @@ def test_indexer_accepts_rolling_args():
     df = DataFrame({"values": range(5)})
 
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+        def get_window_bounds(self, num_values, min_periods, center, inclusive, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
                 if (
                     center
                     and min_periods == 1
-                    and closed == "both"
+                    and inclusive == "both"
                     and step == 1
                     and i == 2
                 ):
@@ -88,7 +88,7 @@ def get_window_bounds(self, num_values, min_periods, center, closed, step):
 
     indexer = CustomIndexer(window_size=1)
     result = df.rolling(
-        indexer, center=True, min_periods=1, closed="both", step=1
+        indexer, center=True, min_periods=1, inclusive="both", step=1
     ).sum()
     expected = DataFrame({"values": [0.0, 1.0, 10.0, 3.0, 4.0]})
     tm.assert_frame_equal(result, expected)
@@ -161,9 +161,9 @@ def test_rolling_forward_window(constructor, func, np_func, expected, np_kwargs,
         rolling = constructor(values).rolling(window=indexer, center=True)
         getattr(rolling, func)()
 
-    match = "Forward-looking windows don't support setting the closed argument"
+    match = "Forward-looking windows don't support setting the inclusive argument"
     with pytest.raises(ValueError, match=match):
-        rolling = constructor(values).rolling(window=indexer, closed="right")
+        rolling = constructor(values).rolling(window=indexer, inclusive="right")
         getattr(rolling, func)()
 
     rolling = constructor(values).rolling(window=indexer, min_periods=2, step=step)
@@ -253,18 +253,18 @@ def test_rolling_forward_cov_corr(func, expected):
 
 
 @pytest.mark.parametrize(
-    "closed,expected_data",
+    "inclusive,expected_data",
     [
         ["right", [0.0, 1.0, 2.0, 3.0, 7.0, 12.0, 6.0, 7.0, 8.0, 9.0]],
         ["left", [0.0, 0.0, 1.0, 2.0, 5.0, 9.0, 5.0, 6.0, 7.0, 8.0]],
     ],
 )
-def test_non_fixed_variable_window_indexer(closed, expected_data):
+def test_non_fixed_variable_window_indexer(inclusive, expected_data):
     index = date_range("2020", periods=10)
     df = DataFrame(range(10), index=index)
     offset = BusinessDay(1)
     indexer = VariableOffsetWindowIndexer(index=index, offset=offset)
-    result = df.rolling(indexer, closed=closed).sum()
+    result = df.rolling(indexer, inclusive=inclusive).sum()
     expected = DataFrame(expected_data, index=index)
     tm.assert_frame_equal(result, expected)
 
@@ -285,7 +285,7 @@ def test_fixed_forward_indexer_count(step):
 def test_indexer_quantile_sum(end_value, values, func, args):
     # GH 37153
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+        def get_window_bounds(self, num_values, min_periods, center, inclusive, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
@@ -466,7 +466,7 @@ def test_rolling_groupby_with_fixed_forward_many(group_keys, window_size):
 
 def test_unequal_start_end_bounds():
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+        def get_window_bounds(self, num_values, min_periods, center, inclusive, step):
             return np.array([1]), np.array([1, 2])
 
     indexer = CustomIndexer()
@@ -488,7 +488,7 @@ def get_window_bounds(self, num_values, min_periods, center, closed, step):
 def test_unequal_bounds_to_object():
     # GH 44470
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+        def get_window_bounds(self, num_values, min_periods, center, inclusive, step):
             return np.array([1]), np.array([2])
 
     indexer = CustomIndexer()
diff --git a/pandas/tests/window/test_groupby.py b/pandas/tests/window/test_groupby.py
index 5f4805eaa01d2..b8724f699ebf9 100644
--- a/pandas/tests/window/test_groupby.py
+++ b/pandas/tests/window/test_groupby.py
@@ -452,7 +452,7 @@ def get_window_bounds(
                 num_values=0,
                 min_periods=None,
                 center=None,
-                closed=None,
+                inclusive=None,
                 step=None,
             ):
                 min_periods = self.window_size if min_periods is None else 0
@@ -483,7 +483,9 @@ def test_groupby_rolling_subset_with_closed(self):
             }
         )
         result = (
-            df.groupby("group").rolling("1D", on="date", closed="left")["column1"].sum()
+            df.groupby("group")
+            .rolling("1D", on="date", inclusive="left")["column1"]
+            .sum()
         )
         expected = Series(
             [np.nan, 0.0, 2.0, np.nan, 1.0, 4.0],
@@ -509,7 +511,7 @@ def test_groupby_subset_rolling_subset_with_closed(self):
 
         result = (
             df.groupby("group")[["column1", "date"]]
-            .rolling("1D", on="date", closed="left")["column1"]
+            .rolling("1D", on="date", inclusive="left")["column1"]
             .sum()
         )
         expected = Series(
@@ -629,7 +631,7 @@ def test_groupby_rolling_count_closed_on(self):
         )
         result = (
             df.groupby("group")
-            .rolling("3d", on="date", closed="left")["column1"]
+            .rolling("3d", on="date", inclusive="left")["column1"]
             .count()
         )
         expected = Series(
@@ -796,7 +798,7 @@ def test_groupby_rolling_object_doesnt_affect_groupby_apply(self, roll_frame):
         assert not g.grouper.mutated
 
     @pytest.mark.parametrize(
-        ("window", "min_periods", "closed", "expected"),
+        ("window", "min_periods", "inclusive", "expected"),
         [
             (2, 0, "left", [None, 0.0, 1.0, 1.0, None, 0.0, 1.0, 1.0]),
             (2, 2, "left", [None, None, 1.0, 1.0, None, None, 1.0, 1.0]),
@@ -804,11 +806,11 @@ def test_groupby_rolling_object_doesnt_affect_groupby_apply(self, roll_frame):
             (4, 4, "right", [None, None, None, 5.0, None, None, None, 5.0]),
         ],
     )
-    def test_groupby_rolling_var(self, window, min_periods, closed, expected):
+    def test_groupby_rolling_var(self, window, min_periods, inclusive, expected):
         df = DataFrame([1, 2, 3, 4, 5, 6, 7, 8])
         result = (
             df.groupby([1, 2, 1, 2, 1, 2, 1, 2])
-            .rolling(window=window, min_periods=min_periods, closed=closed)
+            .rolling(window=window, min_periods=min_periods, inclusive=inclusive)
             .var(0)
         )
         expected_result = DataFrame(
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index 943ffc10f52c8..d0088e0c36a1d 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -170,19 +170,19 @@ def test_numpy_compat(method):
             getattr(r, method)(dtype=np.float64)
 
 
-@pytest.mark.parametrize("closed", ["right", "left", "both", "neither"])
-def test_closed_fixed(closed, arithmetic_win_operators):
+@pytest.mark.parametrize("inclusive", ["right", "left", "both", "neither"])
+def test_closed_fixed(inclusive, arithmetic_win_operators):
     # GH 34315
     func_name = arithmetic_win_operators
     df_fixed = DataFrame({"A": [0, 1, 2, 3, 4]})
     df_time = DataFrame({"A": [0, 1, 2, 3, 4]}, index=date_range("2020", periods=5))
 
     result = getattr(
-        df_fixed.rolling(2, closed=closed, min_periods=1),
+        df_fixed.rolling(2, inclusive=inclusive, min_periods=1),
         func_name,
     )()
     expected = getattr(
-        df_time.rolling("2D", closed=closed, min_periods=1),
+        df_time.rolling("2D", inclusive=inclusive, min_periods=1),
         func_name,
     )().reset_index(drop=True)
 
@@ -190,7 +190,7 @@ def test_closed_fixed(closed, arithmetic_win_operators):
 
 
 @pytest.mark.parametrize(
-    "closed, window_selections",
+    "inclusive, window_selections",
     [
         (
             "both",
@@ -235,7 +235,7 @@ def test_closed_fixed(closed, arithmetic_win_operators):
     ],
 )
 def test_datetimelike_centered_selections(
-    closed, window_selections, arithmetic_win_operators
+    inclusive, window_selections, arithmetic_win_operators
 ):
     # GH 34315
     func_name = arithmetic_win_operators
@@ -254,7 +254,7 @@ def test_datetimelike_centered_selections(
         kwargs = {}
 
     result = getattr(
-        df_time.rolling("2D", closed=closed, min_periods=1, center=True),
+        df_time.rolling("2D", inclusive=inclusive, min_periods=1, center=True),
         func_name,
     )(**kwargs)
 
@@ -262,7 +262,7 @@ def test_datetimelike_centered_selections(
 
 
 @pytest.mark.parametrize(
-    "window,closed,expected",
+    "window,inclusive,expected",
     [
         ("3s", "right", [3.0, 3.0, 3.0]),
         ("3s", "both", [3.0, 3.0, 3.0]),
@@ -275,7 +275,7 @@ def test_datetimelike_centered_selections(
     ],
 )
 def test_datetimelike_centered_offset_covers_all(
-    window, closed, expected, frame_or_series
+    window, inclusive, expected, frame_or_series
 ):
     # GH 42753
 
@@ -286,13 +286,13 @@ def test_datetimelike_centered_offset_covers_all(
     ]
     df = frame_or_series([1, 1, 1], index=index)
 
-    result = df.rolling(window, closed=closed, center=True).sum()
+    result = df.rolling(window, inclusive=inclusive, center=True).sum()
     expected = frame_or_series(expected, index=index)
     tm.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize(
-    "window,closed,expected",
+    "window,inclusive,expected",
     [
         ("2D", "right", [4, 4, 4, 4, 4, 4, 2, 2]),
         ("2D", "left", [2, 2, 4, 4, 4, 4, 4, 4]),
@@ -301,7 +301,7 @@ def test_datetimelike_centered_offset_covers_all(
     ],
 )
 def test_datetimelike_nonunique_index_centering(
-    window, closed, expected, frame_or_series
+    window, inclusive, expected, frame_or_series
 ):
     index = DatetimeIndex(
         [
@@ -319,7 +319,7 @@ def test_datetimelike_nonunique_index_centering(
     df = frame_or_series([1] * 8, index=index, dtype=float)
     expected = frame_or_series(expected, index=index, dtype=float)
 
-    result = df.rolling(window, center=True, closed=closed).sum()
+    result = df.rolling(window, center=True, inclusive=inclusive).sum()
 
     tm.assert_equal(result, expected)
 
@@ -358,18 +358,18 @@ def test_closed_fixed_binary_col(center, step):
     )[::step]
 
     rolling = df.rolling(
-        window=len(df), closed="left", min_periods=1, center=center, step=step
+        window=len(df), inclusive="left", min_periods=1, center=center, step=step
     )
     result = rolling.mean()
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.parametrize("closed", ["neither", "left"])
-def test_closed_empty(closed, arithmetic_win_operators):
+@pytest.mark.parametrize("inclusive", ["neither", "left"])
+def test_closed_empty(inclusive, arithmetic_win_operators):
     # GH 26005
     func_name = arithmetic_win_operators
     ser = Series(data=np.arange(5), index=date_range("2000", periods=5, freq="2D"))
-    roll = ser.rolling("1D", closed=closed)
+    roll = ser.rolling("1D", inclusive=inclusive)
 
     result = getattr(roll, func_name)()
     expected = Series([np.nan] * 5, index=ser.index)
@@ -380,7 +380,7 @@ def test_closed_empty(closed, arithmetic_win_operators):
 def test_closed_one_entry(func):
     # GH24718
     ser = Series(data=[2], index=date_range("2000", periods=1))
-    result = getattr(ser.rolling("10D", closed="left"), func)()
+    result = getattr(ser.rolling("10D", inclusive="left"), func)()
     tm.assert_series_equal(result, Series([np.nan], index=ser.index))
 
 
@@ -392,7 +392,7 @@ def test_closed_one_entry_groupby(func):
         index=date_range("2000", periods=3),
     )
     result = getattr(
-        ser.groupby("A", sort=False)["B"].rolling("10D", closed="left"), func
+        ser.groupby("A", sort=False)["B"].rolling("10D", inclusive="left"), func
     )()
     exp_idx = MultiIndex.from_arrays(arrays=[[1, 1, 2], ser.index], names=("A", None))
     expected = Series(data=[np.nan, 3, np.nan], index=exp_idx, name="B")
@@ -401,7 +401,7 @@ def test_closed_one_entry_groupby(func):
 
 @pytest.mark.parametrize("input_dtype", ["int", "float"])
 @pytest.mark.parametrize(
-    "func,closed,expected",
+    "func,inclusive,expected",
     [
         ("min", "right", [0.0, 0, 0, 1, 2, 3, 4, 5, 6, 7]),
         ("min", "both", [0.0, 0, 0, 0, 1, 2, 3, 4, 5, 6]),
@@ -413,14 +413,14 @@ def test_closed_one_entry_groupby(func):
         ("max", "left", [np.nan, 0, 1, 2, 3, 4, 5, 6, 7, 8]),
     ],
 )
-def test_closed_min_max_datetime(input_dtype, func, closed, expected):
+def test_closed_min_max_datetime(input_dtype, func, inclusive, expected):
     # see gh-21704
     ser = Series(
         data=np.arange(10).astype(input_dtype),
         index=date_range("2000", periods=10),
     )
 
-    result = getattr(ser.rolling("3D", closed=closed), func)()
+    result = getattr(ser.rolling("3D", inclusive=inclusive), func)()
     expected = Series(expected, index=ser.index)
     tm.assert_series_equal(result, expected)
 
@@ -431,13 +431,13 @@ def test_closed_uneven():
 
     # uneven
     ser = ser.drop(index=ser.index[[1, 5]])
-    result = ser.rolling("3D", closed="left").min()
+    result = ser.rolling("3D", inclusive="left").min()
     expected = Series([np.nan, 0, 0, 2, 3, 4, 6, 6], index=ser.index)
     tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize(
-    "func,closed,expected",
+    "func,inclusive,expected",
     [
         ("min", "right", [np.nan, 0, 0, 1, 2, 3, 4, 5, np.nan, np.nan]),
         ("min", "both", [np.nan, 0, 0, 0, 1, 2, 3, 4, 5, np.nan]),
@@ -449,17 +449,17 @@ def test_closed_uneven():
         ("max", "left", [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 6, np.nan]),
     ],
 )
-def test_closed_min_max_minp(func, closed, expected):
+def test_closed_min_max_minp(func, inclusive, expected):
     # see gh-21704
     ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
     ser[ser.index[-3:]] = np.nan
-    result = getattr(ser.rolling("3D", min_periods=2, closed=closed), func)()
+    result = getattr(ser.rolling("3D", min_periods=2, inclusive=inclusive), func)()
     expected = Series(expected, index=ser.index)
     tm.assert_series_equal(result, expected)
 
 
 @pytest.mark.parametrize(
-    "closed,expected",
+    "inclusive,expected",
     [
         ("right", [0, 0.5, 1, 2, 3, 4, 5, 6, 7, 8]),
         ("both", [0, 0.5, 1, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]),
@@ -467,10 +467,10 @@ def test_closed_min_max_minp(func, closed, expected):
         ("left", [np.nan, 0, 0.5, 1, 2, 3, 4, 5, 6, 7]),
     ],
 )
-def test_closed_median_quantile(closed, expected):
+def test_closed_median_quantile(inclusive, expected):
     # GH 26005
     ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
-    roll = ser.rolling("3D", closed=closed)
+    roll = ser.rolling("3D", inclusive=inclusive)
     expected = Series(expected, index=ser.index)
 
     result = roll.median()
@@ -1018,7 +1018,7 @@ def test_rolling_numerical_accuracy_kahan_mean(add):
         ],
     )
     result = (
-        df.resample("1s").ffill().rolling("3s", closed="left", min_periods=3).mean()
+        df.resample("1s").ffill().rolling("3s", inclusive="left", min_periods=3).mean()
     )
     dates = date_range("19700101 09:00:00", periods=7, freq="S")
     expected = DataFrame(
@@ -1176,7 +1176,7 @@ def test_rolling_on_df_transposed():
 def test_rolling_period_index(index, window, func, values):
     # GH: 34225
     ds = Series([0, 1, 2, 3, 4, 5, 6, 7, 8], index=index)
-    result = getattr(ds.rolling(window, closed="left"), func)()
+    result = getattr(ds.rolling(window, inclusive="left"), func)()
     expected = Series(values, index=index)
     tm.assert_series_equal(result, expected)
 
@@ -1290,7 +1290,7 @@ def test_rolling_decreasing_indices(method):
 
 
 @pytest.mark.parametrize(
-    "window,closed,expected",
+    "window,inclusive,expected",
     [
         ("2s", "right", [1.0, 3.0, 5.0, 3.0]),
         ("2s", "left", [0.0, 1.0, 3.0, 5.0]),
@@ -1302,7 +1302,9 @@ def test_rolling_decreasing_indices(method):
         ("3s", "neither", [1.0, 3.0, 6.0, 5.0]),
     ],
 )
-def test_rolling_decreasing_indices_centered(window, closed, expected, frame_or_series):
+def test_rolling_decreasing_indices_centered(
+    window, inclusive, expected, frame_or_series
+):
     """
     Ensure that a symmetrical inverted index return same result as non-inverted.
     """
@@ -1315,8 +1317,8 @@ def test_rolling_decreasing_indices_centered(window, closed, expected, frame_or_
     expected_inc = frame_or_series(expected, index=index)
     expected_dec = frame_or_series(expected, index=index[::-1])
 
-    result_inc = df_inc.rolling(window, closed=closed, center=True).sum()
-    result_dec = df_dec.rolling(window, closed=closed, center=True).sum()
+    result_inc = df_inc.rolling(window, inclusive=inclusive, center=True).sum()
+    result_dec = df_dec.rolling(window, inclusive=inclusive, center=True).sum()
 
     tm.assert_equal(result_inc, expected_inc)
     tm.assert_equal(result_dec, expected_dec)
@@ -1335,7 +1337,7 @@ def test_rolling_center_nanosecond_resolution(
     index = date_range("2020", periods=4, freq="1ns")
     df = frame_or_series([1, 1, 1, 1], index=index, dtype=float)
     expected = frame_or_series(expected, index=index, dtype=float)
-    result = df.rolling(window, closed=closed, center=True).sum()
+    result = df.rolling(window, inclusive=closed, center=True).sum()
     tm.assert_equal(result, expected)
 
 
@@ -1405,7 +1407,7 @@ def test_rolling_non_monotonic(method, expected):
     df = DataFrame({"values": np.arange(len(use_expanding)) ** 2})
 
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+        def get_window_bounds(self, num_values, min_periods, center, inclusive, step):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
             for i in range(num_values):
@@ -1500,11 +1502,11 @@ def test_rolling_descending_date_order_with_offset(window, frame_or_series):
     # GH#40002
     idx = date_range(start="2020-01-01", end="2020-01-03", freq="1d")
     obj = frame_or_series(range(1, 4), index=idx)
-    result = obj.rolling("1d", closed="left").sum()
+    result = obj.rolling("1d", inclusive="left").sum()
     expected = frame_or_series([np.nan, 1, 2], index=idx)
     tm.assert_equal(result, expected)
 
-    result = obj.iloc[::-1].rolling("1d", closed="left").sum()
+    result = obj.iloc[::-1].rolling("1d", inclusive="left").sum()
     idx = date_range(start="2020-01-03", end="2020-01-01", freq="-1d")
     expected = frame_or_series([np.nan, 3, 2], index=idx)
     tm.assert_equal(result, expected)
diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py
index 907c654570273..aae24a975e063 100644
--- a/pandas/tests/window/test_timeseries_window.py
+++ b/pandas/tests/window/test_timeseries_window.py
@@ -273,14 +273,14 @@ def test_closed(self, regular):
             ],
         )
 
-        # closed must be 'right', 'left', 'both', 'neither'
-        msg = "closed must be 'right', 'left', 'both' or 'neither'"
+        # inclusive must be 'right', 'left', 'both', 'neither'
+        msg = "inclusive must be 'right', 'left', 'both' or 'neither'"
         with pytest.raises(ValueError, match=msg):
-            regular.rolling(window="2s", closed="blabla")
+            regular.rolling(window="2s", inclusive="blabla")
 
         expected = df.copy()
         expected["A"] = [1.0, 2, 2, 2, 1]
-        result = df.rolling("2s", closed="right").sum()
+        result = df.rolling("2s", inclusive="right").sum()
         tm.assert_frame_equal(result, expected)
 
         # default should be 'right'
@@ -289,17 +289,17 @@ def test_closed(self, regular):
 
         expected = df.copy()
         expected["A"] = [1.0, 2, 3, 3, 2]
-        result = df.rolling("2s", closed="both").sum()
+        result = df.rolling("2s", inclusive="both").sum()
         tm.assert_frame_equal(result, expected)
 
         expected = df.copy()
         expected["A"] = [np.nan, 1.0, 2, 2, 1]
-        result = df.rolling("2s", closed="left").sum()
+        result = df.rolling("2s", inclusive="left").sum()
         tm.assert_frame_equal(result, expected)
 
         expected = df.copy()
         expected["A"] = [np.nan, 1.0, 1, 1, np.nan]
-        result = df.rolling("2s", closed="neither").sum()
+        result = df.rolling("2s", inclusive="neither").sum()
         tm.assert_frame_equal(result, expected)
 
     def test_ragged_sum(self, ragged):
diff --git a/pandas/tests/window/test_win_type.py b/pandas/tests/window/test_win_type.py
index ba80ac19a6b6a..577d8bc71e8a5 100644
--- a/pandas/tests/window/test_win_type.py
+++ b/pandas/tests/window/test_win_type.py
@@ -177,7 +177,7 @@ def test_win_type_freq_return_deprecation():
 @td.skip_if_no_scipy
 def test_win_type_not_implemented():
     class CustomIndexer(BaseIndexer):
-        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+        def get_window_bounds(self, num_values, min_periods, center, inclusive, step):
             return np.array([0, 1]), np.array([1, 2])
 
     df = DataFrame({"values": range(2)})