sig
  exception Ocsigen_Internal_Error of string
  exception Input_is_too_large
  exception Ocsigen_Bad_Request
  exception Ocsigen_Request_too_long
  val ( >>= ) : 'Lwt.t -> ('-> 'Lwt.t) -> 'Lwt.t
  val ( >|= ) : 'Lwt.t -> ('-> 'b) -> 'Lwt.t
  val ( !! ) : 'Stdlib.Lazy.t -> 'a
  val ( |> ) : '-> ('-> 'b) -> 'b
  val ( @@ ) : ('-> 'b) -> '-> 'b
  external id : '-> 'a = "%identity"
  val comp : ('-> 'b) -> ('-> 'a) -> '-> 'b
  val curry : ('a * '-> 'c) -> '-> '-> 'c
  val uncurry : ('-> '-> 'c) -> 'a * '-> 'c
  module Tuple3 :
    sig
      val fst : 'a * 'b * '-> 'a
      val snd : 'a * 'b * '-> 'b
      val thd : 'a * 'b * '-> 'c
    end
  type poly
  val to_poly : '-> Ocsigen_lib_base.poly
  val from_poly : Ocsigen_lib_base.poly -> 'a
  type yesnomaybe = Yes | No | Maybe
  type ('a, 'b) leftright = Left of '| Right of 'b
  val advert : string
  module Option :
    sig
      type 'a t = 'a option
      val map :
        ('-> 'b) ->
        'Ocsigen_lib_base.Option.t -> 'Ocsigen_lib_base.Option.t
      val get : (unit -> 'a) -> 'Ocsigen_lib_base.Option.t -> 'a
      val get' : '-> 'Ocsigen_lib_base.Option.t -> 'a
      val iter : ('-> unit) -> 'Ocsigen_lib_base.Option.t -> unit
      val return : '-> 'Ocsigen_lib_base.Option.t
      val bind :
        'Ocsigen_lib_base.Option.t ->
        ('-> 'Ocsigen_lib_base.Option.t) -> 'Ocsigen_lib_base.Option.t
      val to_list : 'Ocsigen_lib_base.Option.t -> 'a list
      module Lwt :
        sig
          val map :
            ('-> 'Lwt.t) ->
            'Ocsigen_lib_base.Option.t ->
            'Ocsigen_lib_base.Option.t Lwt.t
          val get :
            (unit -> 'Lwt.t) -> 'Ocsigen_lib_base.Option.t -> 'Lwt.t
          val get' : 'Lwt.t -> 'Ocsigen_lib_base.Option.t -> 'Lwt.t
          val iter :
            ('-> unit Lwt.t) -> 'Ocsigen_lib_base.Option.t -> unit Lwt.t
          val bind :
            'Ocsigen_lib_base.Option.t ->
            ('-> 'Ocsigen_lib_base.Option.t Lwt.t) ->
            'Ocsigen_lib_base.Option.t Lwt.t
        end
    end
  module List :
    sig
      type 'a t = 'a list = [] | (::) of 'a * 'a list
      val length : 'a list -> int
      val compare_lengths : 'a list -> 'b list -> int
      val compare_length_with : 'a list -> int -> int
      val is_empty : 'a list -> bool
      val cons : '-> 'a list -> 'a list
      val hd : 'a list -> 'a
      val tl : 'a list -> 'a list
      val nth : 'a list -> int -> 'a
      val nth_opt : 'a list -> int -> 'a option
      val rev : 'a list -> 'a list
      val init : int -> (int -> 'a) -> 'a list
      val append : 'a list -> 'a list -> 'a list
      val rev_append : 'a list -> 'a list -> 'a list
      val concat : 'a list list -> 'a list
      val flatten : 'a list list -> 'a list
      val equal : ('-> '-> bool) -> 'a list -> 'a list -> bool
      val compare : ('-> '-> int) -> 'a list -> 'a list -> int
      val iter : ('-> unit) -> 'a list -> unit
      val iteri : (int -> '-> unit) -> 'a list -> unit
      val map : ('-> 'b) -> 'a list -> 'b list
      val mapi : (int -> '-> 'b) -> 'a list -> 'b list
      val rev_map : ('-> 'b) -> 'a list -> 'b list
      val filter_map : ('-> 'b option) -> 'a list -> 'b list
      val concat_map : ('-> 'b list) -> 'a list -> 'b list
      val fold_left_map :
        ('acc -> '-> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list
      val fold_left : ('acc -> '-> 'acc) -> 'acc -> 'a list -> 'acc
      val fold_right : ('-> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc
      val iter2 : ('-> '-> unit) -> 'a list -> 'b list -> unit
      val map2 : ('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val rev_map2 : ('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val fold_left2 :
        ('acc -> '-> '-> 'acc) -> 'acc -> 'a list -> 'b list -> 'acc
      val fold_right2 :
        ('-> '-> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'acc
      val for_all : ('-> bool) -> 'a list -> bool
      val exists : ('-> bool) -> 'a list -> bool
      val for_all2 : ('-> '-> bool) -> 'a list -> 'b list -> bool
      val exists2 : ('-> '-> bool) -> 'a list -> 'b list -> bool
      val mem : '-> 'a list -> bool
      val memq : '-> 'a list -> bool
      val find : ('-> bool) -> 'a list -> 'a
      val find_opt : ('-> bool) -> 'a list -> 'a option
      val find_index : ('-> bool) -> 'a list -> int option
      val find_map : ('-> 'b option) -> 'a list -> 'b option
      val find_mapi : (int -> '-> 'b option) -> 'a list -> 'b option
      val filter : ('-> bool) -> 'a list -> 'a list
      val find_all : ('-> bool) -> 'a list -> 'a list
      val filteri : (int -> '-> bool) -> 'a list -> 'a list
      val partition : ('-> bool) -> 'a list -> 'a list * 'a list
      val partition_map :
        ('-> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c list
      val assoc : '-> ('a * 'b) list -> 'b
      val assoc_opt : '-> ('a * 'b) list -> 'b option
      val assq : '-> ('a * 'b) list -> 'b
      val assq_opt : '-> ('a * 'b) list -> 'b option
      val mem_assoc : '-> ('a * 'b) list -> bool
      val mem_assq : '-> ('a * 'b) list -> bool
      val remove_assoc : '-> ('a * 'b) list -> ('a * 'b) list
      val remove_assq : '-> ('a * 'b) list -> ('a * 'b) list
      val split : ('a * 'b) list -> 'a list * 'b list
      val combine : 'a list -> 'b list -> ('a * 'b) list
      val sort : ('-> '-> int) -> 'a list -> 'a list
      val stable_sort : ('-> '-> int) -> 'a list -> 'a list
      val fast_sort : ('-> '-> int) -> 'a list -> 'a list
      val sort_uniq : ('-> '-> int) -> 'a list -> 'a list
      val merge : ('-> '-> int) -> 'a list -> 'a list -> 'a list
      val to_seq : 'a list -> 'Seq.t
      val of_seq : 'Seq.t -> 'a list
      val map_filter : ('-> 'b option) -> 'a list -> 'b list
      val last : 'a list -> 'a
      val assoc_remove : '-> ('a * 'b) list -> 'b * ('a * 'b) list
      val remove_first_if_any : '-> 'a list -> 'a list
      val remove_first_if_any_q : '-> 'a list -> 'a list
      val remove_first : '-> 'a list -> 'a list
      val remove_first_q : '-> 'a list -> 'a list
      val remove_all : '-> 'a list -> 'a list
      val remove_all_q : '-> 'a list -> 'a list
      val remove_all_assoc : '-> ('a * 'b) list -> ('a * 'b) list
      val remove_all_assoc_q : '-> ('a * 'b) list -> ('a * 'b) list
      val is_prefix : 'a list -> 'a list -> bool
      val chop : int -> 'a list -> 'a list
      val split_at : int -> 'a list -> 'a list * 'a list
    end
  module Clist :
    sig
      type 'a t
      type 'a node
      val make : '-> 'Ocsigen_lib_base.Clist.node
      val create : unit -> 'Ocsigen_lib_base.Clist.t
      val insert :
        'Ocsigen_lib_base.Clist.t -> 'Ocsigen_lib_base.Clist.node -> unit
      val remove : 'Ocsigen_lib_base.Clist.node -> unit
      val value : 'Ocsigen_lib_base.Clist.node -> 'a
      val in_list : 'Ocsigen_lib_base.Clist.node -> bool
      val is_empty : 'Ocsigen_lib_base.Clist.t -> bool
      val iter : ('-> unit) -> 'Ocsigen_lib_base.Clist.t -> unit
      val fold_left :
        ('-> '-> 'a) -> '-> 'Ocsigen_lib_base.Clist.t -> 'a
    end
  module Int :
    sig
      module Table :
        sig
          type key = int
          type +!'a t
          val empty : 'a t
          val add : key -> '-> 'a t -> 'a t
          val add_to_list : key -> '-> 'a list t -> 'a list t
          val update : key -> ('a option -> 'a option) -> '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 union : (key -> '-> '-> 'a option) -> '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 min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val to_list : 'a t -> (key * 'a) list
          val of_list : (key * 'a) list -> 'a t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
    end
  module String_base :
    sig
      type t = string
      val make : int -> char -> string
      val init : int -> (int -> char) -> string
      val empty : string
      external length : string -> int = "%string_length"
      external get : string -> int -> char = "%string_safe_get"
      val of_bytes : bytes -> string
      val to_bytes : string -> bytes
      val blit : string -> int -> bytes -> int -> int -> unit
      val concat : string -> string list -> string
      val cat : string -> string -> string
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val starts_with : prefix:string -> string -> bool
      val ends_with : suffix:string -> string -> bool
      val contains_from : string -> int -> char -> bool
      val rcontains_from : string -> int -> char -> bool
      val contains : string -> char -> bool
      val sub : string -> int -> int -> string
      val split_on_char : char -> string -> string list
      val map : (char -> char) -> string -> string
      val mapi : (int -> char -> char) -> string -> string
      val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'acc
      val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'acc
      val for_all : (char -> bool) -> string -> bool
      val exists : (char -> bool) -> string -> bool
      val trim : string -> string
      val escaped : string -> string
      val uppercase_ascii : string -> string
      val lowercase_ascii : string -> string
      val capitalize_ascii : string -> string
      val uncapitalize_ascii : string -> string
      val iter : (char -> unit) -> string -> unit
      val iteri : (int -> char -> unit) -> string -> unit
      val index_from : string -> int -> char -> int
      val index_from_opt : string -> int -> char -> int option
      val rindex_from : string -> int -> char -> int
      val rindex_from_opt : string -> int -> char -> int option
      val index : string -> char -> int
      val index_opt : string -> char -> int option
      val rindex : string -> char -> int
      val rindex_opt : string -> char -> int option
      val to_seq : t -> char Seq.t
      val to_seqi : t -> (int * char) Seq.t
      val of_seq : char Seq.t -> t
      val get_utf_8_uchar : t -> int -> Uchar.utf_decode
      val is_valid_utf_8 : t -> bool
      val get_utf_16be_uchar : t -> int -> Uchar.utf_decode
      val is_valid_utf_16be : t -> bool
      val get_utf_16le_uchar : t -> int -> Uchar.utf_decode
      val is_valid_utf_16le : t -> bool
      val get_uint8 : string -> int -> int
      val get_int8 : string -> int -> int
      val get_uint16_ne : string -> int -> int
      val get_uint16_be : string -> int -> int
      val get_uint16_le : string -> int -> int
      val get_int16_ne : string -> int -> int
      val get_int16_be : string -> int -> int
      val get_int16_le : string -> int -> int
      val get_int32_ne : string -> int -> int32
      val hash : t -> int
      val seeded_hash : int -> t -> int
      val get_int32_be : string -> int -> int32
      val get_int32_le : string -> int -> int32
      val get_int64_ne : string -> int -> int64
      val get_int64_be : string -> int -> int64
      val get_int64_le : string -> int -> int64
      external unsafe_get : string -> int -> char = "%string_unsafe_get"
      external unsafe_blit : string -> int -> bytes -> int -> int -> unit
        = "caml_blit_string" [@@noalloc]
      val remove_spaces : string -> int -> int -> string
      val basic_sep : char -> string -> string * string
      val sep : char -> string -> string * string
      val split : ?multisep:bool -> char -> string -> string list
      val may_append : string -> sep:string -> string -> string
      val may_concat : string -> sep:string -> string -> string
      val first_diff : string -> string -> int -> int -> int
      module Table :
        sig
          type key = string
          type +!'a t
          val empty : 'a t
          val add : key -> '-> 'a t -> 'a t
          val add_to_list : key -> '-> 'a list t -> 'a list t
          val update : key -> ('a option -> 'a option) -> '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 union : (key -> '-> '-> 'a option) -> '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 min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val to_list : 'a t -> (key * 'a) list
          val of_list : (key * 'a) list -> 'a t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
      module Set :
        sig
          type elt = string
          type t
          val empty : t
          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 disjoint : t -> t -> bool
          val diff : t -> t -> t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val min_elt_opt : t -> elt option
          val max_elt : t -> elt
          val max_elt_opt : t -> elt option
          val choose : t -> elt
          val choose_opt : t -> elt option
          val find : elt -> t -> elt
          val find_opt : elt -> t -> elt option
          val find_first : (elt -> bool) -> t -> elt
          val find_first_opt : (elt -> bool) -> t -> elt option
          val find_last : (elt -> bool) -> t -> elt
          val find_last_opt : (elt -> bool) -> t -> elt option
          val iter : (elt -> unit) -> t -> unit
          val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc
          val map : (elt -> elt) -> t -> t
          val filter : (elt -> bool) -> t -> t
          val filter_map : (elt -> elt option) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val split : elt -> t -> t * bool * t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val subset : t -> t -> bool
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val to_list : t -> elt list
          val of_list : elt list -> t
          val to_seq_from : elt -> t -> elt Seq.t
          val to_seq : t -> elt Seq.t
          val to_rev_seq : t -> elt Seq.t
          val add_seq : elt Seq.t -> t -> t
          val of_seq : elt Seq.t -> t
        end
      module Map :
        sig
          type key = string
          type +!'a t
          val empty : 'a t
          val add : key -> '-> 'a t -> 'a t
          val add_to_list : key -> '-> 'a list t -> 'a list t
          val update : key -> ('a option -> 'a option) -> '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 union : (key -> '-> '-> 'a option) -> '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 min_binding_opt : 'a t -> (key * 'a) option
          val max_binding : 'a t -> key * 'a
          val max_binding_opt : 'a t -> (key * 'a) option
          val choose : 'a t -> key * 'a
          val choose_opt : 'a t -> (key * 'a) option
          val find : key -> 'a t -> 'a
          val find_opt : key -> 'a t -> 'a option
          val find_first : (key -> bool) -> 'a t -> key * 'a
          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val find_last : (key -> bool) -> 'a t -> key * 'a
          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
          val map : ('-> 'b) -> 'a t -> 'b t
          val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val filter_map : (key -> '-> 'b option) -> 'a t -> 'b t
          val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
          val split : key -> 'a t -> 'a t * 'a option * 'a t
          val is_empty : 'a t -> bool
          val mem : key -> 'a t -> bool
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val for_all : (key -> '-> bool) -> 'a t -> bool
          val exists : (key -> '-> bool) -> 'a t -> bool
          val to_list : 'a t -> (key * 'a) list
          val of_list : (key * 'a) list -> 'a t
          val to_seq : 'a t -> (key * 'a) Seq.t
          val to_rev_seq : 'a t -> (key * 'a) Seq.t
          val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
          val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
          val of_seq : (key * 'a) Seq.t -> 'a t
        end
    end
  module Url_base :
    sig
      type t = string
      type uri = string
      val make_absolute_url :
        https:bool ->
        host:string ->
        port:int ->
        Ocsigen_lib_base.Url_base.uri -> Ocsigen_lib_base.Url_base.t
      type path = string list
      val remove_dotdot :
        Ocsigen_lib_base.Url_base.path -> Ocsigen_lib_base.Url_base.path
      val remove_end_slash : string -> string
      val remove_internal_slash :
        Ocsigen_lib_base.Url_base.path -> Ocsigen_lib_base.Url_base.path
      val change_empty_list :
        Ocsigen_lib_base.Url_base.path -> Ocsigen_lib_base.Url_base.path
      val add_end_slash_if_missing :
        Ocsigen_lib_base.Url_base.path -> Ocsigen_lib_base.Url_base.path
      val remove_slash_at_end :
        Ocsigen_lib_base.Url_base.path -> Ocsigen_lib_base.Url_base.path
      val remove_slash_at_beginning :
        Ocsigen_lib_base.Url_base.path -> Ocsigen_lib_base.Url_base.path
      val is_prefix_skip_end_slash : string list -> string list -> bool
      val split_fragment : string -> string * string option
      val join_path : Ocsigen_lib_base.Url_base.path -> string
      val split_path : string -> Ocsigen_lib_base.Url_base.path
      val norm_path :
        Ocsigen_lib_base.Url_base.path -> Ocsigen_lib_base.Url_base.path
    end
  val debug : string -> unit
end