BOOST_PARSER_DEFINE_RULES(...)

namespace boost {
  namespace parser {
    template<typename Parser, typename Action> struct action_parser;
    template<typename Attribute> struct attr_parser;
    struct bool_parser;
    template<typename TagType, typename Attribute, typename LocalState, 
             typename ParamsTuple> 
      struct callback_rule;
    template<typename Expected, typename AttributeType> struct char_parser;
    template<typename Tag> struct char_set_parser;
    template<typename Tag> struct char_subrange_parser;
    template<typename Parser, typename DelimiterParser> 
      struct delimited_seq_parser;
    struct digit_parser;
    template<template< class > class Parser> struct directive;
    struct eoi_parser;
    template<typename Predicate> struct eps_parser;
    template<typename Parser, bool FailOnMatch> struct expect_parser;
    template<typename T> struct float_parser;
    template<typename Predicate> struct if_directive;
    template<typename T, int Radix, int MinDigits, int MaxDigits, 
             typename Expected> 
      struct int_parser;
    template<typename Parser> struct lexeme_parser;
    struct merge_directive;
    template<typename Parser> struct no_case_parser;
    struct none;
    template<typename Parser> struct omit_parser;
    template<typename Parser> struct one_plus_parser;
    template<typename Parser> struct opt_parser;
    template<typename ParserTuple> struct or_parser;
    template<typename Parser, typename GlobalState, typename ErrorHandler> 
      struct parser_interface;
    template<typename Parser> struct raw_parser;
    template<typename MinType, typename MaxType> struct repeat_directive;
    template<typename Parser, typename DelimiterParser, typename MinType, 
             typename MaxType> 
      struct repeat_parser;
    template<typename TagType, typename Attribute, typename LocalState, 
             typename ParamsTuple> 
      struct rule;
    template<bool CanUseCallbacks, typename TagType, typename Attribute, 
             typename LocalState, typename ParamsTuple> 
      struct rule_parser;
    struct separate_directive;
    template<typename ParserTuple, typename BacktrackingTuple, 
             typename CombiningGroups> 
      struct seq_parser;
    template<typename SkipParser = detail::nope> struct skip_directive;
    template<typename Parser, typename SkipParser> struct skip_parser;
    template<typename StrIter, typename StrSentinel> struct string_parser;
    template<typename Parser> struct string_view_parser;
    template<typename SwitchValue, typename OrParser> struct switch_parser;
    template<typename T> struct symbol_parser;
    template<typename T> struct symbols;
    template<typename T, int Radix, int MinDigits, int MaxDigits, 
             typename Expected> 
      struct uint_parser;
    template<bool NewlinesOnly, bool NoNewlines> struct ws_parser;
    template<typename Parser> struct zero_plus_parser;

    enum trace;

