sig
  module S : Datatype.S_with_collections
  type t = S.t
  type model = S.t
  type tuning = unit -> unit
  type separation = Kernel_function.t -> Separation.clause list
  val repr : Model.model
  val register :
    id:string ->
    ?descr:string ->
    ?tuning:Model.tuning list ->
    ?separation:Model.separation -> unit -> Model.model
  val get_id : Model.model -> string
  val get_descr : Model.model -> string
  val get_emitter : Model.model -> Emitter.t
  val get_separation : Model.model -> Model.separation
  val find : id:string -> Model.model
  val iter : (Model.model -> unit) -> unit
  val with_model : Model.model -> ('-> 'b) -> '-> 'b
  val on_model : Model.model -> (unit -> unit) -> unit
  val get_model : unit -> Model.model
  val is_model_defined : unit -> bool
  type scope = Kernel_function.t option
  val on_scope : Model.scope -> ('-> 'b) -> '-> 'b
  val on_kf : Kernel_function.t -> (unit -> unit) -> unit
  val on_global : (unit -> unit) -> unit
  val get_scope : unit -> Model.scope
  val directory : unit -> string
  module type Entries =
    sig
      type key
      type data
      val name : string
      val compare : Model.Entries.key -> Model.Entries.key -> int
      val pretty : Format.formatter -> Model.Entries.key -> unit
    end
  module type Registry =
    sig
      module E : Entries
      type key = E.key
      type data = E.data
      val mem : Model.Registry.key -> bool
      val find : Model.Registry.key -> Model.Registry.data
      val get : Model.Registry.key -> Model.Registry.data option
      val clear : unit -> unit
      val remove : Model.Registry.key -> unit
      val define : Model.Registry.key -> Model.Registry.data -> unit
      val update : Model.Registry.key -> Model.Registry.data -> unit
      val memoize :
        (Model.Registry.key -> Model.Registry.data) ->
        Model.Registry.key -> Model.Registry.data
      val compile :
        (Model.Registry.key -> Model.Registry.data) ->
        Model.Registry.key -> unit
      val callback :
        (Model.Registry.key -> Model.Registry.data -> unit) -> unit
      val iter : (Model.Registry.key -> Model.Registry.data -> unit) -> unit
      val iter_sorted :
        (Model.Registry.key -> Model.Registry.data -> unit) -> unit
    end
  module Index :
    functor (E : Entries->
      sig
        module E :
          sig
            type key = E.key
            type data = E.data
            val name : string
            val compare : key -> key -> int
            val pretty : Format.formatter -> key -> unit
          end
        type key = E.key
        type data = E.data
        val mem : key -> bool
        val find : key -> data
        val get : key -> data option
        val clear : unit -> unit
        val remove : key -> unit
        val define : key -> data -> unit
        val update : key -> data -> unit
        val memoize : (key -> data) -> key -> data
        val compile : (key -> data) -> key -> unit
        val callback : (key -> data -> unit) -> unit
        val iter : (key -> data -> unit) -> unit
        val iter_sorted : (key -> data -> unit) -> unit
      end
  module Static :
    functor (E : Entries->
      sig
        module E :
          sig
            type key = E.key
            type data = E.data
            val name : string
            val compare : key -> key -> int
            val pretty : Format.formatter -> key -> unit
          end
        type key = E.key
        type data = E.data
        val mem : key -> bool
        val find : key -> data
        val get : key -> data option
        val clear : unit -> unit
        val remove : key -> unit
        val define : key -> data -> unit
        val update : key -> data -> unit
        val memoize : (key -> data) -> key -> data
        val compile : (key -> data) -> key -> unit
        val callback : (key -> data -> unit) -> unit
        val iter : (key -> data -> unit) -> unit
        val iter_sorted : (key -> data -> unit) -> unit
      end
  module type Key =
    sig
      type t
      val compare : Model.Key.t -> Model.Key.t -> int
      val pretty : Format.formatter -> Model.Key.t -> unit
    end
  module type Data =
    sig
      type key
      type data
      val name : string
      val compile : Model.Data.key -> Model.Data.data
    end
  module type Generator =
    sig
      type key
      type data
      val get : Model.Generator.key -> Model.Generator.data
      val mem : Model.Generator.key -> bool
      val clear : unit -> unit
      val remove : Model.Generator.key -> unit
    end
  module Generator :
    functor
      (K : Key) (D : sig
                       type key = K.t
                       type data
                       val name : string
                       val compile : key -> data
                     end->
      sig
        type key = D.key
        type data = D.data
        val get : key -> data
        val mem : key -> bool
        val clear : unit -> unit
        val remove : key -> unit
      end
  module StaticGenerator :
    functor
      (K : Key) (D : sig
                       type key = K.t
                       type data
                       val name : string
                       val compile : key -> data
                     end->
      sig
        type key = D.key
        type data = D.data
        val get : key -> data
        val mem : key -> bool
        val clear : unit -> unit
        val remove : key -> unit
      end
end