namespace boost {
  typedef unspecified char16;
  typedef unspecified char32;
}

namespace boost {
  namespace unicode {
    template<typename Range1, typename Range2> 
      tuple< sub_range< Range1 >, sub_range< Range1 >, sub_range< Range2 >, sub_range< Range2 > > 
      cat_limits(Range1 &&, Range2 &&);
    template<typename Range1, typename Range2, typename... T> 
      unspecified composed_concated(const Range1 &, const Range2 &, 
                                    const T &...);
    template<typename Range1, typename Range2, typename OutputIterator, 
             typename... T> 
      OutputIterator 
      composed_concat(const Range1 &, const Range2 &, OutputIterator, 
                      const T &...);
    template<typename Range1, typename Range2, typename... T> 
      unspecified decomposed_concated(const Range1 &, const Range2 &, 
                                      const T &...);
    template<typename Range1, typename Range2, typename OutputIterator, 
             typename... T> 
      OutputIterator 
      decomposed_concat(const Range1 &, const Range2 &, OutputIterator, 
                        const T &...);
  }
}

namespace boost {
  namespace unicode {
    struct combiner;
    struct combine_sorter;
    typedef mpl::int_< 31 > combining_max;
    template<typename Range> 
      iterator_range< consumer_iterator< typename range_iterator< Range >::type, combiner >> 
      combine_bounded(Range &&);
  }
}

namespace boost {
  namespace unicode {
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator compose(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified composed(Range &&, const T &...);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator decompose(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified decomposed(Range &&, const T &...);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator normalize(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified normalized(Range &&, const T &...);
  }
}

BOOST_UNICODE_OPTION(o)

namespace boost {
  namespace unicode {
    struct decomposer;
    struct composer;
    typedef unspecified normalizer;
  }
}

namespace boost {
  namespace unicode {
    struct grapheme_boundary;
    typedef multi_boundary< u16_boundary, u16_decoder, grapheme_boundary > u16_grapheme_boundary;
    typedef multi_boundary< u8_boundary, u8_decoder, grapheme_boundary > u8_grapheme_boundary;
    typedef multi_boundary< utf_boundary, utf_decoder, grapheme_boundary > utf_grapheme_boundary;
    template<typename Range> unspecified grapheme_bounded(Range &&);
    template<typename Range> unspecified u16_grapheme_bounded(Range &&);
    template<typename Range> unspecified u8_grapheme_bounded(Range &&);
    template<typename Range> unspecified utf_grapheme_bounded(Range &&);
  }
}

namespace boost {
  namespace unicode {
    struct hangul_decomposer;
    struct hangul_composer;
  }
}

BOOST_UNICODE_ONE_MANY_PIPE_DEF(name, n)
BOOST_UNICODE_PIPE_DEF(name, n)

namespace boost {
  namespace algorithm {
    template<typename F, typename B> struct boundary_finder;
    template<typename F, typename B> 
      boundary_finder< F, B > make_boundary_finder(F f, B b);
  }
  namespace unicode {
    template<typename Match, typename Comp = is_equal> struct simple_finder;
    template<typename F, typename B> struct boundary_finder;
    template<typename Match, typename Comp> 
      simple_finder< Match, Comp > 
      make_simple_finder(const Match & match, Comp comp = Comp());
    template<typename Match> 
      simple_finder< Match > make_simple_finder(const Match & match);
    template<typename F, typename B> 
      boundary_finder< F, B > make_boundary_finder(F f, B b);
  }
}

namespace boost {
  namespace unicode {
    template<typename Sequence> struct static_u8_encode;
    template<typename Sequence> struct static_u16_encode;
  }
}

namespace boost {
  namespace unicode {
    template<char32 I> struct static_u8_encoder;
    template<char32 I> struct static_u16_encoder;
  }
}

namespace boost {
  namespace unicode {
    template<char32 I> struct string_cp;
  }
}

namespace boost {
  namespace unicode {
    bool is_high_surrogate(char32 v);
    bool is_low_surrogate(char32 v);
    bool is_surrogate(char32 v);
  }
}

namespace boost {
  namespace unicode {
    namespace ucd {
      struct block;
      const char * as_string(block::type);
    }
  }
}

BOOST_UNICODE_UCD_VERSION
BOOST_UNICODE_UCD_VERSION_MAJOR
BOOST_UNICODE_UCD_VERSION_MINOR

namespace boost {
  namespace unicode {
    namespace ucd {
      category::type get_category(char32 ch);
      bidi_class::type get_bidi_class(char32 ch);
      line_break::type get_line_break(char32 ch);
      grapheme_cluster_break::type get_grapheme_cluster_break(char32 ch);
      word_break::type get_word_break(char32 ch);
      sentence_break::type get_sentence_break(char32 ch);
      decomposition_type::type get_decomposition_type(char32);
      bool is_unknown(char32 ch);
      int get_combining_class(char32);
      block::type get_block(char32);
      iterator_range< const char32 * > get_decomposition(char32);
    }
  }
}

namespace boost {
  namespace unicode {
    namespace ucd {
      struct category;
      struct join_type;
      struct bidi_class;
      struct line_break;
      struct decomposition_type;
      struct grapheme_cluster_break;
      struct word_break;
      struct sentence_break;
      const char * as_string(category::type);
      const char * as_string(join_type::type);
      const char * as_string(bidi_class::type);
      const char * as_string(line_break::type);
      const char * as_string(decomposition_type::type);
      const char * as_string(grapheme_cluster_break::type);
      const char * as_string(word_break::type);
      const char * as_string(sentence_break::type);
    }
  }
}

namespace boost {
  namespace unicode {
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u16_encode(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified u16_encoded(Range &&, const T &...);
    template<typename OutputIterator, typename... T> 
      unspecified u16_encoded_out(OutputIterator, const T &...);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u16_decode(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified u16_decoded(Range &&, const T &...);
    template<typename Range> unspecified u16_bounded(Range &&);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u8_encode(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified u8_encoded(Range &&, const T &...);
    template<typename OutputIterator, typename... T> 
      unspecified u8_encoded_out(OutputIterator, const T &...);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u8_decode(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified u8_decoded(Range &&, const T &...);
    template<typename Range> unspecified u8_bounded(Range &&);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator utf_decode(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified utf_decoded(Range &&, const T &...);
    template<typename Range> unspecified utf_bounded(Range &&);
    template<typename ValueType, typename Range, typename OutputIterator> 
      OutputIterator utf_encode(const Range & range, OutputIterator out);
    template<typename ValueType, typename Range> 
      unspecified utf_encoded(Range && range);
    template<typename ValueType, typename OutputIterator> 
      unspecified utf_encoded_out(OutputIterator out);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator 
      latin1_encode(const Range &, OutputIterator, const T &...);
    template<typename Range, typename... T> 
      unspecified latin1_encoded(Range &&, const T &...);
    template<typename OutputIterator, typename... T> 
      unspecified latin1_encoded_out(OutputIterator, const T &...);
  }
}

namespace boost {
  namespace unicode {
    struct u16_encoder;
    struct u16_decoder;
    struct u16_boundary;
    struct u8_encoder;
    struct u8_decoder;
    struct u8_boundary;
    template<typename ValueType> struct utf_encoder;
    struct utf_decoder;
    struct utf_boundary;
    typedef unspecified latin1_encoder;
  }
}