sig
  module type S =
    sig
      type 'a t
      val return : '-> 'a t
      val apply : ('-> 'b) t -> 'a t -> 'b t
      val map : 'a t -> f:('-> 'b) -> 'b t
      val map2 : 'a t -> 'b t -> f:('-> '-> 'c) -> 'c t
      val map3 : 'a t -> 'b t -> 'c t -> f:('-> '-> '-> 'd) -> 'd t
      val all : 'a t list -> 'a list t
      val both : 'a t -> 'b t -> ('a * 'b) t
      module Applicative_infix :
        sig
          val ( <*> ) : ('-> 'b) t -> 'a t -> 'b t
          val ( <* ) : 'a t -> unit t -> 'a t
          val ( *> ) : unit t -> 'a t -> 'a t
        end
      val ( <*> ) : ('-> 'b) t -> 'a t -> 'b t
      val ( <* ) : 'a t -> unit t -> 'a t
      val ( *> ) : unit t -> 'a t -> 'a t
      val help : string Core_kernel.Std.Lazy.t t
      val path : string list t
      val args : string list t
      val flag :
        ?aliases:string list ->
        ?full_flag_required:unit ->
        string -> 'Command.Flag.t -> doc:string -> 'a t
      val anon : 'Command.Anons.t -> 'a t
    end
  type 'a t
  val return : '-> 'a t
  val apply : ('-> 'b) t -> 'a t -> 'b t
  val map : 'a t -> f:('-> 'b) -> 'b t
  val map2 : 'a t -> 'b t -> f:('-> '-> 'c) -> 'c t
  val map3 : 'a t -> 'b t -> 'c t -> f:('-> '-> '-> 'd) -> 'd t
  val all : 'a t list -> 'a list t
  val both : 'a t -> 'b t -> ('a * 'b) t
  module Applicative_infix :
    sig
      val ( <*> ) : ('-> 'b) t -> 'a t -> 'b t
      val ( <* ) : 'a t -> unit t -> 'a t
      val ( *> ) : unit t -> 'a t -> 'a t
    end
  val ( <*> ) : ('-> 'b) t -> 'a t -> 'b t
  val ( <* ) : 'a t -> unit t -> 'a t
  val ( *> ) : unit t -> 'a t -> 'a t
  val help : string Core_kernel.Std.Lazy.t t
  val path : string list t
  val args : string list t
  val flag :
    ?aliases:string list ->
    ?full_flag_required:unit -> string -> 'Flag.t -> doc:string -> 'a t
  val anon : 'Anons.t -> 'a t
  module Args :
    sig
      type ('f, 'r) t
      val nil : ('r, 'r) t
      val cons : 'a t -> ('f, 'r) t -> ('-> 'f, 'r) t
      val ( @> ) : 'a t -> ('f, 'r) t -> ('-> 'f, 'r) t
      val step : ('f1, 'r) t -> f:('f2 -> 'f1) -> ('f2, 'r) t
      val mapN : f:'-> ('f, 'r) t -> 'r t
      val applyN : 'f t -> ('f, 'r) t -> 'r t
    end
  val nil : ('r, 'r) Args.t
  val cons : 'a t -> ('f, 'r) Args.t -> ('-> 'f, 'r) Args.t
  val ( @> ) : 'a t -> ('f, 'r) Args.t -> ('-> 'f, 'r) Args.t
  val step : ('f1, 'r) Args.t -> f:('f2 -> 'f1) -> ('f2, 'r) Args.t
  val mapN : f:'-> ('f, 'r) Args.t -> 'r t
  val applyN : 'f t -> ('f, 'r) Args.t -> 'r t
  module Arg_type :
    sig
      type 'a t = 'Arg_type.t
      val create :
        ?complete:(Core_kernel.Std.Univ_map.t -> part:string -> string list) ->
        ?key:'Core_kernel.Std.Univ_map.Multi.Key.t ->
        (string -> 'a) -> 'a t
      val of_map :
        ?key:'Core_kernel.Std.Univ_map.Multi.Key.t ->
        'Core_kernel.Std.String.Map.t -> 'a t
      val of_alist_exn :
        ?key:'Core_kernel.Std.Univ_map.Multi.Key.t ->
        (string * 'a) list -> 'a t
      val file :
        ?key:'Core_kernel.Std.Univ_map.Multi.Key.t ->
        (string -> 'a) -> 'a t
      module Export :
        sig
          val string : string t
          val int : int t
          val char : char t
          val float : float t
          val bool : bool t
          val date : Date.t t
          val time : Time.t t
          val time_ofday : Time.Ofday.Zoned.t t
          val time_ofday_unzoned : Time.Ofday.t t
          val time_span : Time.Span.t t
          val file : string t
        end
    end
  val string : string Arg_type.t
  val int : int Arg_type.t
  val char : char Arg_type.t
  val float : float Arg_type.t
  val bool : bool Arg_type.t
  val date : Date.t Arg_type.t
  val time : Time.t Arg_type.t
  val time_ofday : Time.Ofday.Zoned.t Arg_type.t
  val time_ofday_unzoned : Time.Ofday.t Arg_type.t
  val time_span : Time.Span.t Arg_type.t
  val file : string Arg_type.t
  val required : 'Arg_type.t -> 'Flag.t
  val optional : 'Arg_type.t -> 'a option Flag.t
  val optional_with_default : '-> 'Arg_type.t -> 'Flag.t
  val listed : 'Arg_type.t -> 'a list Flag.t
  val one_or_more : 'Arg_type.t -> ('a * 'a list) Flag.t
  val no_arg : bool Flag.t
  val no_arg_register :
    key:'Core_kernel.Std.Univ_map.With_default.Key.t ->
    value:'-> bool Flag.t
  val no_arg_abort :
    exit:(unit -> Core_kernel.Std.never_returns) -> unit Flag.t
  val escape : string list option Flag.t
  val ( %: ) : string -> 'Arg_type.t -> 'Anons.t
  val sequence : 'Anons.t -> 'a list Anons.t
  val non_empty_sequence : 'Anons.t -> ('a * 'a list) Anons.t
  val maybe : 'Anons.t -> 'a option Anons.t
  val maybe_with_default : '-> 'Anons.t -> 'Anons.t
  val t2 : 'Anons.t -> 'Anons.t -> ('a * 'b) Anons.t
  val t3 : 'Anons.t -> 'Anons.t -> 'Anons.t -> ('a * 'b * 'c) Anons.t
  val t4 :
    'Anons.t ->
    'Anons.t -> 'Anons.t -> 'Anons.t -> ('a * 'b * 'c * 'd) Anons.t
end