BOOST_STACKTRACE_DEFAULT_MAX_DEPTH

namespace boost {
  namespace stacktrace {
    template<std::size_t Depth> class basic_stacktrace;

    typedef basic_stacktrace< BOOST_STACKTRACE_DEFAULT_MAX_DEPTH > stacktrace;

    // Comparison operators that provide platform dependant ordering and have amortized O(1) complexity; O(size()) worst case complexity; are Async-Handler-Safe. 
    template<std::size_t Depth> 
      bool operator>(const basic_stacktrace< Depth > & lhs, 
                     const basic_stacktrace< Depth > & rhs);
    template<std::size_t Depth> 
      bool operator<=(const basic_stacktrace< Depth > & lhs, 
                      const basic_stacktrace< Depth > & rhs);
    template<std::size_t Depth> 
      bool operator>=(const basic_stacktrace< Depth > & lhs, 
                      const basic_stacktrace< Depth > & rhs);
    template<std::size_t Depth> 
      bool operator!=(const basic_stacktrace< Depth > & lhs, 
                      const basic_stacktrace< Depth > & rhs);

    // Hashing support, O(1) complexity; Async-Handler-Safe. 
    template<std::size_t Depth> 
      std::size_t hash_value(const basic_stacktrace< Depth > & st);

    // Outputs stacktrace in a human readable format to output stream; unsafe to use in async handlers. 
    template<typename CharT, typename TraitsT, std::size_t Depth> 
      std::basic_ostream< CharT, TraitsT > & 
      operator<<(std::basic_ostream< CharT, TraitsT > & os, 
                 const basic_stacktrace< Depth > & bt);
  }
}

namespace boost {
  namespace stacktrace {
    class const_iterator;
  }
}

namespace boost {
  namespace stacktrace {
    class frame;

    // Comparison operators that provide platform dependant ordering and have O(1) complexity; are Async-Handler-Safe. 
    bool operator<(const frame & lhs, const frame & rhs);
    bool operator>(const frame & lhs, const frame & rhs);
    bool operator<=(const frame & lhs, const frame & rhs);
    bool operator>=(const frame & lhs, const frame & rhs);
    bool operator==(const frame & lhs, const frame & rhs);
    bool operator!=(const frame & lhs, const frame & rhs);

    // Hashing support, O(1) complexity; Async-Handler-Safe. 
    std::size_t hash_value(const frame & f);

    // Outputs stacktrace::frame in a human readable format to output stream; unsafe to use in async handlers. 
    template<typename CharT, typename TraitsT> 
      std::basic_ostream< CharT, TraitsT > & 
      operator<<(std::basic_ostream< CharT, TraitsT > & os, const frame & f);
  }
}

This header contains only forward declarations of boost::stacktrace::frame, boost::stacktrace::const_iterator, boost::stacktrace::basic_stacktrace and does not include any other headers.