sig
  exception Conflicting_information of string
  type liquid = RPM | Debian | Pkgsrc
  module type ORDERED_LITERATE =
    sig
      type t
      val compare :
        Rapids.ORDERED_LITERATE.t -> Rapids.ORDERED_LITERATE.t -> int
      val scribe :
        'Conduit.conduit -> '-> Rapids.ORDERED_LITERATE.t -> unit
      val io : Rapids.ORDERED_LITERATE.t Io.literate
    end
  module type STRING_ORDERED_LITERATE =
    sig
      type t = string
      val compare :
        Rapids.STRING_ORDERED_LITERATE.t ->
        Rapids.STRING_ORDERED_LITERATE.t -> int
      val scribe :
        'Conduit.conduit -> '-> Rapids.STRING_ORDERED_LITERATE.t -> unit
      val io : string Io.literate
    end
  module Version_order :
    sig
      type t = string
      val compare : Rapids.Version_order.t -> Rapids.Version_order.t -> int
      val set_comparator :
        (Rapids.Version_order.t -> Rapids.Version_order.t -> int) -> unit
      val scribe : 'Conduit.conduit -> '-> Rapids.Version_order.t -> unit
      val io : string Io.literate
    end
  module Release_order :
    sig
      type t = string option
      val compare : Rapids.Release_order.t -> Rapids.Release_order.t -> int
      val set_comparator :
        (Rapids.Release_order.t -> Rapids.Release_order.t -> int) -> unit
      val scribe : 'Conduit.conduit -> '-> Rapids.Release_order.t -> unit
      val io : string option Io.literate
    end
  module type SET =
    sig
      type elt
      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 io : t Io.literate
    end
  module type ID =
    sig
      type id
      val to_int : Rapids.ID.id -> int
      val from_int : int -> Rapids.ID.id
      val compare : Rapids.ID.id -> Rapids.ID.id -> int
      val succ : Rapids.ID.id -> Rapids.ID.id
      val scribe : 'Conduit.conduit -> '-> Rapids.ID.id -> unit
      val zero : Rapids.ID.id
      val sweep : Rapids.ID.id -> (Rapids.ID.id -> unit) -> unit
      val io : Rapids.ID.id Io.literate
    end
  module type INDEX =
    sig
      type elt
      type id
      type t
      val create : unit -> Rapids.INDEX.t
      val register : Rapids.INDEX.t -> Rapids.INDEX.elt -> Rapids.INDEX.id
      val search : Rapids.INDEX.t -> Rapids.INDEX.elt -> Rapids.INDEX.id
      val find : Rapids.INDEX.t -> Rapids.INDEX.id -> Rapids.INDEX.elt
      val compare_id : Rapids.INDEX.id -> Rapids.INDEX.id -> int
      val scribe_id : 'Conduit.conduit -> '-> Rapids.INDEX.id -> unit
      val io_id : Rapids.INDEX.id Io.literate
      val iter :
        Rapids.INDEX.t ->
        (Rapids.INDEX.id -> Rapids.INDEX.elt -> unit) -> unit
      val set_watcher :
        Rapids.INDEX.t ->
        (Rapids.INDEX.id -> Rapids.INDEX.elt -> unit) -> unit
    end
  module type DOUBLE_INDEX =
    sig
      type e1
      type e2
      type elt = Rapids.DOUBLE_INDEX.e1 * Rapids.DOUBLE_INDEX.e2
      type id
      type t
      val create : unit -> Rapids.DOUBLE_INDEX.t
      val register :
        Rapids.DOUBLE_INDEX.t ->
        Rapids.DOUBLE_INDEX.elt -> Rapids.DOUBLE_INDEX.id
      val replace : Rapids.DOUBLE_INDEX.t -> Rapids.DOUBLE_INDEX.elt -> unit
      val find :
        Rapids.DOUBLE_INDEX.t ->
        Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.elt
      val search1 :
        Rapids.DOUBLE_INDEX.t ->
        Rapids.DOUBLE_INDEX.e1 -> Rapids.DOUBLE_INDEX.id
      val search2 :
        Rapids.DOUBLE_INDEX.t ->
        Rapids.DOUBLE_INDEX.e2 -> Rapids.DOUBLE_INDEX.id
      val compare_id :
        Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.id -> int
      val scribe_id :
        'Conduit.conduit -> '-> Rapids.DOUBLE_INDEX.id -> unit
      val iter :
        Rapids.DOUBLE_INDEX.t ->
        (Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.elt -> unit) -> unit
      val set_watcher :
        Rapids.DOUBLE_INDEX.t ->
        (Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.elt -> unit) -> unit
    end
  module type VERSION_POOL =
    sig
      type version
      type handle
      type id
      type t
      val create : unit -> Rapids.VERSION_POOL.t
      val register :
        Rapids.VERSION_POOL.t ->
        Rapids.VERSION_POOL.version -> Rapids.VERSION_POOL.handle
      val search :
        Rapids.VERSION_POOL.t ->
        Rapids.VERSION_POOL.version -> Rapids.VERSION_POOL.handle
      val compare_versions :
        Rapids.VERSION_POOL.t ->
        Rapids.VERSION_POOL.handle -> Rapids.VERSION_POOL.handle -> int
      val find :
        Rapids.VERSION_POOL.t ->
        Rapids.VERSION_POOL.id -> Rapids.VERSION_POOL.handle
      val get_version :
        Rapids.VERSION_POOL.handle -> Rapids.VERSION_POOL.version
      val get_id : Rapids.VERSION_POOL.handle -> Rapids.VERSION_POOL.id
      val iter :
        Rapids.VERSION_POOL.t -> (Rapids.VERSION_POOL.handle -> unit) -> unit
      val scribe_id :
        'Conduit.conduit -> '-> Rapids.VERSION_POOL.id -> unit
      val io_id : Rapids.VERSION_POOL.id Io.literate
    end
  module type LABELED_INDEX =
    sig
      type data
      type elt
      type id
      type t
      val create : unit -> Rapids.LABELED_INDEX.t
      val register :
        Rapids.LABELED_INDEX.t ->
        Rapids.LABELED_INDEX.elt ->
        (unit -> Rapids.LABELED_INDEX.data) -> Rapids.LABELED_INDEX.id
      val search :
        Rapids.LABELED_INDEX.t ->
        Rapids.LABELED_INDEX.elt -> Rapids.LABELED_INDEX.id
      val find :
        Rapids.LABELED_INDEX.t ->
        Rapids.LABELED_INDEX.id -> Rapids.LABELED_INDEX.elt
      val data :
        Rapids.LABELED_INDEX.t ->
        Rapids.LABELED_INDEX.id -> Rapids.LABELED_INDEX.data
      val compare_id :
        Rapids.LABELED_INDEX.id -> Rapids.LABELED_INDEX.id -> int
      val scribe_id :
        'Conduit.conduit -> '-> Rapids.LABELED_INDEX.id -> unit
      val io_id : Rapids.LABELED_INDEX.id Io.literate
      val iter :
        Rapids.LABELED_INDEX.t ->
        (Rapids.LABELED_INDEX.id ->
         Rapids.LABELED_INDEX.elt -> Rapids.LABELED_INDEX.data -> unit) ->
        unit
      val set_watcher :
        Rapids.LABELED_INDEX.t ->
        (Rapids.LABELED_INDEX.id ->
         Rapids.LABELED_INDEX.elt -> Rapids.LABELED_INDEX.data -> unit) ->
        unit
    end
  module type CHRONOLOGICAL_MAP =
    sig
      type t
      type set
      type elt
      type day = int
      val io : Rapids.CHRONOLOGICAL_MAP.t Io.literate
      val create : unit -> Rapids.CHRONOLOGICAL_MAP.t
      val iter :
        (Rapids.CHRONOLOGICAL_MAP.day -> Rapids.CHRONOLOGICAL_MAP.set -> unit) ->
        Rapids.CHRONOLOGICAL_MAP.t -> unit
      val range :
        Rapids.CHRONOLOGICAL_MAP.t ->
        Rapids.CHRONOLOGICAL_MAP.day * Rapids.CHRONOLOGICAL_MAP.day
      val get :
        Rapids.CHRONOLOGICAL_MAP.t ->
        Rapids.CHRONOLOGICAL_MAP.day -> Rapids.CHRONOLOGICAL_MAP.set
      val add :
        Rapids.CHRONOLOGICAL_MAP.t ->
        Rapids.CHRONOLOGICAL_MAP.day ->
        Rapids.CHRONOLOGICAL_MAP.day -> Rapids.CHRONOLOGICAL_MAP.set -> unit
    end
  type archive_name = string
  type architecture_name = string
  type unit_name = string
  type version_name = string
  type source_name = Rapids.unit_name * Rapids.version_name
  type source_version_name = Rapids.version_name
  type version_number
  type release_number
  type version_id
  type release_id
  type unit_id
  type source_id
  type architecture_id
  type package_id
  type archive_id
  type glob = string
  type archive
  module Architecture_name :
    sig
      type t = architecture_name
      val compare : t -> t -> int
      val scribe : 'Conduit.conduit -> '-> t -> unit
      val io : t Io.literate
    end
  module Architecture_index :
    sig
      type elt = architecture_name
      type id = architecture_id
      type t
      val create : unit -> t
      val register : t -> elt -> id
      val search : t -> elt -> id
      val find : t -> id -> elt
      val compare_id : id -> id -> int
      val scribe_id : 'Conduit.conduit -> '-> id -> unit
      val io_id : id Io.literate
      val iter : t -> (id -> elt -> unit) -> unit
      val set_watcher : t -> (id -> elt -> unit) -> unit
    end
  module Unit_name :
    sig
      type t = unit_name
      val compare : t -> t -> int
      val scribe : 'Conduit.conduit -> '-> t -> unit
      val io : t Io.literate
    end
  module Package_ID :
    sig
      type id = package_id
      val to_int : id -> int
      val from_int : int -> id
      val compare : id -> id -> int
      val succ : id -> id
      val scribe : 'Conduit.conduit -> '-> id -> unit
      val zero : id
      val sweep : id -> (id -> unit) -> unit
      val io : id Io.literate
    end
  module Package_set :
    sig
      type elt = package_id
      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 io : t Io.literate
    end
  module Unit_index :
    sig
      type data
      type elt = unit_name
      type id = unit_id
      type t
      val create : unit -> t
      val register : t -> elt -> (unit -> data) -> id
      val search : t -> elt -> id
      val find : t -> id -> elt
      val data : t -> id -> data
      val compare_id : id -> id -> int
      val scribe_id : 'Conduit.conduit -> '-> id -> unit
      val io_id : id Io.literate
      val iter : t -> (id -> elt -> data -> unit) -> unit
      val set_watcher : t -> (id -> elt -> data -> unit) -> unit
    end
  module Unit_set :
    sig
      type elt = unit_id
      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 io : t Io.literate
    end
  module Source_name :
    sig
      type t = source_name
      val compare : t -> t -> int
      val scribe : 'Conduit.conduit -> '-> t -> unit
      val io : t Io.literate
    end
  module Source_index :
    sig
      type elt = source_name
      type id = source_id
      type t
      val create : unit -> t
      val register : t -> elt -> id
      val search : t -> elt -> id
      val find : t -> id -> elt
      val compare_id : id -> id -> int
      val scribe_id : 'Conduit.conduit -> '-> id -> unit
      val io_id : id Io.literate
      val iter : t -> (id -> elt -> unit) -> unit
      val set_watcher : t -> (id -> elt -> unit) -> unit
    end
  module Source_set :
    sig
      type elt = source_id
      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 io : t Io.literate
    end
  module Version_index :
    sig
      type version = string
      type handle = version_number
      type id = version_id
      type t
      val create : unit -> t
      val register : t -> version -> handle
      val search : t -> version -> handle
      val compare_versions : t -> handle -> handle -> int
      val find : t -> id -> handle
      val get_version : handle -> version
      val get_id : handle -> id
      val iter : t -> (handle -> unit) -> unit
      val scribe_id : 'Conduit.conduit -> '-> id -> unit
      val io_id : id Io.literate
    end
  module Release_index :
    sig
      type version = string option
      type handle = release_number
      type id = release_id
      type t
      val create : unit -> t
      val register : t -> version -> handle
      val search : t -> version -> handle
      val compare_versions : t -> handle -> handle -> int
      val find : t -> id -> handle
      val get_version : handle -> version
      val get_id : handle -> id
      val iter : t -> (handle -> unit) -> unit
      val scribe_id : 'Conduit.conduit -> '-> id -> unit
      val io_id : id Io.literate
    end
  module Archive_index :
    sig
      type data = archive
      type elt = archive_name
      type id = archive_id
      type t
      val create : unit -> t
      val register : t -> elt -> (unit -> data) -> id
      val search : t -> elt -> id
      val find : t -> id -> elt
      val data : t -> id -> data
      val compare_id : id -> id -> int
      val scribe_id : 'Conduit.conduit -> '-> id -> unit
      val io_id : id Io.literate
      val iter : t -> (id -> elt -> data -> unit) -> unit
      val set_watcher : t -> (id -> elt -> data -> unit) -> unit
    end
  module Archive_set :
    sig
      type elt = archive_id
      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 io : t Io.literate
    end
  type package_name =
      Rapids.unit_id * Rapids.version_id * Rapids.release_id *
      Rapids.architecture_id
  type package_extra
  type package =
      (Rapids.package_extra, Rapids.unit_id,
       Rapids.version_number * Rapids.release_number, Rapids.glob,
       Rapids.architecture_id, Rapids.source_id)
      Napkin.package
  module Package_index :
    sig
      type e1 = package_name
      type e2 = package
      type elt = e1 * e2
      type id = package_id
      type t
      val create : unit -> t
      val register : t -> elt -> id
      val replace : t -> elt -> unit
      val find : t -> id -> elt
      val search1 : t -> e1 -> id
      val search2 : t -> e2 -> id
      val compare_id : id -> id -> int
      val scribe_id : 'Conduit.conduit -> '-> id -> unit
      val iter : t -> (id -> elt -> unit) -> unit
      val set_watcher : t -> (id -> elt -> unit) -> unit
    end
  type package_set = Rapids.Package_set.t
  type unit_set = Rapids.Unit_set.t
  type source_set = Rapids.Source_set.t
  type archive_set = Rapids.Archive_set.t
  module Chronology :
    sig
      type t
      type set = Package_set.t
      type elt = Package_ID.id
      type day = int
      val io : t Io.literate
      val create : unit -> t
      val iter : (day -> set -> unit) -> t -> unit
      val range : t -> day * day
      val get : t -> day -> set
      val add : t -> day -> day -> set -> unit
    end
  type db
  val create_database : unit -> Rapids.db
  val add_package : Rapids.db -> Napkin.default_package -> Rapids.package_id
  val replace_package : Rapids.db -> Rapids.package -> unit
  val self_test : Rapids.db -> unit
  val get_liquid : Rapids.db -> Rapids.liquid option
  val get_package_index : Rapids.db -> Rapids.Package_index.t
  val get_unit_index : Rapids.db -> Rapids.Unit_index.t
  val get_version_index : Rapids.db -> Rapids.Version_index.t
  val get_release_index : Rapids.db -> Rapids.Release_index.t
  val get_architecture_index : Rapids.db -> Rapids.Architecture_index.t
  val get_archive_index : Rapids.db -> Rapids.Archive_index.t
  val get_source_index : Rapids.db -> Rapids.Source_index.t
  val set_liquid : Rapids.db -> Rapids.liquid -> unit
  val split_version : string -> string * string option
  val add_archive : Rapids.db -> Rapids.archive_name -> Rapids.archive_id
  val get_archive : Rapids.db -> Rapids.archive_id -> Rapids.archive
  val get_archive_contents :
    Rapids.archive -> Lifetime.day -> Rapids.package_set
  val iterate_over_archive :
    (Lifetime.day -> Rapids.package_set -> unit) -> Rapids.archive -> unit
  val archive_range :
    Rapids.db -> Rapids.archive -> Lifetime.day * Lifetime.day
  val add_packages_to_archive :
    Rapids.db ->
    Rapids.archive -> Rapids.package_set -> Lifetime.lifetime -> unit
  module Functions :
    sig
      val packages : Rapids.db -> Rapids.package_set
      val units : Rapids.db -> Rapids.unit_set
      val sources : Rapids.db -> Rapids.source_set
      val archives : Rapids.db -> Rapids.archive_set
      val unit_id_to_package_set :
        Rapids.db -> Rapids.unit_id -> Rapids.package_set
      val unit_id_to_providers :
        Rapids.db ->
        Rapids.unit_id ->
        (Rapids.package_id, Rapids.version_number * Rapids.release_number,
         Rapids.glob)
        Napkin.versioned list
      val select :
        Rapids.db ->
        (Rapids.Unit_index.id,
         Rapids.Version_index.handle * Rapids.Release_index.handle, string)
        Napkin.versioned -> Rapids.package_set
      val dependency_closure :
        Rapids.db ->
        ?relations:[ `Dep | `Pre ] list ->
        Rapids.package_set -> Rapids.package_set
      val dependency_path :
        ?conjunctive:bool ->
        Rapids.db ->
        Rapids.package_set ->
        Rapids.package_id ->
        Rapids.package_id -> Rapids.package_id list option
      val conflicts : Rapids.db -> Rapids.package_set -> Rapids.package_set
      val get_package_from_id :
        Rapids.db -> Rapids.package_id -> Rapids.package
      val scribe_package :
        Rapids.db ->
        'Conduit.conduit ->
        '->
        ?default_architecture:Rapids.architecture_id ->
        Rapids.package -> unit
      val scribe_package_from_id :
        Rapids.db ->
        'Conduit.conduit ->
        '->
        ?default_architecture:Rapids.architecture_id ->
        Rapids.package_id -> unit
      val scribe_unit_from_id :
        Rapids.db -> 'Conduit.conduit -> '-> Rapids.unit_id -> unit
      val scribe_archive_from_id :
        Rapids.db -> 'Conduit.conduit -> '-> Rapids.archive_id -> unit
      val scribe_source_from_id :
        Rapids.db -> 'Conduit.conduit -> '-> Rapids.source_id -> unit
      val scribe_version_from_number :
        Rapids.db ->
        'Conduit.conduit ->
        '-> Rapids.version_number * Rapids.release_number -> unit
    end
end