sig
  module type S_no_log =
    sig
      val add_group : ?memo:bool -> string -> Cmdline.Group.t
      module Help : Parameter_sig.Bool
      module Verbose : Parameter_sig.Int
      module Debug : Parameter_sig.Int
      module Share : Parameter_sig.Specific_dir
      module Session : Parameter_sig.Specific_dir
      module Config : Parameter_sig.Specific_dir
      val help : Cmdline.Group.t
      val messages : Cmdline.Group.t
      val add_plugin_output_aliases : string list -> unit
    end
  module type S =
    sig
      type category
      type warn_category
      val verbose_atleast : int -> bool
      val debug_atleast : int -> bool
      val printf :
        ?level:int ->
        ?dkey:category ->
        ?current:bool ->
        ?source:Filepath.position ->
        ?append:(Format.formatter -> unit) ->
        ?header:(Format.formatter -> unit) ->
        ('a, Format.formatter, unit) format -> 'a
      val result : ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val feedback :
        ?ontty:Log.ontty ->
        ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val debug : ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val warning : ?wkey:warn_category -> 'Log.pretty_printer
      val error : 'Log.pretty_printer
      val abort : ('a, 'b) Log.pretty_aborter
      val failure : 'Log.pretty_printer
      val fatal : ('a, 'b) Log.pretty_aborter
      val verify : bool -> ('a, bool) Log.pretty_aborter
      val not_yet_implemented :
        ('a, Format.formatter, unit, 'b) format4 -> 'a
      val deprecated : string -> now:string -> ('-> 'b) -> '-> 'b
      val with_result :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_warning :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_error :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_failure :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val log :
        ?kind:Log.kind -> ?verbose:int -> ?debug:int -> 'Log.pretty_printer
      val logwith :
        (Log.event option -> 'b) ->
        ?wkey:warn_category ->
        ?emitwith:(Log.event -> unit) ->
        ?once:bool -> ('a, 'b) Log.pretty_aborter
      val register : Log.kind -> (Log.event -> unit) -> unit
      val register_tag_handlers :
        (string -> string) * (string -> string) -> unit
      val register_category : string -> category
      val pp_category : Format.formatter -> category -> unit
      val dkey_name : category -> string
      val is_registered_category : string -> bool
      val get_category : string -> category option
      val get_all_categories : unit -> category list
      val add_debug_keys : category -> unit
      val del_debug_keys : category -> unit
      val get_debug_keys : unit -> category list
      val is_debug_key_enabled : category -> bool
      val get_debug_keyset : unit -> category list
      val register_warn_category : string -> warn_category
      val is_warn_category : string -> bool
      val pp_warn_category : Format.formatter -> warn_category -> unit
      val pp_all_warn_categories_status : unit -> unit
      val wkey_name : warn_category -> string
      val get_warn_category : string -> warn_category option
      val get_all_warn_categories : unit -> warn_category list
      val get_all_warn_categories_status :
        unit -> (warn_category * Log.warn_status) list
      val set_warn_status : warn_category -> Log.warn_status -> unit
      val get_warn_status : warn_category -> Log.warn_status
      val add_group : ?memo:bool -> string -> Cmdline.Group.t
      module Help : Parameter_sig.Bool
      module Verbose : Parameter_sig.Int
      module Debug : Parameter_sig.Int
      module Share : Parameter_sig.Specific_dir
      module Session : Parameter_sig.Specific_dir
      module Config : Parameter_sig.Specific_dir
      val help : Cmdline.Group.t
      val messages : Cmdline.Group.t
      val add_plugin_output_aliases : string list -> unit
    end
  type plugin = private {
    p_name : string;
    p_shortname : string;
    p_help : string;
    p_parameters : (string, Typed_parameter.t list) Stdlib.Hashtbl.t;
  }
  module type General_services =
    sig
      type category
      type warn_category
      val verbose_atleast : int -> bool
      val debug_atleast : int -> bool
      val printf :
        ?level:int ->
        ?dkey:category ->
        ?current:bool ->
        ?source:Filepath.position ->
        ?append:(Format.formatter -> unit) ->
        ?header:(Format.formatter -> unit) ->
        ('a, Format.formatter, unit) format -> 'a
      val result : ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val feedback :
        ?ontty:Log.ontty ->
        ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val debug : ?level:int -> ?dkey:category -> 'Log.pretty_printer
      val warning : ?wkey:warn_category -> 'Log.pretty_printer
      val error : 'Log.pretty_printer
      val abort : ('a, 'b) Log.pretty_aborter
      val failure : 'Log.pretty_printer
      val fatal : ('a, 'b) Log.pretty_aborter
      val verify : bool -> ('a, bool) Log.pretty_aborter
      val not_yet_implemented :
        ('a, Format.formatter, unit, 'b) format4 -> 'a
      val deprecated : string -> now:string -> ('-> 'b) -> '-> 'b
      val with_result :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_warning :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_error :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val with_failure :
        (Log.event option -> 'b) -> ('a, 'b) Log.pretty_aborter
      val log :
        ?kind:Log.kind -> ?verbose:int -> ?debug:int -> 'Log.pretty_printer
      val logwith :
        (Log.event option -> 'b) ->
        ?wkey:warn_category ->
        ?emitwith:(Log.event -> unit) ->
        ?once:bool -> ('a, 'b) Log.pretty_aborter
      val register : Log.kind -> (Log.event -> unit) -> unit
      val register_tag_handlers :
        (string -> string) * (string -> string) -> unit
      val register_category : string -> category
      val pp_category : Format.formatter -> category -> unit
      val dkey_name : category -> string
      val is_registered_category : string -> bool
      val get_category : string -> category option
      val get_all_categories : unit -> category list
      val add_debug_keys : category -> unit
      val del_debug_keys : category -> unit
      val get_debug_keys : unit -> category list
      val is_debug_key_enabled : category -> bool
      val get_debug_keyset : unit -> category list
      val register_warn_category : string -> warn_category
      val is_warn_category : string -> bool
      val pp_warn_category : Format.formatter -> warn_category -> unit
      val pp_all_warn_categories_status : unit -> unit
      val wkey_name : warn_category -> string
      val get_warn_category : string -> warn_category option
      val get_all_warn_categories : unit -> warn_category list
      val get_all_warn_categories_status :
        unit -> (warn_category * Log.warn_status) list
      val set_warn_status : warn_category -> Log.warn_status -> unit
      val get_warn_status : warn_category -> Log.warn_status
      val add_group : ?memo:bool -> string -> Cmdline.Group.t
      module Help : Parameter_sig.Bool
      module Verbose : Parameter_sig.Int
      module Debug : Parameter_sig.Int
      module Share : Parameter_sig.Specific_dir
      module Session : Parameter_sig.Specific_dir
      module Config : Parameter_sig.Specific_dir
      val help : Cmdline.Group.t
      val messages : Cmdline.Group.t
      val add_plugin_output_aliases : string list -> unit
      val no_element_of_string : string -> 'a
      module Bool :
        functor
          (X : sig
                 val option_name : string
                 val help : string
                 val default : bool
               end->
          Parameter_sig.Bool
      module Action : functor (X : Parameter_sig.Input-> Parameter_sig.Bool
      module False : functor (X : Parameter_sig.Input-> Parameter_sig.Bool
      module True : functor (X : Parameter_sig.Input-> Parameter_sig.Bool
      module WithOutput :
        functor
          (X : sig
                 val option_name : string
                 val help : string
                 val output_by_default : bool
               end->
          Parameter_sig.With_output
      module Int :
        functor
          (X : sig
                 val option_name : string
                 val help : string
                 val arg_name : string
                 val default : int
               end->
          Parameter_sig.Int
      module Zero :
        functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.Int
      module String :
        functor
          (X : sig
                 val option_name : string
                 val help : string
                 val arg_name : string
                 val default : string
               end->
          Parameter_sig.String
      module Empty_string :
        functor (X : Parameter_sig.Input_with_arg-> Parameter_sig.String
      exception Cannot_build of string
      module Make_set :
        functor
          (E : sig
                 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 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 choose : t -> elt
                     val find : elt -> t -> elt
                     val of_list : elt list -> t
                     val min_elt : t -> elt
                     val max_elt : t -> elt
                     val split : elt -> t -> t * bool * t
                     val nearest_elt_le : elt -> t -> elt
                     val nearest_elt_ge : elt -> t -> elt
                     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 Map :
                   sig
                     type key = t
                     type +'a t
                     val empty : 'a t
                     val is_empty : 'a t -> bool
                     val mem : key -> 'a t -> bool
                     val add : key -> '-> 'a t -> 'a t
                     val singleton : key -> '-> 'a t
                     val remove : key -> 'a t -> 'a t
                     val merge :
                       (key -> 'a option -> 'b option -> 'c option) ->
                       'a t -> 'b t -> 'c t
                     val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                     val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                     val iter : (key -> '-> unit) -> 'a t -> unit
                     val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                     val for_all : (key -> '-> bool) -> 'a t -> bool
                     val exists : (key -> '-> bool) -> 'a t -> bool
                     val filter : (key -> '-> bool) -> 'a t -> 'a t
                     val partition :
                       (key -> '-> bool) -> 'a t -> 'a t * 'a t
                     val cardinal : 'a t -> int
                     val bindings : 'a t -> (key * 'a) list
                     val min_binding : 'a t -> key * 'a
                     val max_binding : 'a t -> key * 'a
                     val choose : 'a t -> key * 'a
                     val split : key -> 'a t -> 'a t * 'a option * 'a t
                     val find : key -> 'a t -> 'a
                     val find_opt : key -> 'a t -> 'a option
                     val map : ('-> 'b) -> 'a t -> 'b t
                     val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                     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 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 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
                     val iter_sorted :
                       ?cmp:(key -> key -> int) ->
                       (key -> '-> unit) -> 'a t -> unit
                     val fold_sorted :
                       ?cmp:(key -> key -> int) ->
                       (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                     val iter_sorted_by_entry :
                       cmp:(key * '-> key * '-> int) ->
                       (key -> '-> unit) -> 'a t -> unit
                     val fold_sorted_by_entry :
                       cmp:(key * '-> key * '-> int) ->
                       (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                     val iter_sorted_by_value :
                       cmp:('-> '-> int) ->
                       (key -> '-> unit) -> 'a t -> unit
                     val fold_sorted_by_value :
                       cmp:('-> '-> int) ->
                       (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                     val find_opt : 'a t -> key -> 'a option
                     val find_def : 'a t -> key -> '-> 'a
                     val memo : 'a t -> key -> (key -> 'a) -> 'a
                     val structural_descr :
                       Structural_descr.t -> Structural_descr.t
                     val make_type : 'Type.t -> 'a t Type.t
                     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
                 val of_string : string -> t
                 val to_string : t -> string
                 val of_singleton_string : string -> Set.t
               end) (X : sig
                           val option_name : string
                           val help : string
                           val arg_name : string
                           val dependencies : State.t list
                           val default : E.Set.t
                         end->
          sig
            type t = E.Set.t
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = E.t
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val mem : elt -> bool
            val exists : (elt -> bool) -> bool
          end
      module String_set :
        functor (X : Parameter_sig.Input_with_arg->
          Parameter_sig.String_set
      module Filled_string_set :
        functor
          (X : sig
                 val option_name : string
                 val help : string
                 val arg_name : string
                 val default : Datatype.String.Set.t
               end->
          Parameter_sig.String_set
      module Kernel_function_set :
        functor (X : Parameter_sig.Input_with_arg->
          Parameter_sig.Kernel_function_set
      module Fundec_set :
        functor (X : Parameter_sig.Input_with_arg->
          Parameter_sig.Fundec_set
      module Make_list :
        functor
          (E : sig
                 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
                 val of_string : string -> t
                 val to_string : t -> string
                 val of_singleton_string : string -> t list
               end) (X : sig
                           val option_name : string
                           val help : string
                           val arg_name : string
                           val dependencies : State.t list
                           val default : E.t list
                         end->
          sig
            type t = E.t list
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = E.t
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val append_before : t -> unit
            val append_after : t -> unit
          end
      module String_list :
        functor (X : Parameter_sig.Input_with_arg->
          Parameter_sig.String_list
      module Make_map :
        functor
          (K : Parameter_sig.String_datatype_with_collections) (V : sig
                                                                    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
                                                                    type key =
                                                                    K.t
                                                                    val of_string :
                                                                    key:
                                                                    key ->
                                                                    prev:
                                                                    t option ->
                                                                    string
                                                                    option ->
                                                                    t option
                                                                    val to_string :
                                                                    key:
                                                                    key ->
                                                                    t option ->
                                                                    string
                                                                    option
                                                                    end) (X : 
          sig
            val option_name : string
            val help : string
            val arg_name : string
            val dependencies : State.t list
            val default : V.t K.Map.t
          end->
          sig
            type key = K.t
            type value = V.t
            type t = V.t K.Map.t
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = key * value option
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val find : key -> value
            val mem : key -> bool
          end
      module String_map :
        functor
          (V : sig
                 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
                 type key = string
                 val of_string :
                   key:key -> prev:t option -> string option -> t option
                 val to_string : key:key -> t option -> string option
               end) (X : sig
                           val option_name : string
                           val help : string
                           val arg_name : string
                           val default : V.t Datatype.String.Map.t
                         end->
          sig
            type key = string
            type value = V.t
            type t = V.t Datatype.String.Map.t
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = key * value option
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val find : key -> value
            val mem : key -> bool
          end
      module Kernel_function_map :
        functor
          (V : sig
                 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
                 type key = Cil_types.kernel_function
                 val of_string :
                   key:key -> prev:t option -> string option -> t option
                 val to_string : key:key -> t option -> string option
               end) (X : sig
                           val option_name : string
                           val help : string
                           val arg_name : string
                           val default : V.t Cil_datatype.Kf.Map.t
                         end->
          sig
            type key = Cil_types.kernel_function
            type value = V.t
            type t = V.t Cil_datatype.Kf.Map.t
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = key * value option
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val find : key -> value
            val mem : key -> bool
          end
      module Make_multiple_map :
        functor
          (K : Parameter_sig.String_datatype_with_collections) (V : sig
                                                                    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
                                                                    type key =
                                                                    K.t
                                                                    val of_string :
                                                                    key:
                                                                    key ->
                                                                    prev:
                                                                    t list
                                                                    option ->
                                                                    string
                                                                    option ->
                                                                    t option
                                                                    val to_string :
                                                                    key:
                                                                    key ->
                                                                    t option ->
                                                                    string
                                                                    option
                                                                    end) (X : 
          sig
            val option_name : string
            val help : string
            val arg_name : string
            val dependencies : State.t list
            val default : V.t list K.Map.t
          end->
          sig
            type key = K.t
            type value = V.t
            type t = V.t list K.Map.t
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = key * value list
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val find : key -> value list
            val mem : key -> bool
          end
      module String_multiple_map :
        functor
          (V : sig
                 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
                 type key = string
                 val of_string :
                   key:key -> prev:t list option -> string option -> t option
                 val to_string : key:key -> t option -> string option
               end) (X : sig
                           val option_name : string
                           val help : string
                           val arg_name : string
                           val default : V.t list Datatype.String.Map.t
                         end->
          sig
            type key = string
            type value = V.t
            type t = V.t list Datatype.String.Map.t
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = key * value list
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val find : key -> value list
            val mem : key -> bool
          end
      module Kernel_function_multiple_map :
        functor
          (V : sig
                 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
                 type key = Cil_types.kernel_function
                 val of_string :
                   key:key -> prev:t list option -> string option -> t option
                 val to_string : key:key -> t option -> string option
               end) (X : sig
                           val option_name : string
                           val help : string
                           val arg_name : string
                           val default : V.t list Cil_datatype.Kf.Map.t
                         end->
          sig
            type key = Cil_types.kernel_function
            type value = V.t
            type t = V.t list Cil_datatype.Kf.Map.t
            val set : t -> unit
            val add_set_hook : (t -> t -> unit) -> unit
            val add_update_hook : (t -> t -> unit) -> unit
            val get : unit -> t
            val clear : unit -> unit
            val is_default : unit -> bool
            val option_name : string
            val print_help : Format.formatter -> unit
            val self : State.t
            val name : string
            val mark_as_computed : ?project:Project.t -> unit -> unit
            val is_computed : ?project:Project.t -> unit -> bool
            module Datatype : Datatype.S
            val add_hook_on_update : (Datatype.t -> unit) -> unit
            val howto_marshal :
              (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
            val equal : t -> t -> bool
            val add_aliases : string list -> unit
            val is_set : unit -> bool
            val unsafe_set : t -> unit
            val parameter : Typed_parameter.t
            type elt = key * value list
            val is_empty : unit -> bool
            val iter : (elt -> unit) -> unit
            val fold : (elt -> '-> 'a) -> '-> 'a
            val add : elt -> unit
            module As_string : Parameter_sig.String
            module Category :
              sig
                type elt = elt
                type t = elt Parameter_category.t
                val none : t
                val default : unit -> t
                val all : unit -> t
                val set_default : t -> unit
                val add :
                  string ->
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all :
                  State.t list -> elt Parameter_category.accessor -> t
                val enable_all_as : t -> unit
              end
            val find : key -> value list
            val mem : key -> bool
          end
      val parameters : unit -> Typed_parameter.t list
    end
  val register_kernel : unit -> unit
  module Register :
    functor
      (P : sig val name : string val shortname : string val help : string end->
      General_services
  val is_share_visible : unit -> unit
  val is_session_visible : unit -> unit
  val is_config_visible : unit -> unit
  val plugin_subpath : string -> unit
  val default_msg_keys : string list -> unit
  val get_from_shortname : string -> Plugin.plugin
  val get_from_name : string -> Plugin.plugin
  val is_present : string -> bool
  val get : string -> Plugin.plugin
  val iter_on_plugins : (Plugin.plugin -> unit) -> unit
  val positive_debug_ref : int Stdlib.ref
  val session_is_set_ref : (unit -> bool) Stdlib.ref
  val session_ref : (unit -> string) Stdlib.ref
  val config_is_set_ref : (unit -> bool) Stdlib.ref
  val config_ref : (unit -> string) Stdlib.ref
end