namespace boost {
  namespace program_options {
    namespace command_line_style {
      enum style_t;
    }
  }
}

BOOST_PROGRAM_OPTIONS_DECL

namespace boost {
  class environment_iterator;
}

namespace boost {
  template<typename Derived, typename ValueType> class eof_iterator;
}

namespace boost {
  namespace program_options {
    class ambiguous_option;
    class error;
    class error_with_no_option_name;
    class error_with_option_name;
    class invalid_bool_value;
    class invalid_command_line_style;
    class invalid_command_line_syntax;
    class invalid_config_file_syntax;
    class invalid_option_value;
    class invalid_syntax;
    class multiple_occurrences;
    class multiple_values;
    class reading_file;
    class required_option;
    class too_many_positional_options_error;
    class unknown_option;
    class validation_error;
    std::string strip_prefixes(const std::string & text);
  }
}

namespace boost {
  namespace program_options {
    template<typename charT> class basic_option;

    typedef basic_option< char > option;
    typedef basic_option< wchar_t > woption;
  }
}

namespace boost {
  namespace program_options {
    class duplicate_option_error;
    class option_description;
    class options_description;
    class options_description_easy_init;
  }
}

namespace boost {
  namespace program_options {
    template<typename charT> class basic_command_line_parser;

    template<> class basic_parsed_options<wchar_t>;

    enum collect_unrecognized_mode;

    typedef basic_parsed_options< char > parsed_options;
    typedef basic_parsed_options< wchar_t > wparsed_options;
    typedef function1< std::pair< std::string, std::string >, const std::string & > ext_parser;
    typedef basic_command_line_parser< char > command_line_parser;
    typedef basic_command_line_parser< wchar_t > wcommand_line_parser;
    template<typename charT> 
      basic_parsed_options< charT > 
      parse_command_line(int, const charT *const, const options_description &, 
                         int = 0, 
                         function1< std::pair< std::string, std::string >, const std::string & > = ext_parser());
    template<typename charT> 
      BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options< charT > 
      parse_config_file(std::basic_istream< charT > &, 
                        const options_description &, bool = false);
    template<typename charT = char> 
      BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options< charT > 
      parse_config_file(const char *, const options_description &, 
                        bool = false);
    template<typename charT> 
      std::vector< std::basic_string< charT > > 
      collect_unrecognized(const std::vector< basic_option< charT > > &, 
                           enum collect_unrecognized_mode);
    BOOST_PROGRAM_OPTIONS_DECL parsed_options 
    parse_environment(const options_description &, 
                      const function1< std::string, std::string > &);
    BOOST_PROGRAM_OPTIONS_DECL parsed_options 
    parse_environment(const options_description &, const std::string &);
    BOOST_PROGRAM_OPTIONS_DECL parsed_options 
    parse_environment(const options_description &, const char *);
    BOOST_PROGRAM_OPTIONS_DECL std::vector< std::string > 
    split_unix(const std::string &, const std::string & = " \t", 
               const std::string & = "'\"", const std::string & = "\\");
    BOOST_PROGRAM_OPTIONS_DECL std::vector< std::wstring > 
    split_unix(const std::wstring &, const std::wstring & = L" \t", 
               const std::wstring & = L"'\"", const std::wstring & = L"\\");
  }
}

namespace boost {
  namespace program_options {
    class positional_options_description;
  }
}

namespace boost {
  namespace program_options {
    template<typename T, typename charT = char> class typed_value;
    class typed_value_base;
    class untyped_value;
    class value_semantic;
    template<typename charT> class value_semantic_codecvt_helper;

    template<> class value_semantic_codecvt_helper<char>;
    template<> class value_semantic_codecvt_helper<wchar_t>;
    template<typename T> typed_value< T > * value();
    template<typename T> typed_value< T > * value(T *);
    template<typename T> typed_value< T, wchar_t > * wvalue();
    template<typename T> typed_value< T, wchar_t > * wvalue(T *);
    BOOST_PROGRAM_OPTIONS_DECL typed_value< bool > * bool_switch();
    BOOST_PROGRAM_OPTIONS_DECL typed_value< bool > * bool_switch(bool *);
  }
}

namespace boost {
  namespace program_options {
    class abstract_variables_map;
    template<typename charT> class basic_parsed_options;
    class variable_value;
    class variables_map;
    BOOST_PROGRAM_OPTIONS_DECL void 
    store(const basic_parsed_options< char > &, variables_map &, bool = false);
    BOOST_PROGRAM_OPTIONS_DECL void 
    store(const basic_parsed_options< wchar_t > &, variables_map &);
    BOOST_PROGRAM_OPTIONS_DECL void notify(variables_map &);
  }
}

BOOST_PROGRAM_OPTIONS_VERSION
BOOST_PROGRAM_OPTIONS_IMPLICIT_VALUE_NEXT_TOKEN