sig
  module Camomile :
    sig
      module ISet :
        sig
          type t = (int * int) AvlTree.tree
          type elt = int
          val empty : t
          val is_empty : t -> bool
          val mem : int -> t -> bool
          val add : int -> t -> t
          val add_range : int -> int -> t -> t
          val singleton : int -> t
          val remove : int -> t -> t
          val remove_range : int -> int -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compl : t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val from : int -> t -> t
          val after : int -> t -> t
          val until : int -> t -> t
          val before : int -> t -> t
          val iter : (int -> unit) -> t -> unit
          val iter_range : (int -> int -> unit) -> t -> unit
          val fold : (int -> '-> 'a) -> t -> '-> 'a
          val fold_range : (int -> int -> '-> 'a) -> t -> '-> 'a
          val for_all : (int -> bool) -> t -> bool
          val exists : (int -> bool) -> t -> bool
          val filter : (int -> bool) -> t -> t
          val partition : (int -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> int list
          val ranges : t -> (int * int) list
          val min_elt : t -> int
          val max_elt : t -> int
          val choose : t -> int
        end
      module IMap :
        sig
          type 'a t = (int * int * 'a) AvlTree.tree
          type key = int
          val empty : 'a t
          val is_empty : 'a t -> bool
          val add : ?eq:('-> '-> bool) -> int -> '-> 'a t -> 'a t
          val add_range :
            ?eq:('-> '-> bool) -> int -> int -> '-> 'a t -> 'a t
          val find : int -> 'a t -> 'a
          val remove : int -> 'a t -> 'a t
          val remove_range : int -> int -> 'a t -> 'a t
          val from : int -> 'a t -> 'a t
          val after : int -> 'a t -> 'a t
          val until : int -> 'a t -> 'a t
          val before : int -> 'a t -> 'a t
          val mem : int -> 'a t -> bool
          val iter : (int -> '-> unit) -> 'a t -> unit
          val iter_range : (int -> int -> '-> unit) -> 'a t -> unit
          val map : ?eq:('-> '-> bool) -> ('-> 'a) -> 'b t -> 'a t
          val mapi :
            ?eq:('-> '-> bool) -> (int -> '-> 'a) -> 'b t -> 'a t
          val fold : (int -> '-> '-> 'b) -> 'a t -> '-> 'b
          val fold_range : (int -> int -> '-> '-> 'b) -> 'a t -> '-> 'b
          val set_to_map : ISet.t -> '-> 'a t
          val domain : 'a t -> ISet.t
          val map_to_set : ('-> bool) -> 'a t -> ISet.t
        end
      module XArray :
        sig
          type 'a xarray = 'XArray.xarray
          type 'a t = 'a xarray
          val init : ?bufsize:int -> int -> '-> (int -> 'a) -> 'a xarray
          val make : ?bufsize:int -> int -> '-> 'a xarray
          val length : 'a xarray -> int
          val get : 'a xarray -> int -> 'a
          val set : 'a xarray -> int -> '-> unit
          type index = XArray.index
          val nth : 'a xarray -> int -> index
          val first : 'a xarray -> index
          val last : 'a xarray -> index
          val look : 'a xarray -> index -> 'a
          val next : 'a t -> index -> index
          val prev : 'a t -> index -> index
          val move : 'a t -> index -> int -> index
          val out_of_range : 'a xarray -> index -> bool
          val compare_index : 'a xarray -> index -> index -> int
          val clear : 'a xarray -> unit
          val reset : 'a xarray -> unit
          val copy : 'a xarray -> 'a xarray
          val sub : 'a xarray -> int -> int -> 'a xarray
          val add_element : 'a xarray -> '-> unit
          val add_array : 'a xarray -> 'a array -> unit
          val add_xarray : 'a xarray -> 'a xarray -> unit
          val append : 'a xarray -> 'a xarray -> 'a xarray
          val iter : ('-> unit) -> 'a xarray -> unit
          val array_of : 'a xarray -> 'a array
          val shrink : 'a xarray -> int -> unit
        end
      module OOChannel :
        sig
          class type ['a] obj_input_channel =
            object method close_in : unit -> unit method get : unit -> 'end
          class type ['a] obj_output_channel =
            object
              method close_out : unit -> unit
              method flush : unit -> unit
              method put : '-> unit
            end
          class ['a] channel_of_stream :
            'Stream.t -> ['a] obj_input_channel
          val stream_of_channel : '#obj_input_channel -> 'Stream.t
          class type char_input_channel =
            object
              method close_in : unit -> unit
              method input : string -> int -> int -> int
            end
          class type char_output_channel =
            object
              method close_out : unit -> unit
              method flush : unit -> unit
              method output : string -> int -> int -> int
            end
          class char_input_channel_of :
            char #obj_input_channel -> char_input_channel
          class char_obj_input_channel_of :
            char_input_channel -> [char] obj_input_channel
          class char_output_channel_of :
            char #obj_output_channel -> char_output_channel
          class char_obj_output_channel_of :
            char_output_channel -> [char] obj_output_channel
          class of_in_channel : in_channel -> char_input_channel
          class of_out_channel : out_channel -> char_output_channel
        end
      module UChar :
        sig
          type t = UChar.t
          exception Out_of_range
          val char_of : t -> char
          val of_char : char -> t
          val code : t -> int
          val chr : int -> t
          external uint_code : t -> int = "%identity"
          val chr_of_uint : int -> t
          val eq : t -> t -> bool
          val compare : t -> t -> int
          type uchar = t
          val int_of : uchar -> int
          val of_int : int -> uchar
        end
      module USet :
        sig
          type t = USet.t
          val empty : t
          val is_empty : t -> bool
          val mem : UChar.t -> t -> bool
          val add : UChar.t -> t -> t
          val add_range : UChar.t -> UChar.t -> t -> t
          val singleton : UChar.t -> t
          val remove : UChar.t -> t -> t
          val remove_range : UChar.t -> UChar.t -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compl : t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val from : UChar.t -> t -> t
          val after : UChar.t -> t -> t
          val until : UChar.t -> t -> t
          val before : UChar.t -> t -> t
          val iter : (UChar.t -> unit) -> t -> unit
          val iter_range : (UChar.t -> UChar.t -> unit) -> t -> unit
          val fold : (UChar.t -> '-> 'a) -> t -> '-> 'a
          val fold_range : (UChar.t -> UChar.t -> '-> 'a) -> t -> '-> 'a
          val for_all : (UChar.t -> bool) -> t -> bool
          val exists : (UChar.t -> bool) -> t -> bool
          val filter : (UChar.t -> bool) -> t -> t
          val partition : (UChar.t -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> UChar.t list
          val ranges : t -> (UChar.t * UChar.t) list
          val min_elt : t -> UChar.t
          val max_elt : t -> UChar.t
          val choose : t -> UChar.t
          val uset_of_iset : ISet.t -> t
          val iset_of_uset : t -> ISet.t
        end
      module UMap :
        sig
          type 'a t = 'UMap.t
          val empty : 'a t
          val is_empty : 'a t -> bool
          val add : ?eq:('-> '-> bool) -> UChar.t -> '-> 'a t -> 'a t
          val add_range :
            ?eq:('-> '-> bool) ->
            UChar.t -> UChar.t -> '-> 'a t -> 'a t
          val find : UChar.t -> 'a t -> 'a
          val remove : UChar.t -> 'a t -> 'a t
          val remove_range : UChar.t -> UChar.t -> 'a t -> 'a t
          val from : UChar.t -> 'a t -> 'a t
          val after : UChar.t -> 'a t -> 'a t
          val until : UChar.t -> 'a t -> 'a t
          val before : UChar.t -> 'a t -> 'a t
          val mem : UChar.t -> 'a t -> bool
          val iter : (UChar.t -> '-> unit) -> 'a t -> unit
          val iter_range : (UChar.t -> UChar.t -> '-> unit) -> 'a t -> unit
          val map : ?eq:('-> '-> bool) -> ('-> 'a) -> 'b t -> 'a t
          val mapi :
            ?eq:('-> '-> bool) -> (UChar.t -> '-> 'a) -> 'b t -> 'a t
          val fold : (UChar.t -> '-> '-> 'b) -> 'a t -> '-> 'b
          val fold_range :
            (UChar.t -> UChar.t -> '-> '-> 'b) -> 'a t -> '-> 'b
          val set_to_map : USet.t -> '-> 'a t
          val domain : 'a t -> USet.t
          val map_to_set : ('-> bool) -> 'a t -> USet.t
          val umap_of_imap : 'IMap.t -> 'a t
          val imap_of_umap : 'a t -> 'IMap.t
        end
      module UCharTbl :
        sig
          type 'a tbl = 'UCharTbl.tbl
          type 'a t = 'a tbl
          val get : 'a tbl -> UChar.t -> 'a
          module type Type =
            sig
              type elt
              type t = elt tbl
              val get : elt tbl -> UChar.t -> elt
              val of_map : elt -> elt UMap.t -> t
            end
          module Make :
            functor (H : Hashtbl.HashedType->
              sig
                type elt = H.t
                type t = elt tbl
                val get : elt tbl -> UChar.t -> elt
                val of_map : elt -> elt UMap.t -> t
              end
          module Bool :
            sig
              type t = UCharTbl.Bool.t
              val get : t -> UChar.t -> bool
              val of_set : USet.t -> t
            end
          module Bits :
            sig
              type t = UCharTbl.Bits.t
              val of_map : int -> int UMap.t -> t
              val get : t -> UChar.t -> int
            end
          module Bytes :
            sig
              type t = UCharTbl.Bytes.t
              val of_map : int -> int UMap.t -> t
              val get : t -> UChar.t -> int
            end
          module Char :
            sig
              type t = UCharTbl.Char.t
              val of_map : char -> char UMap.t -> t
              val get : t -> UChar.t -> char
            end
        end
      module UnicodeString :
        sig
          module type Type =
            sig
              type t
              val get : t -> int -> UChar.t
              val init : int -> (int -> UChar.t) -> t
              val length : t -> int
              type index
              val look : t -> index -> UChar.t
              val nth : t -> int -> index
              val next : t -> index -> index
              val prev : t -> index -> index
              val out_of_range : t -> index -> bool
              val iter : (UChar.t -> unit) -> t -> unit
              val compare : t -> t -> int
              val first : t -> index
              val last : t -> index
              val move : t -> index -> int -> index
              val compare_index : t -> index -> index -> int
              module Buf :
                sig
                  type buf
                  val create : int -> buf
                  val contents : buf -> t
                  val clear : buf -> unit
                  val reset : buf -> unit
                  val add_char : buf -> UChar.t -> unit
                  val add_string : buf -> t -> unit
                  val add_buffer : buf -> buf -> unit
                end
            end
        end
      module UText :
        sig
          type mutability = [ `Immutable | `Mutable ]
          type 'a text = 'UText.text
          type utext = [ `Immutable ] text
          type ustring = [ `Mutable ] text
          type t = utext
          val utext_of_ustring : ustring -> utext
          val ustring_of_utext : utext -> ustring
          val get : 'a text -> int -> UChar.t
          val set : ustring -> int -> UChar.t -> unit
          type index = UText.index
          val look : 'a text -> index -> UChar.t
          val nth : 'a text -> int -> index
          val first : 'a text -> index
          val last : 'a text -> index
          val out_of_range : 'a text -> index -> bool
          val compare_index : 'a text -> index -> index -> int
          val next : 'a text -> index -> index
          val prev : 'a text -> index -> index
          val move : 'a text -> index -> int -> index
          val length : 'a text -> int
          val of_string : string -> utext
          val init : int -> (int -> UChar.t) -> utext
          val init_ustring : int -> (int -> UChar.t) -> ustring
          val make : int -> UChar.t -> ustring
          val copy : ustring -> ustring
          val sub : 'a text -> int -> int -> 'a text
          val fill : ustring -> int -> int -> UChar.t -> unit
          val blit : 'a text -> int -> ustring -> int -> int -> unit
          val append : 'a text -> 'b text -> 'a text
          val iter : (UChar.t -> unit) -> 'a text -> unit
          val compare : 'a text -> 'b text -> int
          module Buf :
            sig
              type buf = UText.Buf.buf
              val create : int -> buf
              val contents : buf -> t
              val contents_string : buf -> ustring
              val length : buf -> int
              val clear : buf -> unit
              val reset : buf -> unit
              val add_char : buf -> UChar.t -> unit
              val add_string : buf -> 'a text -> unit
              val add_buffer : buf -> buf -> unit
            end
        end
      module XString :
        sig
          type xstring = XString.xstring
          type t = xstring
          val get : xstring -> int -> UChar.t
          val set : xstring -> int -> UChar.t -> unit
          val length : xstring -> int
          val init : int -> (int -> UChar.t) -> xstring
          type index = XString.index
          val look : xstring -> index -> UChar.t
          val nth : xstring -> int -> index
          val first : xstring -> index
          val last : xstring -> index
          val out_of_range : xstring -> index -> bool
          val next : xstring -> index -> index
          val prev : xstring -> index -> index
          val move : xstring -> index -> int -> index
          val compare_index : xstring -> index -> index -> int
          val make : ?bufsize:int -> int -> UChar.t -> xstring
          val clear : xstring -> unit
          val reset : xstring -> unit
          val copy : xstring -> xstring
          val sub : xstring -> int -> int -> xstring
          val add_char : xstring -> UChar.t -> unit
          val add_text : xstring -> 'UText.text -> unit
          val add_xstring : xstring -> xstring -> unit
          val shrink : xstring -> int -> unit
          val append : xstring -> xstring -> xstring
          val utext_of : xstring -> UText.t
          val ustring_of : xstring -> UText.ustring
          val iter : (UChar.t -> unit) -> xstring -> unit
          val compare : t -> t -> int
          module Buf :
            sig
              type buf = XString.Buf.buf
              val create : int -> buf
              val contents : buf -> t
              val length : buf -> int
              val clear : buf -> unit
              val reset : buf -> unit
              val add_char : buf -> UChar.t -> unit
              val add_string : buf -> t -> unit
              val add_buffer : buf -> buf -> unit
            end
        end
      module SubText :
        sig
          module type Type =
            sig
              type t
              val get : t -> int -> UChar.t
              val init : int -> (int -> UChar.t) -> t
              val length : t -> int
              type index
              val look : t -> index -> UChar.t
              val nth : t -> int -> index
              val first : t -> index
              val last : t -> index
              val next : t -> index -> index
              val prev : t -> index -> index
              val move : t -> index -> int -> index
              val out_of_range : t -> index -> bool
              val compare_index : t -> index -> index -> int
              val iter : (UChar.t -> unit) -> t -> unit
              val compare : t -> t -> int
              module Buf :
                sig
                  type buf
                  val create : int -> buf
                  val contents : buf -> t
                  val clear : buf -> unit
                  val reset : buf -> unit
                  val add_char : buf -> UChar.t -> unit
                  val add_string : buf -> t -> unit
                  val add_buffer : buf -> buf -> unit
                end
              type ur_text
              type ur_index
              val refer : ur_text -> ur_index -> ur_index -> t
              val excerpt : t -> ur_text
              val context : t -> ur_text * ur_index * ur_index
              val ur_index_of : t -> index -> ur_index
            end
          module Make :
            functor (Text : UnicodeString.Type->
              sig
                type t = SubText.Make(Text).t
                val get : t -> int -> UChar.t
                val init : int -> (int -> UChar.t) -> t
                val length : t -> int
                type index = SubText.Make(Text).index
                val look : t -> index -> UChar.t
                val nth : t -> int -> index
                val first : t -> index
                val last : t -> index
                val next : t -> index -> index
                val prev : t -> index -> index
                val move : t -> index -> int -> index
                val out_of_range : t -> index -> bool
                val compare_index : t -> index -> index -> int
                val iter : (UChar.t -> unit) -> t -> unit
                val compare : t -> t -> int
                module Buf :
                  sig
                    type buf = SubText.Make(Text).Buf.buf
                    val create : int -> buf
                    val contents : buf -> t
                    val clear : buf -> unit
                    val reset : buf -> unit
                    val add_char : buf -> UChar.t -> unit
                    val add_string : buf -> t -> unit
                    val add_buffer : buf -> buf -> unit
                  end
                type ur_text = Text.t
                type ur_index = Text.index
                val refer : ur_text -> ur_index -> ur_index -> t
                val excerpt : t -> ur_text
                val context : t -> ur_text * ur_index * ur_index
                val ur_index_of : t -> index -> ur_index
              end
        end
      module ULine :
        sig
          type separator = [ `CR | `CRLF | `LF | `LS | `NEL | `PS ]
          class input :
            separator ->
            UChar.t #OOChannel.obj_input_channel ->
            [UChar.t] OOChannel.obj_input_channel
          class output :
            separator ->
            UChar.t #OOChannel.obj_output_channel ->
            [UChar.t] OOChannel.obj_output_channel
          module type Type =
            sig
              type text
              class input_line :
                UChar.t #OOChannel.obj_input_channel ->
                [text] OOChannel.obj_input_channel
              class output_line :
                ?sp:separator ->
                UChar.t #OOChannel.obj_output_channel ->
                [text] OOChannel.obj_output_channel
            end
          module Make :
            functor (Text : UnicodeString.Type->
              sig
                type text = Text.t
                class input_line :
                  UChar.t #OOChannel.obj_input_channel ->
                  [text] OOChannel.obj_input_channel
                class output_line :
                  ?sp:separator ->
                  UChar.t #OOChannel.obj_output_channel ->
                  [text] OOChannel.obj_output_channel
              end
        end
      module Locale :
        sig
          type t = string
          val read : string -> string -> (in_channel -> 'a) -> string -> 'a
          val contain : string -> string -> bool
        end
      module CharEncoding : CharEncoding.Interface
      module UTF8 :
        sig
          type t = string
          exception Malformed_code
          val validate : t -> unit
          val get : t -> int -> UChar.t
          val init : int -> (int -> UChar.t) -> t
          val length : t -> int
          type index = int
          val nth : t -> int -> index
          val first : t -> index
          val last : t -> index
          val look : t -> index -> UChar.t
          val out_of_range : t -> index -> bool
          val compare_index : t -> index -> index -> int
          val next : t -> index -> index
          val prev : t -> index -> index
          val move : t -> index -> int -> index
          val iter : (UChar.t -> unit) -> t -> unit
          val compare : t -> t -> int
          module Buf :
            sig
              type buf = Buffer.t
              val create : int -> buf
              val contents : buf -> t
              val clear : buf -> unit
              val reset : buf -> unit
              val add_char : buf -> UChar.t -> unit
              val add_string : buf -> t -> unit
              val add_buffer : buf -> buf -> unit
            end
        end
      module UTF16 :
        sig
          type t =
              (int, Bigarray.int16_unsigned_elt, Bigarray.c_layout)
              Bigarray.Array1.t
          exception Malformed_code
          val validate : t -> unit
          val get : t -> int -> UChar.t
          exception Out_of_range
          val init : int -> (int -> UChar.t) -> t
          val length : t -> int
          type index = int
          val nth : t -> int -> index
          val first : t -> index
          val last : t -> index
          val look : t -> index -> UChar.t
          val out_of_range : t -> index -> bool
          val compare_index : t -> index -> index -> int
          val next : t -> index -> index
          val prev : t -> index -> index
          val move : t -> index -> int -> index
          val iter : (UChar.t -> unit) -> t -> unit
          val compare : t -> t -> int
          module Buf :
            sig
              type buf = UTF16.Buf.buf
              val create : int -> buf
              val contents : buf -> t
              val clear : buf -> unit
              val reset : buf -> unit
              val add_char : buf -> UChar.t -> unit
              val add_string : buf -> t -> unit
              val add_buffer : buf -> buf -> unit
            end
        end
      module UCS4 :
        sig
          type t =
              (int32, Bigarray.int32_elt, Bigarray.c_layout)
              Bigarray.Array1.t
          exception Malformed_code
          val validate : t -> unit
          val get : t -> int -> UChar.t
          val init : int -> (int -> UChar.t) -> t
          val length : t -> int
          type index = int
          val nth : t -> int -> index
          val first : t -> index
          val last : t -> index
          val look : t -> index -> UChar.t
          val out_of_range : t -> index -> bool
          val compare_index : t -> index -> index -> int
          val next : t -> index -> index
          val prev : t -> index -> index
          val move : t -> index -> int -> index
          val iter : (UChar.t -> unit) -> t -> unit
          val compare : t -> t -> int
          module Buf :
            sig
              type buf = UCS4.Buf.buf
              val create : int -> buf
              val contents : buf -> t
              val clear : buf -> unit
              val reset : buf -> unit
              val add_char : buf -> UChar.t -> unit
              val add_string : buf -> t -> unit
              val add_buffer : buf -> buf -> unit
            end
        end
      module UPervasives :
        sig
          type uchar = UChar.t
          val int_of_uchar : uchar -> int
          val uchar_of_int : int -> uchar
          val escaped_uchar : uchar -> string
          val escaped_utf8 : string -> string
          val printer_utf8 : Format.formatter -> string -> unit
          val printer_uchar : Format.formatter -> uchar -> unit
        end
      module URe :
        sig
          type regexp =
              [ `After of regexp
              | `Alt of regexp * regexp
              | `Before of regexp
              | `BoS
              | `EoS
              | `Epsilon
              | `Group of regexp
              | `OneChar
              | `Rep of regexp
              | `Repn of regexp * int * int option
              | `Seq of regexp * regexp
              | `Set of USet.t
              | `String of UChar.t list ]
          type match_semantics = [ `First | `Longest | `Shortest ]
          val no_group : regexp -> regexp
          module type Type =
            sig
              type text
              type index
              type compiled_regexp
              module SubText :
                sig
                  type t
                  val get : t -> int -> UChar.t
                  val init : int -> (int -> UChar.t) -> t
                  val length : t -> int
                  type index
                  val look : t -> index -> UChar.t
                  val nth : t -> int -> index
                  val first : t -> index
                  val last : t -> index
                  val next : t -> index -> index
                  val prev : t -> index -> index
                  val move : t -> index -> int -> index
                  val out_of_range : t -> index -> bool
                  val compare_index : t -> index -> index -> int
                  val iter : (UChar.t -> unit) -> t -> unit
                  val compare : t -> t -> int
                  module Buf :
                    sig
                      type buf
                      val create : int -> buf
                      val contents : buf -> t
                      val clear : buf -> unit
                      val reset : buf -> unit
                      val add_char : buf -> UChar.t -> unit
                      val add_string : buf -> t -> unit
                      val add_buffer : buf -> buf -> unit
                    end
                  type ur_text = text
                  type ur_index = index
                  val refer : ur_text -> ur_index -> ur_index -> t
                  val excerpt : t -> ur_text
                  val context : t -> ur_text * ur_index * ur_index
                  val ur_index_of : t -> index -> ur_index
                end
              val compile : regexp -> compiled_regexp
              val regexp_match :
                ?sem:match_semantics ->
                compiled_regexp ->
                text -> index -> SubText.t option array option
              val string_match : compiled_regexp -> text -> index -> bool
              val search_forward :
                ?sem:match_semantics ->
                compiled_regexp ->
                text -> index -> SubText.t option array option
            end
          module Make :
            functor (Text : UnicodeString.Type->
              sig
                type text = Text.t
                type index = Text.index
                type compiled_regexp
                module SubText :
                  sig
                    type t
                    val get : t -> int -> UChar.t
                    val init : int -> (int -> UChar.t) -> t
                    val length : t -> int
                    type index
                    val look : t -> index -> UChar.t
                    val nth : t -> int -> index
                    val first : t -> index
                    val last : t -> index
                    val next : t -> index -> index
                    val prev : t -> index -> index
                    val move : t -> index -> int -> index
                    val out_of_range : t -> index -> bool
                    val compare_index : t -> index -> index -> int
                    val iter : (UChar.t -> unit) -> t -> unit
                    val compare : t -> t -> int
                    module Buf :
                      sig
                        type buf
                        val create : int -> buf
                        val contents : buf -> t
                        val clear : buf -> unit
                        val reset : buf -> unit
                        val add_char : buf -> UChar.t -> unit
                        val add_string : buf -> t -> unit
                        val add_buffer : buf -> buf -> unit
                      end
                    type ur_text = text
                    type ur_index = index
                    val refer : ur_text -> ur_index -> ur_index -> t
                    val excerpt : t -> ur_text
                    val context : t -> ur_text * ur_index * ur_index
                    val ur_index_of : t -> index -> ur_index
                  end
                val compile : regexp -> compiled_regexp
                val regexp_match :
                  ?sem:match_semantics ->
                  compiled_regexp ->
                  text -> index -> SubText.t option array option
                val string_match : compiled_regexp -> text -> index -> bool
                val search_forward :
                  ?sem:match_semantics ->
                  compiled_regexp ->
                  text -> index -> SubText.t option array option
              end
        end
      module UCharInfo : UCharInfo.Type
      module UNF :
        sig
          module type Type = UNF.Type
          module Make :
            functor (Text : UnicodeString.Type->
              sig
                type text = Text.t
                class nfd :
                  UChar.t #OOChannel.obj_output_channel ->
                  [UChar.t] OOChannel.obj_output_channel
                class nfc :
                  UChar.t #OOChannel.obj_output_channel ->
                  [UChar.t] OOChannel.obj_output_channel
                class nfkd :
                  UChar.t #OOChannel.obj_output_channel ->
                  [UChar.t] OOChannel.obj_output_channel
                class nfkc :
                  UChar.t #OOChannel.obj_output_channel ->
                  [UChar.t] OOChannel.obj_output_channel
                val nfd : text -> text
                val nfkd : text -> text
                val nfc : text -> text
                val nfkc : text -> text
                module NFCBuf :
                  sig
                    type buf
                    val create : int -> buf
                    val contents : buf -> text
                    val clear : buf -> unit
                    val reset : buf -> unit
                    val add_char : buf -> UChar.t -> unit
                    val add_string : buf -> text -> unit
                    val add_buffer : buf -> buf -> unit
                  end
                val nfc_append : text -> text -> text
                val put_nfd : XString.t -> text -> unit
                val put_nfkd : XString.t -> text -> unit
                val put_nfc : XString.t -> text -> unit
                val put_nfkc : XString.t -> text -> unit
                type index = Text.index
                val nfd_inc :
                  text ->
                  index ->
                  ([ `Inc of UChar.t list * index * 'a lazy_t ] as 'a)
                val canon_compare : text -> text -> int
                val nfd_decompose : UChar.t -> UChar.t list
                val nfkd_decompose : UChar.t -> UChar.t list
              end
        end
      module UCol :
        sig
          type variable_option =
              [ `Blanked | `Non_ignorable | `Shift_Trimmed | `Shifted ]
          type precision =
              [ `Primary | `Quaternary | `Secondary | `Tertiary ]
          module type Type = UCol.Type
          module Make :
            functor (Text : UnicodeString.Type->
              sig
                type text = Text.t
                type index = Text.index
                val compare :
                  ?locale:string ->
                  ?prec:UCol.precision ->
                  ?variable:UCol.variable_option -> text -> text -> int
                val sort_key :
                  ?locale:string ->
                  ?prec:UCol.precision ->
                  ?variable:UCol.variable_option -> text -> string
                val compare_with_key :
                  ?locale:string ->
                  ?prec:UCol.precision ->
                  ?variable:UCol.variable_option -> string -> text -> int
                val search_with_key :
                  ?locale:string ->
                  ?prec:UCol.precision ->
                  ?variable:UCol.variable_option ->
                  string -> text -> index -> index * index
                val search :
                  ?locale:string ->
                  ?prec:UCol.precision ->
                  ?variable:UCol.variable_option ->
                  text -> text -> index -> index * index
              end
        end
      module CaseMap :
        sig
          module type Type = CaseMap.Type
          module Make :
            functor (Text : UnicodeString.Type->
              sig
                type text = Text.t
                val lowercase : ?locale:string -> text -> text
                val uppercase : ?locale:string -> text -> text
                val titlecase : ?locale:string -> text -> text
                val casefolding : text -> text
                val compare_caseless : text -> text -> int
              end
        end
      module UReStr : UReStr.Interface
    end
end