sig
  val strf : ('a, Stdlib.Format.formatter, unit, string) Stdlib.format4 -> 'a
  val ( ^ ) : string -> string -> string
  module Char :
    sig
      type t = char
      val of_byte : int -> char
      val unsafe_of_byte : int -> char
      val of_int : int -> char option
      val to_int : char -> int
      val hash : char -> int
      val equal : char -> char -> bool
      val compare : char -> char -> int
      module Ascii :
        sig
          val is_valid : char -> bool
          val is_digit : char -> bool
          val is_hex_digit : char -> bool
          val is_upper : char -> bool
          val is_lower : char -> bool
          val is_letter : char -> bool
          val is_alphanum : char -> bool
          val is_white : char -> bool
          val is_blank : char -> bool
          val is_graphic : char -> bool
          val is_print : char -> bool
          val is_control : char -> bool
          val uppercase : char -> char
          val lowercase : char -> char
          val escape : char -> string
          val escape_char : char -> string
        end
      val pp : Stdlib.Format.formatter -> char -> unit
      val dump : Stdlib.Format.formatter -> char -> unit
    end
  module String :
    sig
      type t = string
      val empty : string
      val v : len:int -> (int -> char) -> string
      val length : string -> int
      val get : string -> int -> char
      val get_byte : string -> int -> int
      val unsafe_get : string -> int -> char
      val unsafe_get_byte : string -> int -> int
      val head : ?rev:bool -> string -> char option
      val get_head : ?rev:bool -> string -> char
      val hash : string -> int
      val append : string -> string -> string
      val concat : ?sep:string -> string list -> string
      val is_empty : string -> bool
      val is_prefix : affix:string -> string -> bool
      val is_infix : affix:string -> string -> bool
      val is_suffix : affix:string -> string -> bool
      val for_all : (char -> bool) -> string -> bool
      val exists : (char -> bool) -> string -> bool
      val equal : string -> string -> bool
      val compare : string -> string -> int
      val with_range : ?first:int -> ?len:int -> string -> string
      val with_index_range : ?first:int -> ?last:int -> string -> string
      val trim : ?drop:(char -> bool) -> string -> string
      val span :
        ?rev:bool ->
        ?min:int ->
        ?max:int -> ?sat:(char -> bool) -> string -> string * string
      val take :
        ?rev:bool ->
        ?min:int -> ?max:int -> ?sat:(char -> bool) -> string -> string
      val drop :
        ?rev:bool ->
        ?min:int -> ?max:int -> ?sat:(char -> bool) -> string -> string
      val cut : ?rev:bool -> sep:string -> string -> (string * string) option
      val cuts :
        ?rev:bool -> ?empty:bool -> sep:string -> string -> string list
      val fields :
        ?empty:bool -> ?is_sep:(char -> bool) -> string -> string list
      type sub
      val sub : ?start:int -> ?stop:int -> string -> Astring.String.sub
      val sub_with_range :
        ?first:int -> ?len:int -> string -> Astring.String.sub
      val sub_with_index_range :
        ?first:int -> ?last:int -> string -> Astring.String.sub
      module Sub :
        sig
          type t = Astring.String.sub
          val empty : Astring.String.sub
          val v : ?start:int -> ?stop:int -> string -> Astring.String.sub
          val start_pos : Astring.String.sub -> int
          val stop_pos : Astring.String.sub -> int
          val base_string : Astring.String.sub -> string
          val length : Astring.String.sub -> int
          val get : Astring.String.sub -> int -> char
          val get_byte : Astring.String.sub -> int -> int
          val unsafe_get : Astring.String.sub -> int -> char
          val unsafe_get_byte : Astring.String.sub -> int -> int
          val head : ?rev:bool -> Astring.String.sub -> char option
          val get_head : ?rev:bool -> Astring.String.sub -> char
          val of_string : string -> Astring.String.sub
          val to_string : Astring.String.sub -> string
          val rebase : Astring.String.sub -> Astring.String.sub
          val hash : Astring.String.sub -> int
          val start : Astring.String.sub -> Astring.String.sub
          val stop : Astring.String.sub -> Astring.String.sub
          val base : Astring.String.sub -> Astring.String.sub
          val tail : ?rev:bool -> Astring.String.sub -> Astring.String.sub
          val extend :
            ?rev:bool ->
            ?max:int ->
            ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub
          val reduce :
            ?rev:bool ->
            ?max:int ->
            ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub
          val extent :
            Astring.String.sub -> Astring.String.sub -> Astring.String.sub
          val overlap :
            Astring.String.sub ->
            Astring.String.sub -> Astring.String.sub option
          val append :
            Astring.String.sub -> Astring.String.sub -> Astring.String.sub
          val concat :
            ?sep:Astring.String.sub ->
            Astring.String.sub list -> Astring.String.sub
          val is_empty : Astring.String.sub -> bool
          val is_prefix :
            affix:Astring.String.sub -> Astring.String.sub -> bool
          val is_infix :
            affix:Astring.String.sub -> Astring.String.sub -> bool
          val is_suffix :
            affix:Astring.String.sub -> Astring.String.sub -> bool
          val for_all : (char -> bool) -> Astring.String.sub -> bool
          val exists : (char -> bool) -> Astring.String.sub -> bool
          val same_base : Astring.String.sub -> Astring.String.sub -> bool
          val equal_bytes : Astring.String.sub -> Astring.String.sub -> bool
          val compare_bytes : Astring.String.sub -> Astring.String.sub -> int
          val equal : Astring.String.sub -> Astring.String.sub -> bool
          val compare : Astring.String.sub -> Astring.String.sub -> int
          val with_range :
            ?first:int ->
            ?len:int -> Astring.String.sub -> Astring.String.sub
          val with_index_range :
            ?first:int ->
            ?last:int -> Astring.String.sub -> Astring.String.sub
          val trim :
            ?drop:(char -> bool) -> Astring.String.sub -> Astring.String.sub
          val span :
            ?rev:bool ->
            ?min:int ->
            ?max:int ->
            ?sat:(char -> bool) ->
            Astring.String.sub -> Astring.String.sub * Astring.String.sub
          val take :
            ?rev:bool ->
            ?min:int ->
            ?max:int ->
            ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub
          val drop :
            ?rev:bool ->
            ?min:int ->
            ?max:int ->
            ?sat:(char -> bool) -> Astring.String.sub -> Astring.String.sub
          val cut :
            ?rev:bool ->
            sep:Astring.String.sub ->
            Astring.String.sub ->
            (Astring.String.sub * Astring.String.sub) option
          val cuts :
            ?rev:bool ->
            ?empty:bool ->
            sep:Astring.String.sub ->
            Astring.String.sub -> Astring.String.sub list
          val fields :
            ?empty:bool ->
            ?is_sep:(char -> bool) ->
            Astring.String.sub -> Astring.String.sub list
          val find :
            ?rev:bool ->
            (char -> bool) -> Astring.String.sub -> Astring.String.sub option
          val find_sub :
            ?rev:bool ->
            sub:Astring.String.sub ->
            Astring.String.sub -> Astring.String.sub option
          val filter :
            (char -> bool) -> Astring.String.sub -> Astring.String.sub
          val filter_map :
            (char -> char option) -> Astring.String.sub -> Astring.String.sub
          val map :
            (char -> char) -> Astring.String.sub -> Astring.String.sub
          val mapi :
            (int -> char -> char) -> Astring.String.sub -> Astring.String.sub
          val fold_left :
            ('-> char -> 'a) -> '-> Astring.String.sub -> 'a
          val fold_right :
            (char -> '-> 'a) -> Astring.String.sub -> '-> 'a
          val iter : (char -> unit) -> Astring.String.sub -> unit
          val iteri : (int -> char -> unit) -> Astring.String.sub -> unit
          val pp : Stdlib.Format.formatter -> Astring.String.sub -> unit
          val dump : Stdlib.Format.formatter -> Astring.String.sub -> unit
          val dump_raw :
            Stdlib.Format.formatter -> Astring.String.sub -> unit
          val of_char : char -> Astring.String.sub
          val to_char : Astring.String.sub -> char option
          val of_bool : bool -> Astring.String.sub
          val to_bool : Astring.String.sub -> bool option
          val of_int : int -> Astring.String.sub
          val to_int : Astring.String.sub -> int option
          val of_nativeint : nativeint -> Astring.String.sub
          val to_nativeint : Astring.String.sub -> nativeint option
          val of_int32 : int32 -> Astring.String.sub
          val to_int32 : Astring.String.sub -> int32 option
          val of_int64 : int64 -> Astring.String.sub
          val to_int64 : Astring.String.sub -> int64 option
          val of_float : float -> Astring.String.sub
          val to_float : Astring.String.sub -> float option
        end
      val find :
        ?rev:bool -> ?start:int -> (char -> bool) -> string -> int option
      val find_sub :
        ?rev:bool -> ?start:int -> sub:string -> string -> int option
      val filter : (char -> bool) -> string -> string
      val filter_map : (char -> char option) -> string -> string
      val map : (char -> char) -> string -> string
      val mapi : (int -> char -> char) -> string -> string
      val fold_left : ('-> char -> 'a) -> '-> string -> 'a
      val fold_right : (char -> '-> 'a) -> string -> '-> 'a
      val iter : (char -> unit) -> string -> unit
      val iteri : (int -> char -> unit) -> string -> unit
      val uniquify : string list -> string list
      module Ascii :
        sig
          val is_valid : string -> bool
          val uppercase : string -> string
          val lowercase : string -> string
          val capitalize : string -> string
          val uncapitalize : string -> string
          val escape : string -> string
          val unescape : string -> string option
          val escape_string : string -> string
          val unescape_string : string -> string option
        end
      val pp : Stdlib.Format.formatter -> string -> unit
      val dump : Stdlib.Format.formatter -> string -> unit
      type set
      module Set :
        sig
          val empty : set
          val is_empty : set -> bool
          val mem : string -> set -> bool
          val add : string -> set -> set
          val singleton : string -> set
          val remove : string -> set -> set
          val union : set -> set -> set
          val inter : set -> set -> set
          val disjoint : set -> set -> bool
          val diff : set -> set -> set
          val compare : set -> set -> int
          val equal : set -> set -> bool
          val subset : set -> set -> bool
          val iter : (string -> unit) -> set -> unit
          val map : (string -> string) -> set -> set
          val fold : (string -> '-> 'a) -> set -> '-> 'a
          val for_all : (string -> bool) -> set -> bool
          val exists : (string -> bool) -> set -> bool
          val filter : (string -> bool) -> set -> set
          val filter_map : (string -> string option) -> set -> set
          val partition : (string -> bool) -> set -> set * set
          val cardinal : set -> int
          val elements : set -> string list
          val min_elt_opt : set -> string option
          val max_elt_opt : set -> string option
          val choose_opt : set -> string option
          val split : string -> set -> set * bool * set
          val find_opt : string -> set -> string option
          val find_first : (string -> bool) -> set -> string
          val find_first_opt : (string -> bool) -> set -> string option
          val find_last : (string -> bool) -> set -> string
          val find_last_opt : (string -> bool) -> set -> string option
          val to_seq_from : string -> set -> string Seq.t
          val to_seq : set -> string Seq.t
          val add_seq : string Seq.t -> set -> set
          val of_seq : string Seq.t -> set
          type t = Astring.String.set
          val min_elt : Astring.String.set -> string option
          val get_min_elt : Astring.String.set -> string
          val max_elt : Astring.String.set -> string option
          val get_max_elt : Astring.String.set -> string
          val choose : Astring.String.set -> string option
          val get_any_elt : Astring.String.set -> string
          val find : string -> Astring.String.set -> string option
          val get : string -> Astring.String.set -> string
          val of_list : string list -> Astring.String.set
          val pp :
            ?sep:(Stdlib.Format.formatter -> unit -> unit) ->
            (Stdlib.Format.formatter -> string -> unit) ->
            Stdlib.Format.formatter -> Astring.String.set -> unit
          val dump : Stdlib.Format.formatter -> Astring.String.set -> unit
        end
      type +'a map
      module Map :
        sig
          val empty : 'a map
          val is_empty : 'a map -> bool
          val mem : string -> 'a map -> bool
          val add : string -> '-> 'a map -> 'a map
          val update : string -> ('a option -> 'a option) -> 'a map -> 'a map
          val singleton : string -> '-> 'a map
          val remove : string -> 'a map -> 'a map
          val merge :
            (string -> 'a option -> 'b option -> 'c option) ->
            'a map -> 'b map -> 'c map
          val union :
            (string -> '-> '-> 'a option) -> 'a map -> 'a map -> 'a map
          val compare : ('-> '-> int) -> 'a map -> 'a map -> int
          val equal : ('-> '-> bool) -> 'a map -> 'a map -> bool
          val iter : (string -> '-> unit) -> 'a map -> unit
          val fold : (string -> '-> '-> 'b) -> 'a map -> '-> 'b
          val for_all : (string -> '-> bool) -> 'a map -> bool
          val exists : (string -> '-> bool) -> 'a map -> bool
          val filter : (string -> '-> bool) -> 'a map -> 'a map
          val filter_map : (string -> '-> 'b option) -> 'a map -> 'b map
          val partition : (string -> '-> bool) -> 'a map -> 'a map * 'a map
          val cardinal : 'a map -> int
          val bindings : 'a map -> (string * 'a) list
          val min_binding_opt : 'a map -> (string * 'a) option
          val max_binding_opt : 'a map -> (string * 'a) option
          val choose_opt : 'a map -> (string * 'a) option
          val split : string -> 'a map -> 'a map * 'a option * 'a map
          val find_opt : string -> 'a map -> 'a option
          val find_first : (string -> bool) -> 'a map -> string * 'a
          val find_first_opt :
            (string -> bool) -> 'a map -> (string * 'a) option
          val find_last : (string -> bool) -> 'a map -> string * 'a
          val find_last_opt :
            (string -> bool) -> 'a map -> (string * 'a) option
          val map : ('-> 'b) -> 'a map -> 'b map
          val mapi : (string -> '-> 'b) -> 'a map -> 'b map
          val to_seq : 'a map -> (string * 'a) Seq.t
          val to_seq_from : string -> 'a map -> (string * 'a) Seq.t
          val add_seq : (string * 'a) Seq.t -> 'a map -> 'a map
          val of_seq : (string * 'a) Seq.t -> 'a map
          type 'a t = 'Astring.String.map
          val min_binding : 'Astring.String.map -> (string * 'a) option
          val get_min_binding : 'Astring.String.map -> string * 'a
          val max_binding : 'Astring.String.map -> (string * 'a) option
          val get_max_binding : 'Astring.String.map -> string * 'a
          val choose : 'Astring.String.map -> (string * 'a) option
          val get_any_binding : 'Astring.String.map -> string * 'a
          val find : string -> 'Astring.String.map -> 'a option
          val get : string -> 'Astring.String.map -> 'a
          val dom : 'Astring.String.map -> Astring.String.set
          val of_list : (string * 'a) list -> 'Astring.String.map
          val pp :
            ?sep:(Stdlib.Format.formatter -> unit -> unit) ->
            (Stdlib.Format.formatter -> string * '-> unit) ->
            Stdlib.Format.formatter -> 'Astring.String.map -> unit
          val dump :
            (Stdlib.Format.formatter -> '-> unit) ->
            Stdlib.Format.formatter -> 'Astring.String.map -> unit
          val dump_string_map :
            Stdlib.Format.formatter -> string Astring.String.map -> unit
        end
      val of_char : char -> string
      val to_char : string -> char option
      val of_bool : bool -> string
      val to_bool : string -> bool option
      val of_int : int -> string
      val to_int : string -> int option
      val of_nativeint : nativeint -> string
      val to_nativeint : string -> nativeint option
      val of_int32 : int32 -> string
      val to_int32 : string -> int32 option
      val of_int64 : int64 -> string
      val to_int64 : string -> int64 option
      val of_float : float -> string
      val to_float : string -> float option
    end
end