    constexpr bool container;
    unspecified _p;
    int64_t const Inf;
    constexpr directive< omit_parser > omit;
    constexpr directive< raw_parser > raw;
    constexpr directive< string_view_parser > string_view;
    constexpr directive< lexeme_parser > lexeme;
    constexpr directive< no_case_parser > no_case;
    constexpr skip_directive skip;
    constexpr merge_directive merge;
    constexpr separate_directive separate;
    unspecified eps;
    constexpr parser_interface< eoi_parser > eoi;
    unspecified char_;
    unspecified cp;
    unspecified cu;
    constexpr parser_interface< ws_parser< true, false > > eol;
    constexpr parser_interface< ws_parser< false, false > > ws;
    constexpr parser_interface< ws_parser< false, true > > blank;
    constexpr parser_interface< digit_parser > digit;
    unspecified hex_digit;
    unspecified control;
    unspecified punct;
    unspecified lower;
    unspecified upper;
    constexpr parser_interface< bool_parser > bool_;
    constexpr parser_interface< uint_parser< unsigned int, 2 > > bin;
    constexpr parser_interface< uint_parser< unsigned int, 8 > > oct;
    constexpr parser_interface< uint_parser< unsigned int, 16 > > hex;
    constexpr parser_interface< uint_parser< unsigned short > > ushort_;
    constexpr parser_interface< uint_parser< unsigned int > > uint_;
    constexpr parser_interface< uint_parser< unsigned long > > ulong_;
    constexpr parser_interface< uint_parser< unsigned long long > > ulong_long;
    constexpr parser_interface< int_parser< short > > short_;
    constexpr parser_interface< int_parser< int > > int_;
    constexpr parser_interface< int_parser< long > > long_;
    constexpr parser_interface< int_parser< long long > > long_long;
    constexpr parser_interface< float_parser< float > > float_;
    constexpr parser_interface< float_parser< double > > double_;
    template<typename Context> decltype(auto) _val(Context const &);
    template<typename Context> decltype(auto) _attr(Context const &);
    template<typename Context> decltype(auto) _where(Context const &);
    template<typename Context> decltype(auto) _begin(Context const &);
    template<typename Context> decltype(auto) _end(Context const &);
    template<typename Context> decltype(auto) _pass(Context const &);
    template<typename Context> decltype(auto) _locals(Context const &);
    template<typename Context> decltype(auto) _params(Context const &);
    template<typename Context> decltype(auto) _globals(Context const &);
    template<typename Context> decltype(auto) _error_handler(Context const &);
    template<typename Context> 
      void _report_error(Context const &, std::string_view);
    template<typename Context> 
      void _report_warning(Context const &, std::string_view);
    template<typename Context> 
      decltype(auto) _no_case(Context const & context);
    template<typename I, typename Context> 
      void _report_error(Context const & context, std::string_view message, 
                         I location);
    template<typename I, typename Context> 
      void _report_warning(Context const & context, std::string_view message, 
                           I location);
    template<typename Parser, typename GlobalState, typename ErrorHandler> 
      auto with_globals(unspecified, GlobalState &);
    template<typename Parser, typename GlobalState, typename ErrorHandler> 
      auto with_error_handler(parser_interface< Parser, GlobalState, default_error_handler > const &, 
                              ErrorHandler &);
    template<typename T> constexpr repeat_directive< T, T > repeat(T);
    template<typename MinType, typename MaxType> 
      constexpr repeat_directive< MinType, MaxType > repeat(MinType, MaxType);
    template<typename Attribute> constexpr auto attr(Attribute);
    constexpr auto lit(char);
    constexpr auto lit(char8_t);
    constexpr auto lit(char32_t);
    template<typename R>  string_parser(R r);
    template<typename R> constexpr auto string(R &&);
    template<typename R> constexpr auto lit(R &&);
    template<typename Predicate> constexpr auto if_(Predicate);
    template<typename T> constexpr auto switch_(T);
    template<typename Parser> 
      constexpr auto operator>>(char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator>>(char32_t, parser_interface< Parser >);
    template<typename R, typename Parser, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      constexpr auto operator>>(R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator>(char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator>(char32_t, parser_interface< Parser >);
    template<typename R, typename Parser, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      constexpr auto operator>(R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator|(char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator|(char32_t, parser_interface< Parser >);
    template<typename R, typename Parser, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      constexpr auto operator|(R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator-(char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator-(char32_t, parser_interface< Parser >);
    template<typename R, typename Parser, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      constexpr auto operator-(R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator%(char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr auto operator%(char32_t, parser_interface< Parser >);
    template<typename R, typename Parser, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      constexpr auto operator%(R &&, parser_interface< Parser >);
    template<typename I, typename S, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename Attr, 
             typename Enable = std::enable_if_t<            detail::is_parsable_iter_v<I> &&            detail::is_equality_comparable_with_v<I, S>> > 
      bool prefix_parse(I &, S, 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                        Attr &, trace = trace::off);
    template<typename R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename Attr, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      bool parse(R const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                 Attr &, trace = trace::off);
    template<typename I, typename S, typename Parser, typename GlobalState, 
             typename ErrorHandler, 
             typename Enable = std::enable_if_t<            detail::is_parsable_iter_v<I> &&            detail::is_equality_comparable_with_v<I, S>> > 
      auto prefix_parse(I &, S, 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                        trace = trace::off);
    template<typename R, typename Parser, typename GlobalState, 
             typename ErrorHandler, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      auto parse(R const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                 trace = trace::off);
    template<typename I, typename S, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, typename Attr, 
             typename Enable = std::enable_if_t<            detail::is_parsable_iter_v<I> &&            detail::is_equality_comparable_with_v<I, S>> > 
      bool prefix_parse(I &, S, 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                        parser_interface< SkipParser > const &, Attr &, 
                        trace = trace::off);
    template<typename R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, typename Attr, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      bool parse(R const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                 parser_interface< SkipParser > const &, Attr &, 
                 trace = trace::off);
    template<typename I, typename S, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, 
             typename Enable = std::enable_if_t<            detail::is_parsable_iter_v<I> &&            detail::is_equality_comparable_with_v<I, S>> > 
      auto prefix_parse(I &, S, 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                        parser_interface< SkipParser > const &, 
                        trace = trace::off);
    template<typename R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      auto parse(R const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                 parser_interface< SkipParser > const &, trace = trace::off);
    template<typename I, typename S, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename Callbacks, 
             typename Enable = std::enable_if_t<            detail::is_parsable_iter_v<I> &&            detail::is_equality_comparable_with_v<I, S>> > 
      bool callback_prefix_parse(I &, S, 
                                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                                 Callbacks const &, trace = trace::off);
    template<typename R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename Callbacks, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      bool callback_parse(R const &, 
                          parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                          Callbacks const &, trace = trace::off);
    template<typename I, typename S, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, typename Callbacks, 
             typename Enable = std::enable_if_t<            detail::is_parsable_iter_v<I> &&            detail::is_equality_comparable_with_v<I, S>> > 
      bool callback_prefix_parse(I &, S, 
                                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                                 parser_interface< SkipParser > const &, 
                                 Callbacks const &, trace = trace::off);
    template<typename R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, typename Callbacks, 
             typename Enable = std::enable_if_t<detail::is_parsable_range_like_v<R>> > 
      bool callback_parse(R const &, 
                          parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                          parser_interface< SkipParser > const &, 
                          Callbacks const &, trace = trace::off);
    namespace literals {
      constexpr auto operator""_l(char);
      constexpr auto operator""_l(char8_t);
      constexpr auto operator""_l(char32_t);
      constexpr auto operator""_l(char const *, std::size_t);
      constexpr auto operator""_l(char8_t const *, std::size_t);
      constexpr auto operator""_l(char32_t const *, std::size_t);
      constexpr auto operator""_p(char);
      constexpr auto operator""_p(char8_t);
      constexpr auto operator""_p(char32_t);
      constexpr auto operator""_p(char const *, std::size_t);
      constexpr auto operator""_p(char8_t const *, std::size_t);
      constexpr auto operator""_p(char32_t const *, std::size_t);
    }
  }
}