sig
  type 'a sequence = ('a -> unit) -> unit
  type 'a or_error = ('a, string) CCResult.t
  module Time :
    sig
      val total : unit -> float
      val start : unit -> float
      type timer
      val start_timer : unit -> Utils.Time.timer
      val stop_timer : Utils.Time.timer -> unit
      val get_timer : Utils.Time.timer -> float
    end
  module Section :
    sig
      type t
      val full_name : Utils.Section.t -> string
      val set_debug : Utils.Section.t -> int -> unit
      val clear_debug : Utils.Section.t -> unit
      val get_debug : Utils.Section.t -> int option
      val cur_level : Utils.Section.t -> int
      val iter : (string * Utils.Section.t) Utils.sequence
      val root : Utils.Section.t
      val make :
        ?parent:Utils.Section.t ->
        ?inheriting:Utils.Section.t list -> string -> Utils.Section.t
    end
  val set_debug : int -> unit
  val get_debug : unit -> int
  val debugf :
    ?lock:bool ->
    ?section:Utils.Section.t ->
    int ->
    ('a, Format.formatter, unit, unit) Pervasives.format4 ->
    ('a -> unit) -> unit
  val debug : ?lock:bool -> ?section:Utils.Section.t -> int -> string -> unit
  module Callback :
    sig
      type 'a t
      type callback_id = private int
      val create : unit -> 'a Utils.Callback.t
      val register :
        'a Utils.Callback.t -> f:'a -> Utils.Callback.callback_id
      val remove : 'a Utils.Callback.t -> id:int -> unit
      val iter : 'a Utils.Callback.t -> f:('a -> unit) -> unit
      val call1 : ('a -> unit) Utils.Callback.t -> 'a -> unit
      val call2 : ('a -> 'b -> unit) Utils.Callback.t -> 'a -> 'b -> unit
    end
  val vec_fold_map :
    ('b -> 'a -> 'b * 'c) ->
    'b -> ('a, 'd) CCVector.t -> 'b * ('c, [ `RW ]) CCVector.t
  val fold_map : ('b -> 'a -> 'b * 'c) -> 'b -> 'a list -> 'b * 'c list
  val fold_mapi :
    f:(int -> 'b -> 'a -> 'b * 'c) -> x:'b -> 'a list -> 'b * 'c list
  val filteri : (int -> 'a -> bool) -> 'a list -> 'a list
  val singleton_if : bool -> f:('a -> 'b) -> 'a -> 'b list
  val arg_choice : (string * 'a) list -> ('a -> unit) -> Arg.spec
  type warning = Warn_overlapping_match | Warn_model_parsing_error
  val toggle_warning : Utils.warning -> bool -> unit
  val is_warning_enabled : Utils.warning -> bool
  val warning : Utils.warning -> string -> unit
  val warningf :
    Utils.warning ->
    ('a, Format.formatter, unit, unit) Pervasives.format4 -> 'a
  val options_warnings_ : (Arg.key * Arg.spec * Arg.doc) list
  val options_others_ : (Arg.key * Arg.spec * Arg.doc) list Pervasives.ref
  val add_option : Arg.key * Arg.spec * Arg.doc -> unit
  exception NotImplemented of string
  val pp_seq :
    ?sep:string -> 'a CCFormat.printer -> 'a Sequence.t CCFormat.printer
  val pp_list :
    ?sep:string -> 'a CCFormat.printer -> 'a list CCFormat.printer
  val pp_error_prefix : unit CCFormat.printer
  val err_sprintf :
    ('a, Format.formatter, unit, string) Pervasives.format4 -> 'a
  val not_implemented : string -> 'a
  val not_implementedf :
    ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
  val failwithf : ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
  val err_of_exn : exn -> 'a Utils.or_error
  val exn_ksprintf :
    f:(string -> exn) ->
    ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
  val ignore_catch : ('a -> 'b) -> 'a -> unit
end