sig
  module Unit :
    sig
      type t = unit
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module Int :
    sig
      type t = int
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module Bool :
    sig
      type t = bool
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module String :
    sig
      type t = string
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module BigInt :
    sig
      type t = Big_int.big_int
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module Formatter :
    sig
      type t = Format.formatter
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module OutChannel :
    sig
      type t = out_channel
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module InChannel :
    sig
      type t = in_channel
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
  module Ref :
    functor (Data : Project.Datatype.S->
      sig
        type t = Data.t ref
        val rehash : t -> t
        val descr : Unmarshal.t
        val copy : t -> t
        val name : string
        val register_comparable :
          ?compare:(t -> t -> int) ->
          ?equal:(t -> t -> bool) ->
          ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
        val is_comparable_set : unit -> bool
        val hash : t -> int
        val physical_hash : t -> int
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val contain_project : (Project.project -> t -> bool) option ref
      end
  module Option :
    functor (Data : Project.Datatype.S->
      sig
        type t = Data.t option
        val rehash : t -> t
        val descr : Unmarshal.t
        val copy : t -> t
        val name : string
        val register_comparable :
          ?compare:(t -> t -> int) ->
          ?equal:(t -> t -> bool) ->
          ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
        val is_comparable_set : unit -> bool
        val hash : t -> int
        val physical_hash : t -> int
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val contain_project : (Project.project -> t -> bool) option ref
      end
  module OptionRef :
    functor (Data : Project.Datatype.S->
      sig
        type t = Data.t option ref
        val rehash : t -> t
        val descr : Unmarshal.t
        val copy : t -> t
        val name : string
        val register_comparable :
          ?compare:(t -> t -> int) ->
          ?equal:(t -> t -> bool) ->
          ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
        val is_comparable_set : unit -> bool
        val hash : t -> int
        val physical_hash : t -> int
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val contain_project : (Project.project -> t -> bool) option ref
      end
  module List :
    functor (Data : Project.Datatype.S->
      sig
        type t = Data.t list
        val rehash : t -> t
        val descr : Unmarshal.t
        val copy : t -> t
        val name : string
        val register_comparable :
          ?compare:(t -> t -> int) ->
          ?equal:(t -> t -> bool) ->
          ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
        val is_comparable_set : unit -> bool
        val hash : t -> int
        val physical_hash : t -> int
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val contain_project : (Project.project -> t -> bool) option ref
      end
  module type HASHTBL =
    sig
      type key
      type 'a t
      val create : int -> 'Datatype.HASHTBL.t
      val iter :
        (Datatype.HASHTBL.key -> '-> unit) -> 'Datatype.HASHTBL.t -> unit
      val fold :
        (Datatype.HASHTBL.key -> '-> '-> 'b) ->
        'Datatype.HASHTBL.t -> '-> 'b
      val add : 'Datatype.HASHTBL.t -> Datatype.HASHTBL.key -> '-> unit
      val replace :
        'Datatype.HASHTBL.t -> Datatype.HASHTBL.key -> '-> unit
      val length : 'Datatype.HASHTBL.t -> int
      val find_all : 'Datatype.HASHTBL.t -> Datatype.HASHTBL.key -> 'a list
    end
  module Make_Hashtbl :
    functor (H : HASHTBL->
      functor (Data : Project.Datatype.S->
        sig
          type t = Data.t H.t
          val rehash : t -> t
          val descr : Unmarshal.t
          val copy : t -> t
          val name : string
          val register_comparable :
            ?compare:(t -> t -> int) ->
            ?equal:(t -> t -> bool) ->
            ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
          val is_comparable_set : unit -> bool
          val hash : t -> int
          val physical_hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val contain_project : (Project.project -> t -> bool) option ref
        end
  module type SET =
    sig
      type elt
      type t
      val empty : Datatype.SET.t
      val singleton : Datatype.SET.elt -> Datatype.SET.t
      val add : Datatype.SET.elt -> Datatype.SET.t -> Datatype.SET.t
      val iter : (Datatype.SET.elt -> unit) -> Datatype.SET.t -> unit
      val fold : (Datatype.SET.elt -> '-> 'a) -> Datatype.SET.t -> '-> 'a
    end
  module Make_Set :
    functor (Set : SET->
      functor
        (Data : sig
                  type t = Set.elt
                  val rehash : t -> t
                  val descr : Unmarshal.t
                  val copy : t -> t
                  val name : string
                  val register_comparable :
                    ?compare:(t -> t -> int) ->
                    ?equal:(t -> t -> bool) ->
                    ?hash:(t -> int) ->
                    ?physical_hash:(t -> int) -> unit -> unit
                  val is_comparable_set : unit -> bool
                  val hash : t -> int
                  val physical_hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val contain_project :
                    (Project.project -> t -> bool) option ref
                end->
        sig
          type t = Set.t
          val rehash : t -> t
          val descr : Unmarshal.t
          val copy : t -> t
          val name : string
          val register_comparable :
            ?compare:(t -> t -> int) ->
            ?equal:(t -> t -> bool) ->
            ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
          val is_comparable_set : unit -> bool
          val hash : t -> int
          val physical_hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val contain_project : (Project.project -> t -> bool) option ref
        end
  module Make_SetRef :
    functor (Set : SET->
      functor
        (Data : sig
                  type t = Set.elt
                  val rehash : t -> t
                  val descr : Unmarshal.t
                  val copy : t -> t
                  val name : string
                  val register_comparable :
                    ?compare:(t -> t -> int) ->
                    ?equal:(t -> t -> bool) ->
                    ?hash:(t -> int) ->
                    ?physical_hash:(t -> int) -> unit -> unit
                  val is_comparable_set : unit -> bool
                  val hash : t -> int
                  val physical_hash : t -> int
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val contain_project :
                    (Project.project -> t -> bool) option ref
                end->
        sig
          type t = Set.t ref
          val rehash : t -> t
          val descr : Unmarshal.t
          val copy : t -> t
          val name : string
          val register_comparable :
            ?compare:(t -> t -> int) ->
            ?equal:(t -> t -> bool) ->
            ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
          val is_comparable_set : unit -> bool
          val hash : t -> int
          val physical_hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val contain_project : (Project.project -> t -> bool) option ref
        end
  module Set :
    functor (Data : Project.Datatype.S->
      sig
        type t = Set.Make(Data).t
        val rehash : t -> t
        val descr : Unmarshal.t
        val copy : t -> t
        val name : string
        val register_comparable :
          ?compare:(t -> t -> int) ->
          ?equal:(t -> t -> bool) ->
          ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
        val is_comparable_set : unit -> bool
        val hash : t -> int
        val physical_hash : t -> int
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val contain_project : (Project.project -> t -> bool) option ref
      end
  module type MAP =
    sig
      type key
      type 'a t
      val empty : 'Datatype.MAP.t
      val add :
        Datatype.MAP.key -> '-> 'Datatype.MAP.t -> 'Datatype.MAP.t
      val iter :
        (Datatype.MAP.key -> '-> unit) -> 'Datatype.MAP.t -> unit
      val fold :
        (Datatype.MAP.key -> '-> '-> 'b) -> 'Datatype.MAP.t -> '-> 'b
    end
  module Make_Map :
    functor (Map : MAP->
      functor (Data : Project.Datatype.S->
        sig
          type t = Data.t Map.t
          val rehash : t -> t
          val descr : Unmarshal.t
          val copy : t -> t
          val name : string
          val register_comparable :
            ?compare:(t -> t -> int) ->
            ?equal:(t -> t -> bool) ->
            ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
          val is_comparable_set : unit -> bool
          val hash : t -> int
          val physical_hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val contain_project : (Project.project -> t -> bool) option ref
        end
  module Queue :
    functor (Data : Project.Datatype.S->
      sig
        type t = Data.t Queue.t
        val rehash : t -> t
        val descr : Unmarshal.t
        val copy : t -> t
        val name : string
        val register_comparable :
          ?compare:(t -> t -> int) ->
          ?equal:(t -> t -> bool) ->
          ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
        val is_comparable_set : unit -> bool
        val hash : t -> int
        val physical_hash : t -> int
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val contain_project : (Project.project -> t -> bool) option ref
      end
  module Couple :
    functor (D1 : Project.Datatype.S->
      functor (D2 : Project.Datatype.S->
        sig
          type t = D1.t * D2.t
          val rehash : t -> t
          val descr : Unmarshal.t
          val copy : t -> t
          val name : string
          val register_comparable :
            ?compare:(t -> t -> int) ->
            ?equal:(t -> t -> bool) ->
            ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
          val is_comparable_set : unit -> bool
          val hash : t -> int
          val physical_hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val contain_project : (Project.project -> t -> bool) option ref
        end
  module Triple :
    functor (D1 : Project.Datatype.S->
      functor (D2 : Project.Datatype.S->
        functor (D3 : Project.Datatype.S->
          sig
            type t = D1.t * D2.t * D3.t
            val rehash : t -> t
            val descr : Unmarshal.t
            val copy : t -> t
            val name : string
            val register_comparable :
              ?compare:(t -> t -> int) ->
              ?equal:(t -> t -> bool) ->
              ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
            val is_comparable_set : unit -> bool
            val hash : t -> int
            val physical_hash : t -> int
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val contain_project : (Project.project -> t -> bool) option ref
          end
  module Project :
    sig
      type t = Project.t
      val rehash : t -> t
      val descr : Unmarshal.t
      val copy : t -> t
      val name : string
      val register_comparable :
        ?compare:(t -> t -> int) ->
        ?equal:(t -> t -> bool) ->
        ?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
      val is_comparable_set : unit -> bool
      val hash : t -> int
      val physical_hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val contain_project : (Project.project -> t -> bool) option ref
    end
end