namespace boost {
  namespace property_tree {
    class ptree_error;
    class ptree_bad_data;
    class ptree_bad_path;
  }
}

namespace boost {
  namespace property_tree {
    template<typename T> struct translator_between<T, T>;
    template<typename Ch, typename Traits, typename Alloc> 
      struct translator_between<std::basic_string< Ch, Traits, Alloc >, std::basic_string< Ch, Traits, Alloc >>;
  }
}

namespace boost {
  namespace property_tree {
    namespace info_parser {
      template<typename Ptree, typename Ch> 
        void read_info(std::basic_istream< Ch > &, Ptree &);
      template<typename Ptree, typename Ch> 
        void read_info(std::basic_istream< Ch > &, Ptree &, const Ptree &);
      template<typename Ptree> 
        void read_info(const std::string &, Ptree &, 
                       const std::locale & = std::locale());
      template<typename Ptree> 
        void read_info(const std::string &, Ptree &, const Ptree &, 
                       const std::locale & = std::locale());
      template<typename Ptree, typename Ch> 
        void write_info(std::basic_ostream< Ch > &, const Ptree &, 
                        const info_writer_settings< Ch > & = info_writer_settings< Ch >());
      template<typename Ptree> 
        void write_info(const std::string &, const Ptree &, 
                        const std::locale & = std::locale(), 
                        const info_writer_settings< typename Ptree::key_type::value_type > & = info_writer_make_settings< typename Ptree::key_type::value_type >());
    }
  }
}

namespace boost {
  namespace property_tree {
    namespace ini_parser {
      class ini_parser_error;
      bool validate_flags(int);
      template<typename Ptree> 
        void read_ini(std::basic_istream< typename Ptree::key_type::value_type > &, 
                      Ptree &);
      template<typename Ptree> 
        void read_ini(const std::string &, Ptree &, 
                      const std::locale & = std::locale());
      template<typename Ptree> 
        void write_ini(std::basic_ostream< typename Ptree::key_type::value_type > &, 
                       const Ptree &, int = 0);
      template<typename Ptree> 
        void write_ini(const std::string &, const Ptree &, int = 0, 
                       const std::locale & = std::locale());
    }
  }
}

namespace boost {
  namespace property_tree {
    namespace json_parser {
      template<typename Ptree> 
        void read_json(std::basic_istream< typename Ptree::key_type::value_type > &, 
                       Ptree &);
      template<typename Ptree> 
        void read_json(const std::string &, Ptree &, 
                       const std::locale & = std::locale());
      template<typename Ptree> 
        void write_json(std::basic_ostream< typename Ptree::key_type::value_type > &, 
                        const Ptree &, bool = true);
      template<typename Ptree> 
        void write_json(const std::string &, const Ptree &, 
                        const std::locale & = std::locale(), bool = true);
    }
  }
}

namespace boost {
  namespace property_tree {
    template<typename Key, typename Data, 
             typename KeyCompare = std::less<Key> > 
      class basic_ptree;

    template<typename T> struct id_translator;
    template<typename Key> struct path_of;
    template<typename Internal, typename External> struct translator_between;
    typedef string_path< std::string, id_translator< std::string > > path;
    typedef basic_ptree< std::string, std::string > ptree;
    typedef unspecified iptree;
    typedef string_path< std::wstring, id_translator< std::wstring > > wpath;
    typedef basic_ptree< std::wstring, std::wstring > wptree;
    typedef unspecified wiptree;
    template<typename K, typename D, typename C> 
      void swap(basic_ptree< K, D, C > &, basic_ptree< K, D, C > &);
  }
}

namespace boost {
  namespace property_tree {
    template<typename Archive, typename K, typename D, typename C> 
      void save(Archive &, const basic_ptree< K, D, C > &, const unsigned int);
    template<typename Archive, typename K, typename D, typename C> 
      void load(Archive &, basic_ptree< K, D, C > &, const unsigned int);
    template<typename Archive, typename K, typename D, typename C> 
      void serialize(Archive &, basic_ptree< K, D, C > &, const unsigned int);
  }
}

namespace boost {
  namespace property_tree {
    template<typename Ch, typename Traits, typename E, 
             typename Enabler = void> 
      struct customize_stream;

    template<typename Ch, typename Traits> 
      struct customize_stream<Ch, Traits, Ch, void>;
    template<typename Ch, typename Traits, typename F> 
      struct customize_stream<Ch, Traits, F, typename boost::enable_if< detail::is_inexact< F > >::type>;
    template<typename Ch, typename Traits> 
      struct customize_stream<Ch, Traits, bool, void>;
    template<typename Ch, typename Traits> 
      struct customize_stream<Ch, Traits, signed char, void>;
    template<typename Ch, typename Traits> 
      struct customize_stream<Ch, Traits, unsigned char, void>;

    template<typename Ch, typename Traits, typename Alloc, typename E> 
      class stream_translator;

    template<typename Ch, typename Traits, typename Alloc, typename E> 
      struct translator_between<std::basic_string< Ch, Traits, Alloc >, E>;
  }
}

namespace boost {
  namespace property_tree {
    template<typename String, typename Translator> class string_path;

    template<typename Ch, typename Traits, typename Alloc> 
      struct path_of<std::basic_string< Ch, Traits, Alloc >>;
    template<typename String, typename Translator> 
      string_path< String, Translator > 
      operator/(string_path< String, Translator > p1, 
                const string_path< String, Translator > & p2);
    template<typename String, typename Translator> 
      string_path< String, Translator > 
      operator/(string_path< String, Translator > p1, 
                const typename String::value_type * p2);
    template<typename String, typename Translator> 
      string_path< String, Translator > 
      operator/(const typename String::value_type * p1, 
                const string_path< String, Translator > & p2);
  }
}

namespace boost {
  namespace property_tree {
    namespace xml_parser {
      template<typename Ptree> 
        void read_xml(std::basic_istream< typename Ptree::key_type::value_type > &, 
                      Ptree &, int = 0);
      template<typename Ptree> 
        void read_xml(const std::string &, Ptree &, int = 0, 
                      const std::locale & = std::locale());
      template<typename Ptree> 
        void write_xml(std::basic_ostream< typename Ptree::key_type::value_type > &, 
                       const Ptree &, 
                       const xml_writer_settings< typename Ptree::key_type > & = xml_writer_settings< typename Ptree::key_type >());
      template<typename Ptree> 
        void write_xml(const std::string &, const Ptree &, 
                       const std::locale & = std::locale(), 
                       const xml_writer_settings< typename Ptree::key_type > & = xml_writer_settings< typename Ptree::key_type >());
    }
  }
}