namespace boost {
  namespace stl_interfaces {
    namespace v1 {
      enum element_layout;
      namespace v1_dtl {
        template<typename Range, typename  = void> struct decrementable_sentinel;

        template<typename Range> 
          struct decrementable_sentinel<Range, void_t< decltype(--std::declval< sentinel_t< Range > & >())>>;

        template<typename Range, typename  = void> struct iterator;

        template<typename Range> 
          struct iterator<Range, void_t< decltype(std::declval< Range & >().begin())>>;

        template<typename Range, typename  = void> struct sentinel;

        template<typename Range> 
          struct sentinel<Range, void_t< decltype(std::declval< Range & >().end())>>;

        typedef void void_t;
        typedef typename std::iterator_traits< Iter >::difference_type iter_difference_t;
        typedef typename iterator< Range >::type iterator_t;
        typedef typename sentinel< Range >::type sentinel_t;
        typedef iter_difference_t< iterator_t< Range > > range_difference_t;
        typedef std::is_same< iterator_t< Range >, sentinel_t< Range > > common_range;
      }
    }
  }
}

BOOST_STL_INTERFACES_STATIC_ASSERT_CONCEPT(type, concept_name)
BOOST_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(iter, category, concept, value_type, reference, pointer, difference_type)

namespace boost {
  namespace stl_interfaces {
    struct access;
    template<typename T> struct proxy_arrow_result;
    namespace v1 {
      template<typename Derived, typename IteratorConcept, typename ValueType, 
               typename Reference, typename Pointer, typename DifferenceType> 
        struct iterator_interface;
      typedef iterator_interface< Derived, IteratorConcept, ValueType, Reference, proxy_arrow_result< Reference >, DifferenceType > proxy_iterator_interface;
      template<typename IteratorInterface1, typename IteratorInterface2, 
               typename Enable = std::enable_if_t<!v1_dtl::ra_iter<IteratorInterface1>::value> > 
        constexpr auto operator==(IteratorInterface1, IteratorInterface2);
      template<typename IteratorInterface1, typename IteratorInterface2> 
        constexpr auto operator!=(IteratorInterface1, IteratorInterface2);
      template<typename IteratorInterface1, typename IteratorInterface2> 
        constexpr auto operator<(IteratorInterface1, IteratorInterface2);
      template<typename IteratorInterface1, typename IteratorInterface2> 
        constexpr auto operator<=(IteratorInterface1, IteratorInterface2);
      template<typename IteratorInterface1, typename IteratorInterface2> 
        constexpr auto operator>(IteratorInterface1, IteratorInterface2);
      template<typename IteratorInterface1, typename IteratorInterface2> 
        constexpr auto operator>=(IteratorInterface1, IteratorInterface2);
      namespace v1_dtl {
        template<typename Iterator, typename DifferenceType, typename  = void> 
          struct plus_eq;

        template<typename Iterator, typename DifferenceType> 
          struct plus_eq<Iterator, DifferenceType, void_t< decltype(std::declval< Iterator & >()+=std::declval< DifferenceType >())>>;

        template<typename Iterator, typename  = void> struct ra_iter;

        template<typename Iterator> 
          struct ra_iter<Iterator, void_t< typename Iterator::iterator_concept >>;
        template<typename D, typename IteratorConcept, typename ValueType, 
                 typename Reference, typename Pointer, 
                 typename DifferenceType> 
          void derived_iterator(iterator_interface< D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &);
      }
    }
  }
}

namespace boost {
  namespace stl_interfaces {
    namespace v1 {
      template<typename BidiIter> struct reverse_iterator;
      template<typename BidiIter> 
        constexpr auto 
        operator==(reverse_iterator< BidiIter > lhs, 
                   reverse_iterator< BidiIter > rhs);
      template<typename BidiIter1, typename BidiIter2> 
        constexpr auto 
        operator==(reverse_iterator< BidiIter1 > lhs, 
                   reverse_iterator< BidiIter2 > rhs);
      template<typename BidiIter> auto make_reverse_iterator(BidiIter);
      namespace v1_dtl {
        template<typename Iter> 
          constexpr auto 
          ce_dist(Iter f, Iter l, std::random_access_iterator_tag);
        template<typename Iter, typename Tag> 
          constexpr auto ce_dist(Iter f, Iter l, Tag);
        template<typename Iter> constexpr Iter ce_prev(Iter it);
        template<typename Iter, typename Offset> 
          constexpr void 
          ce_adv(Iter & f, Offset n, std::random_access_iterator_tag);
        template<typename Iter, typename Offset, typename Tag> 
          constexpr void ce_adv(Iter & f, Offset n, Tag);
      }
    }
    namespace v2 {
      typedef std::reverse_iterator< BidiIter > reverse_iterator;
      template<typename BidiIter> auto make_reverse_iterator(BidiIter);
    }
  }
}

namespace boost {
  namespace stl_interfaces {
    namespace v1 {
      template<typename Derived, element_layout Contiguity> 
        struct sequence_container_interface;
      template<typename ContainerInterface> 
        constexpr auto swap(ContainerInterface &, ContainerInterface &);
      template<typename ContainerInterface> 
        constexpr auto 
        operator==(ContainerInterface const &, ContainerInterface const &);
      template<typename ContainerInterface> 
        constexpr auto 
        operator!=(ContainerInterface const &, ContainerInterface const &);
      template<typename ContainerInterface> 
        constexpr auto 
        operator<(ContainerInterface const &, ContainerInterface const &);
      template<typename ContainerInterface> 
        constexpr auto 
        operator<=(ContainerInterface const &, ContainerInterface const &);
      template<typename ContainerInterface> 
        constexpr auto 
        operator>(ContainerInterface const &, ContainerInterface const &);
      template<typename ContainerInterface> 
        constexpr auto 
        operator>=(ContainerInterface const &, ContainerInterface const &);
      namespace v1_dtl {
        template<typename D, typename  = void> struct clear_impl;

        template<typename D> 
          struct clear_impl<D, void_t< decltype(std::declval< D >().clear())>>;

        typedef std::is_convertible< typename std::iterator_traits< Iter >::iterator_category, std::input_iterator_tag > in_iter;
        template<typename D, element_layout Contiguity> 
          void derived_container(sequence_container_interface< D, Contiguity > const &);
      }
    }
  }
}

namespace boost {
  namespace stl_interfaces {
    namespace v1 {
      template<typename Derived, element_layout Contiguity> struct view_interface;
      template<typename ViewInterface> 
        constexpr auto operator!=(ViewInterface, ViewInterface);
      namespace v1_dtl {
        template<typename D, element_layout Contiguity> 
          void derived_view(view_interface< D, Contiguity > const &);
      }
    }
    namespace v2 {
      typedef std::ranges::view_interface< D > view_interface;
    }
  }
}