sig
  type request = Cudf.package list
  type reason =
      Dependency of (Cudf.package * Cudf_types.vpkg list * Cudf.package list)
    | Missing of (Cudf.package * Cudf_types.vpkg list)
    | Conflict of (Cudf.package * Cudf.package * Cudf_types.vpkg)
  type result =
      Success of (?all:bool -> unit -> Cudf.package list)
    | Failure of (unit -> Algo.Diagnostic.reason list)
  type diagnosis = {
    result : Algo.Diagnostic.result;
    request : Algo.Diagnostic.request;
  }
  type reason_int =
      DependencyInt of (int * Cudf_types.vpkg list * int list)
    | MissingInt of (int * Cudf_types.vpkg list)
    | ConflictInt of (int * int * Cudf_types.vpkg)
  type result_int =
      SuccessInt of (?all:bool -> unit -> int list)
    | FailureInt of (unit -> Algo.Diagnostic.reason_int list)
  type request_int = int list
  val diagnosis :
    Common.Util.projection ->
    Cudf.universe ->
    Algo.Diagnostic.result_int ->
    Algo.Diagnostic.request_int -> Algo.Diagnostic.diagnosis
  val result :
    Common.Util.projection ->
    Cudf.universe -> Algo.Diagnostic.result_int -> Algo.Diagnostic.result
  val request :
    Cudf.universe -> Algo.Diagnostic.request_int -> Cudf.package list
  module ResultHash :
    sig
      type key = reason
      type 'a t
      val create : int -> 'a t
      val clear : 'a t -> unit
      val reset : '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_opt : 'a t -> key -> 'a option
      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 filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val length : 'a t -> int
      val stats : 'a t -> Hashtbl.statistics
      val to_seq : 'a t -> (key * 'a) Seq.t
      val to_seq_keys : 'a t -> key Seq.t
      val to_seq_values : 'a t -> 'Seq.t
      val add_seq : 'a t -> (key * 'a) Seq.t -> unit
      val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
      val of_seq : (key * 'a) Seq.t -> 'a t
    end
  type summary = {
    mutable missing : int;
    mutable conflict : int;
    mutable unique_missing : int;
    mutable unique_conflict : int;
    mutable unique_selfconflict : int;
    summary : Cudf.package list Stdlib.ref Algo.Diagnostic.ResultHash.t;
    statistic : (int * int, int Stdlib.ref) Stdlib.Hashtbl.t;
  }
  val default_result : int -> Algo.Diagnostic.summary
  val collect : Algo.Diagnostic.summary -> Algo.Diagnostic.diagnosis -> unit
  val pp_out_version : Stdlib.Format.formatter -> unit
  val pp_package :
    ?source:bool ->
    ?fields:bool ->
    Common.CudfAdd.pp -> Stdlib.Format.formatter -> Cudf.package -> unit
  val pp_list :
    (Stdlib.Format.formatter -> '-> unit) ->
    Stdlib.Format.formatter -> 'a list -> unit
  val print_error :
    ?condense:bool ->
    ?minimal:bool ->
    Common.CudfAdd.pp ->
    Cudf.package ->
    Stdlib.Format.formatter -> Algo.Diagnostic.reason list -> unit
  val get_installationset :
    ?minimal:bool -> Algo.Diagnostic.diagnosis -> Cudf.package list
  val is_solution : Algo.Diagnostic.diagnosis -> bool
  val pp_summary :
    ?pp:Common.CudfAdd.pp ->
    ?explain:bool ->
    unit -> Stdlib.Format.formatter -> Algo.Diagnostic.summary -> unit
  val fprintf :
    ?pp:Common.CudfAdd.pp ->
    ?failure:bool ->
    ?success:bool ->
    ?explain:bool ->
    ?minimal:bool ->
    ?condense:bool ->
    Stdlib.Format.formatter -> Algo.Diagnostic.diagnosis -> unit
  val printf :
    ?pp:Common.CudfAdd.pp ->
    ?failure:bool ->
    ?success:bool -> ?explain:bool -> Algo.Diagnostic.diagnosis -> unit
  val print_dot :
    ?pp:Common.CudfAdd.pp ->
    ?condense:bool ->
    ?addmissing:bool -> ?dir:string -> Algo.Diagnostic.diagnosis -> unit
end