sig
  type mw_version = { mw_major : int; mw_minor : int; }
  val user_agent : string
  module Set :
    sig
      type 'a t
      type 'a enumerable = 'a t
      type 'a mappable = 'a t
      val empty : 'a t
      val create : ('a -> 'a -> int) -> 'a t
      val singleton : ?cmp:('a -> 'a -> int) -> 'a -> 'a t
      val is_empty : 'a t -> bool
      val mem : 'a -> 'a t -> bool
      val add : 'a -> 'a t -> 'a t
      val remove : 'a -> 'a t -> 'a t
      val iter : ('a -> unit) -> 'a t -> unit
      val map : ('a -> 'a) -> 'a t -> 'a t
      val filter_map : ('a -> 'b option) -> 'a t -> 'b t
      val fold : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
      val exists : ('a -> bool) -> 'a t -> bool
      val cardinal : 'a t -> int
      val choose : 'a t -> 'a
      val min_elt : 'a t -> 'a
      val max_elt : 'a t -> 'a
      val enum : 'a t -> 'a BatEnum.t
      val of_enum : 'a BatEnum.t -> 'a t
      val of_enum_cmp : cmp:('a -> 'a -> int) -> 'a BatEnum.t -> 'a t
      val of_list : 'a list -> 'a t
      val for_all : ('a -> bool) -> 'a t -> bool
      val partition : ('a -> bool) -> 'a t -> 'a t * 'a t
      val split : 'a -> 'a t -> 'a t * bool * 'a t
      val filter : ('a -> bool) -> 'a t -> 'a t
      val pop : 'a t -> 'a * 'a t
      val union : 'a t -> 'a t -> 'a t
      val diff : 'a t -> 'a t -> 'a t
      val intersect : 'a t -> 'a t -> 'a t
      val subset : 'a t -> 'a t -> bool
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> 'b -> unit) ->
        'a BatInnerIO.output -> 'b t -> unit
    end
  module Map :
    sig
      type ('a, 'b) t
      val empty : ('a, 'b) t
      val is_empty : ('a, 'b) t -> bool
      val create : ('a -> 'a -> int) -> ('a, 'b) t
      val singleton : ?cmp:('a -> 'a -> int) -> 'a -> 'b -> ('a, 'b) t
      val cardinal : ('a, 'b) t -> int
      val add : 'a -> 'b -> ('a, 'b) t -> ('a, 'b) t
      val find : 'a -> ('a, 'b) t -> 'b
      val remove : 'a -> ('a, 'b) t -> ('a, 'b) t
      val mem : 'a -> ('a, 'b) t -> bool
      val exists : 'a -> ('a, 'b) t -> bool
      val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
      val map : ('a -> 'b) -> ('c, 'a) t -> ('c, 'b) t
      val mapi : ('a -> 'b -> 'c) -> ('a, 'b) t -> ('a, 'c) t
      val fold : ('a -> 'b -> 'b) -> ('c, 'a) t -> 'b -> 'b
      val foldi : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
      val filter : ('a -> bool) -> ('b, 'a) t -> ('b, 'a) t
      val filteri : ('a -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t
      val filter_map : ('a -> 'b -> 'c option) -> ('a, 'b) t -> ('a, 'c) t
      val choose : ('a, 'b) t -> 'a * 'b
      val min_binding : ('a, 'b) t -> 'a * 'b
      val max_binding : ('a, 'b) t -> 'a * 'b
      val enum : ('a, 'b) t -> ('a * 'b) BatEnum.t
      val backwards : ('a, 'b) t -> ('a * 'b) BatEnum.t
      val keys : ('a, 'b) t -> 'a BatEnum.t
      val values : ('a, 'b) t -> 'b BatEnum.t
      val of_enum :
        ?cmp:('a -> 'a -> int) -> ('a * 'b) BatEnum.t -> ('a, 'b) t
      val for_all : ('a -> 'b -> bool) -> ('a, 'b) t -> bool
      val exists_f : ('a -> 'b -> bool) -> ('a, 'b) t -> bool
      val partition :
        ('a -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t * ('a, 'b) t
      val add_carry : 'a -> 'b -> ('a, 'b) t -> ('a, 'b) t * 'b option
      val modify : 'a -> ('b -> 'b) -> ('a, 'b) t -> ('a, 'b) t
      val modify_def : 'a -> 'b -> ('a -> 'a) -> ('b, 'a) t -> ('b, 'a) t
      val extract : 'a -> ('a, 'b) t -> 'b * ('a, 'b) t
      val pop : ('a, 'b) t -> ('a * 'b) * ('a, 'b) t
      val union : ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val diff : ('a, 'b) t -> ('a, 'b) t -> ('a, 'b) t
      val intersect :
        ('a -> 'b -> 'c) -> ('d, 'a) t -> ('d, 'b) t -> ('d, 'c) t
      val split : 'a -> ('a, 'b) t -> ('a, 'b) t * 'b option * ('a, 'b) t
      val merge :
        ('a -> 'b option -> 'c option -> 'd option) ->
        ('a, 'b) t -> ('a, 'c) t -> ('a, 'd) t
      val merge_unsafe :
        ('a -> 'b option -> 'c option -> 'd option) ->
        ('a, 'b) t -> ('a, 'c) t -> ('a, 'd) t
      module Exceptionless : sig val find : 'a -> ('a, 'b) t -> 'b option end
      module Infix :
        sig
          val ( --> ) : ('a, 'b) t -> 'a -> 'b
          val ( <-- ) : ('a, 'b) t -> 'a * 'b -> ('a, 'b) t
        end
      val bindings : ('a, 'b) t -> ('a * 'b) list
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> 'b -> unit) ->
        ('a BatInnerIO.output -> 'c -> unit) ->
        'a BatInnerIO.output -> ('b, 'c) t -> unit
    end
end