sig
  type standard_kind = [ `Correctness | `Internal ]
  type user_kind = [ `Correctness | `Internal | `Irrelevant | `Tuning ]
  type kind =
      [ `Correctness
      | `Internal
      | `Irrelevant
      | `Proxy of State.standard_kind
      | `Tuning ]
  type t
  val ty : t Type.t
  val name : string
  val descr : t Descr.t
  val packed_descr : Structural_descr.pack
  val reprs : t list
  val equal : t -> t -> bool
  val compare : t -> t -> int
  val hash : t -> int
  val pretty_code : Format.formatter -> t -> unit
  val internal_pretty_code : Type.precedence -> Format.formatter -> t -> unit
  val pretty : Format.formatter -> t -> unit
  val varname : t -> string
  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
  val copy : t -> t
  module Set :
    sig
      type elt = t
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (elt -> unit) -> t -> unit
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val filter : (elt -> bool) -> t -> t
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val ty : t Type.t
      val name : string
      val descr : t Descr.t
      val packed_descr : Structural_descr.pack
      val reprs : t list
      val hash : t -> int
      val internal_pretty_code :
        Type.precedence -> Format.formatter -> t -> unit
      val pretty_code : Format.formatter -> t -> unit
      val pretty : Format.formatter -> t -> unit
      val varname : t -> string
      val mem_project : (Project_skeleton.t -> bool) -> t -> bool
      val copy : t -> t
    end
  module Map :
    sig
      type key = t
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      module Key :
        sig
          type t = key
          val ty : t Type.t
          val name : string
          val descr : t Descr.t
          val packed_descr : Structural_descr.pack
          val reprs : t list
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val hash : t -> int
          val pretty_code : Format.formatter -> t -> unit
          val internal_pretty_code :
            Type.precedence -> Format.formatter -> t -> unit
          val pretty : Format.formatter -> t -> unit
          val varname : t -> string
          val mem_project : (Project_skeleton.t -> bool) -> t -> bool
          val copy : t -> t
        end
      module Make :
        functor (Data : Datatype.S->
          sig
            type t = Data.t t
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
          end
    end
  module Hashtbl :
    sig
      type key = t
      type 'a t
      val create : int -> 'a t
      val clear : 'a t -> unit
      val copy : 'a t -> 'a t
      val add : 'a t -> key -> '-> unit
      val remove : 'a t -> key -> unit
      val find : 'a t -> key -> 'a
      val find_all : 'a t -> key -> 'a list
      val replace : 'a t -> key -> '-> unit
      val mem : 'a t -> key -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
      module Key :
        sig
          type t = key
          val ty : t Type.t
          val name : string
          val descr : t Descr.t
          val packed_descr : Structural_descr.pack
          val reprs : t list
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val hash : t -> int
          val pretty_code : Format.formatter -> t -> unit
          val internal_pretty_code :
            Type.precedence -> Format.formatter -> t -> unit
          val pretty : Format.formatter -> t -> unit
          val varname : t -> string
          val mem_project : (Project_skeleton.t -> bool) -> t -> bool
          val copy : t -> t
        end
      module Make :
        functor (Data : Datatype.S->
          sig
            type t = Data.t t
            val ty : t Type.t
            val name : string
            val descr : t Descr.t
            val packed_descr : Structural_descr.pack
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val pretty_code : Format.formatter -> t -> unit
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> t -> unit
            val pretty : Format.formatter -> t -> unit
            val varname : t -> string
            val mem_project : (Project_skeleton.t -> bool) -> t -> bool
            val copy : t -> t
          end
    end
  module type Local =
    sig
      type t
      val create : unit -> State.Local.t
      val clear : State.Local.t -> unit
      val get : unit -> State.Local.t
      val set : State.Local.t -> unit
      val clear_some_projects :
        (Project_skeleton.t -> bool) -> State.Local.t -> bool
    end
  val get_name : t -> string
  val set_name : t -> string -> unit
  val get_unique_name : t -> string
  val kind : t -> State.kind
  val dummy : t
  val dummy_unique_name : string
  val is_dummy : t -> bool
  exception Unknown
  val get : string -> t
  val get_descr : t -> Structural_descr.pack
  module Cluster :
    sig
      val create : string -> t list -> unit
      val extend : string -> t list -> unit
      val states : t -> t list
      val name : t -> string option
      val unmarshal : string option -> t -> unit
      val after_load : unit -> unit
    end
  type state_on_disk = {
    on_disk_value : Obj.t;
    on_disk_computed : bool;
    on_disk_saved : bool;
    on_disk_digest : Digest.t;
  }
  type private_ops = private {
    descr : Structural_descr.pack;
    create : Project_skeleton.project -> unit;
    remove : Project_skeleton.project -> unit;
    mutable clear : Project_skeleton.project -> unit;
    mutable clear_some_projects :
      (Project_skeleton.project -> bool) -> Project_skeleton.project -> bool;
    copy : Project_skeleton.project -> Project_skeleton.project -> unit;
    commit : Project_skeleton.project -> unit;
    update : Project_skeleton.project -> unit;
    clean : unit -> unit;
    serialize : Project_skeleton.project -> State.state_on_disk;
    unserialize : Project_skeleton.project -> State.state_on_disk -> unit;
  }
  val dummy_state_on_disk : State.state_on_disk
  val private_ops : t -> State.private_ops
  module States : Local
  module States_datatype :
    sig
      type t = States.t
      val ty : t Type.t
      val name : string
      val descr : t Descr.t
      val packed_descr : Structural_descr.pack
      val reprs : t list
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : t -> int
      val pretty_code : Format.formatter -> t -> unit
      val internal_pretty_code :
        Type.precedence -> Format.formatter -> t -> unit
      val pretty : Format.formatter -> t -> unit
      val varname : t -> string
      val mem_project : (Project_skeleton.t -> bool) -> t -> bool
      val copy : t -> t
    end
  val delete : t -> unit
  val unusable : name:string -> string -> t
  val is_usable : t -> bool
  val update_unusable :
    t -> State.kind -> (Project_skeleton.project -> unit) -> unit
  val create :
    descr:Structural_descr.pack ->
    create:(Project_skeleton.project -> unit) ->
    remove:(Project_skeleton.project -> unit) ->
    clear:(Project_skeleton.project -> unit) ->
    clear_some_projects:((Project_skeleton.project -> bool) ->
                         Project_skeleton.project -> bool) ->
    copy:(Project_skeleton.project -> Project_skeleton.project -> unit) ->
    commit:(Project_skeleton.project -> unit) ->
    update:(Project_skeleton.project -> unit) ->
    clean:(unit -> unit) ->
    serialize:(Project_skeleton.project -> State.state_on_disk) ->
    unserialize:(Project_skeleton.project -> State.state_on_disk -> unit) ->
    unique_name:string -> name:string -> State.kind -> t
end