docs: 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