sig
  module Diagnostic :
    sig
      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 option * int 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 request = Cudf.package list
      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;
      }
      val diagnosis :
        Common.Util.projection ->
        Cudf.universe ->
        Algo.Diagnostic.result_int ->
        Algo.Diagnostic.request_int -> Algo.Diagnostic.diagnosis
      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_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
          val stats : 'a t -> Hashtbl.statistics
        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 Pervasives.ref Algo.Diagnostic.ResultHash.t;
        statistic : (int * int, int Pervasives.ref) Hashtbl.t;
      }
      val default_result : int -> Algo.Diagnostic.summary
      val collect :
        Algo.Diagnostic.summary -> Algo.Diagnostic.diagnosis -> unit
      val pp_out_version : Format.formatter -> unit
      val pp_package :
        ?source:bool ->
        ?fields:bool ->
        Common.CudfAdd.pp -> Format.formatter -> Cudf.package -> unit
      val pp_dependency :
        Common.CudfAdd.pp ->
        ?label:string ->
        Format.formatter -> Cudf.package * Cudf_types.vpkglist -> unit
      val pp_dependencies :
        Common.CudfAdd.pp ->
        Format.formatter ->
        (Cudf.package * Cudf_types.vpkglist) list list -> unit
      val pp_list :
        (Format.formatter -> '-> unit) ->
        Format.formatter -> 'a list -> unit
      val print_error :
        ?condense:bool ->
        ?minimal:bool ->
        Common.CudfAdd.pp ->
        Cudf.package ->
        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 -> Format.formatter -> Algo.Diagnostic.summary -> unit
      val print_error_human :
        ?prefix:string ->
        Common.CudfAdd.pp ->
        Cudf.package ->
        Format.formatter -> Algo.Diagnostic.reason list -> unit
      val fprintf_human :
        ?pp:Common.CudfAdd.pp ->
        ?prefix:string ->
        Format.formatter -> Algo.Diagnostic.diagnosis -> unit
      val fprintf :
        ?pp:Common.CudfAdd.pp ->
        ?failure:bool ->
        ?success:bool ->
        ?explain:bool ->
        ?minimal:bool ->
        ?condense:bool ->
        Format.formatter -> Algo.Diagnostic.diagnosis -> unit
      val printf :
        ?pp:Common.CudfAdd.pp ->
        ?failure:bool ->
        ?success:bool -> ?explain:bool -> Algo.Diagnostic.diagnosis -> unit
    end
  module Depsolver_int :
    sig
      module R : sig type reason = Algo.Diagnostic.reason_int end
      module S :
        sig
          module X : sig type reason = Diagnostic.reason_int end
          type state
          type var = int
          type value = True | False | Unknown
          type lit
          val lit_of_var : var -> bool -> lit
          val initialize_problem :
            ?print_var:(Format.formatter -> int -> unit) ->
            ?buffer:bool -> int -> state
          val copy : state -> state
          val propagate : state -> unit
          val protect : state -> unit
          val reset : state -> unit
          val assignment : state -> value array
          val assignment_true : state -> var list
          val add_rule : state -> lit array -> X.reason list -> unit
          val associate_vars : state -> lit -> var list -> unit
          val solve_all : (state -> unit) -> state -> var -> bool
          val solve : state -> var -> bool
          val solve_lst : state -> var list -> bool
          val collect_reasons : state -> var -> X.reason list
          val collect_reasons_lst : state -> var list -> X.reason list
          val dump : state -> (int * bool) list list
          val debug : bool -> unit
          val stats : state -> unit
        end
      type solver = {
        constraints : Algo.Depsolver_int.S.state;
        map : Common.Util.projection;
      }
      type dep_t =
          (Cudf_types.vpkg list * int list) list *
          (Cudf_types.vpkg * int list) list
      and pool = Algo.Depsolver_int.dep_t array
      and t =
          [ `CudfPool of Algo.Depsolver_int.pool
          | `SolverPool of Algo.Depsolver_int.pool ]
      type result =
          Success of (unit -> int list)
        | Failure of (unit -> Algo.Diagnostic.reason_int list)
      val init_pool_univ :
        global_constraints:bool ->
        Cudf.universe -> [> `CudfPool of Algo.Depsolver_int.pool ]
      val init_solver_pool :
        Common.Util.projection ->
        [< `CudfPool of Algo.Depsolver_int.pool ] ->
        'a list -> [> `SolverPool of Algo.Depsolver_int.pool ]
      val init_solver_cache :
        ?buffer:bool ->
        [< `SolverPool of Algo.Depsolver_int.pool ] ->
        Algo.Depsolver_int.S.state
      val solve :
        ?tested:bool array ->
        Algo.Depsolver_int.solver ->
        int option * int list -> Algo.Diagnostic.result_int
      val pkgcheck :
        bool ->
        (Algo.Diagnostic.result_int * (int option * int list) -> 'a) option ->
        Algo.Depsolver_int.solver -> bool array -> int -> bool
      val init_solver_univ :
        ?global_constraints:bool ->
        ?buffer:bool -> Cudf.universe -> Algo.Depsolver_int.solver
      val init_solver_closure :
        ?buffer:bool ->
        [< `CudfPool of Algo.Depsolver_int.pool ] ->
        int list -> Algo.Depsolver_int.solver
      val copy_solver :
        Algo.Depsolver_int.solver -> Algo.Depsolver_int.solver
      val reverse_dependencies : Cudf.universe -> int list array
      val dependency_closure_cache :
        ?maxdepth:int ->
        ?conjunctive:bool ->
        [< `CudfPool of Algo.Depsolver_int.pool ] ->
        int list -> Algo.Depsolver_int.S.var list
      val dependency_closure :
        ?maxdepth:int ->
        ?conjunctive:bool ->
        ?global_constraints:bool ->
        Cudf.universe -> Cudf.package list -> Cudf.package list
      val reverse_dependency_closure :
        ?maxdepth:int -> int list array -> int list -> int list
      val progressbar_init : Common.Util.Progress.t
      val progressbar_univcheck : Common.Util.Progress.t
    end
  module Depsolver :
    sig
      type solver
      val load : ?check:bool -> Cudf.universe -> Algo.Depsolver.solver
      val edos_install :
        ?global_constraints:bool ->
        Cudf.universe -> Cudf.package -> Algo.Diagnostic.diagnosis
      val edos_coinstall :
        ?global_constraints:bool ->
        Cudf.universe -> Cudf.package list -> Algo.Diagnostic.diagnosis
      val edos_coinstall_prod :
        ?global_constraints:bool ->
        Cudf.universe ->
        Cudf.package list list -> Algo.Diagnostic.diagnosis list
      val trim : ?global_constraints:bool -> Cudf.universe -> Cudf.universe
      val trimlist :
        ?global_constraints:bool ->
        Cudf.universe -> Cudf.package list -> Cudf.package list
      val find_broken :
        ?global_constraints:bool -> Cudf.universe -> Cudf.package list
      val find_installable :
        ?global_constraints:bool -> Cudf.universe -> Cudf.package list
      val find_listbroken :
        ?global_constraints:bool ->
        Cudf.universe -> Cudf.package list -> Cudf.package list
      val find_listinstallable :
        ?global_constraints:bool ->
        Cudf.universe -> Cudf.package list -> Cudf.package list
      val univcheck :
        ?global_constraints:bool ->
        ?callback:(Algo.Diagnostic.diagnosis -> unit) -> Cudf.universe -> int
      val listcheck :
        ?global_constraints:bool ->
        ?callback:(Algo.Diagnostic.diagnosis -> unit) ->
        Cudf.universe -> Cudf.package list -> int
      val dependency_closure :
        ?maxdepth:int ->
        ?conjunctive:bool ->
        ?global_constraints:bool ->
        Cudf.universe -> Cudf.package list -> Cudf.package list
      val reverse_dependencies :
        Cudf.universe -> Cudf.package list Common.CudfAdd.Cudf_hashtbl.t
      val reverse_dependency_closure :
        ?maxdepth:int ->
        Cudf.universe -> Cudf.package list -> Cudf.package list
      type enc = Cnf | Dimacs
      val output_clauses :
        ?global_constraints:bool ->
        ?enc:Algo.Depsolver.enc -> Cudf.universe -> string
      type depclean_result =
          Cudf.package *
          (Cudf_types.vpkglist * Cudf_types.vpkg * Cudf.package list) list *
          (Cudf_types.vpkg * Cudf.package list) list
      val depclean :
        ?global_constraints:bool ->
        ?callback:(Algo.Depsolver.depclean_result -> unit) ->
        Cudf.universe ->
        Cudf.package list -> Algo.Depsolver.depclean_result list
      type solver_result =
          Sat of (Cudf.preamble option * Cudf.universe)
        | Unsat of Algo.Diagnostic.diagnosis option
        | Error of string
      val check_request :
        ?cmd:string ->
        ?callback:(int array * Algo.Diagnostic.diagnosis -> unit) ->
        ?criteria:string ->
        ?explain:bool -> Cudf.cudf -> Algo.Depsolver.solver_result
      val check_request_using :
        ?call_solver:(Cudf.cudf -> Cudf.preamble option * Cudf.universe) ->
        ?callback:(int array * Algo.Diagnostic.diagnosis -> unit) ->
        ?criteria:string ->
        ?explain:bool -> Cudf.cudf -> Algo.Depsolver.solver_result
    end
  module Strongdeps :
    sig
      val strongdeps :
        ?transitive:bool ->
        Cudf.universe -> Cudf.package list -> Defaultgraphs.PackageGraph.G.t
      val strongdeps_univ :
        ?transitive:bool -> Cudf.universe -> Defaultgraphs.PackageGraph.G.t
      val impactset :
        Defaultgraphs.PackageGraph.G.t -> Cudf.package -> Cudf.package list
      val conjdeps_univ : Cudf.universe -> Defaultgraphs.PackageGraph.G.t
      val conjdeps :
        Cudf.universe -> Cudf.package list -> Defaultgraphs.PackageGraph.G.t
    end
end