def sufficient_gaps(self,
                        every_n_days: int,
                        requiredgaps: List[datetime.timedelta],
                        flexibility: int = 2) \
            -> Tuple[bool, Optional[Interval]]:
        """
        Are gaps present sufficiently often?
        For example:

        .. code-block:: python

            every_n_days=21
            requiredgaps=[
                datetime.timedelta(hours=62),
                datetime.timedelta(hours=48),
            ]

        ... means "is there at least one 62-hour gap and one (separate) 48-hour
        gap in every possible 21-day sequence within the IntervalList?

        - If ``flexibility == 0``: gaps must be WHOLLY WITHIN the interval.

        - If ``flexibility == 1``: gaps may OVERLAP the edges of the interval.

        - If ``flexibility == 2``: gaps may ABUT the edges of the interval.

        Returns ``(True, None)`` or ``(False, first_failure_interval)``.
        """
        if len(self.intervals) < 2:
            return False, None
        startdate = self.start_date()
        enddate = self.end_date()
        ndays = (enddate - startdate).days + 1
        if ndays <= every_n_days:
            # Our interval is too short, or just right
            return self._sufficient_gaps(startdate, enddate, requiredgaps,
                                         flexibility)
        for i in range(ndays - every_n_days):
            j = i + every_n_days
            a = startdate + datetime.timedelta(days=i)
            b = startdate + datetime.timedelta(days=j)
            sufficient, ffi = self._sufficient_gaps(a, b, requiredgaps,
                                                    flexibility)
            if not sufficient:
                return False, ffi
        return True, None