sig
  type 'a param = 'Command.Param.t
  val return : '-> 'a param
  val apply : ('-> 'b) param -> 'a param -> 'b param
  val map : 'a param -> f:('-> 'b) -> 'b param
  val map2 : 'a param -> 'b param -> f:('-> '-> 'c) -> 'c param
  val map3 :
    'a param -> 'b param -> 'c param -> f:('-> '-> '-> 'd) -> 'd param
  val all : 'a param list -> 'a list param
  val both : 'a param -> 'b param -> ('a * 'b) param
  module Applicative_infix :
    sig
      val ( <*> ) : ('-> 'b) param -> 'a param -> 'b param
      val ( <* ) : 'a param -> unit param -> 'a param
      val ( *> ) : unit param -> 'a param -> 'a param
    end
  val ( <*> ) : ('-> 'b) param -> 'a param -> 'b param
  val ( <* ) : 'a param -> unit param -> 'a param
  val ( *> ) : unit param -> 'a param -> 'a param
  val help : string Core_kernel.Std.Lazy.t param
  val path : string list param
  val args : string list param
  val flag :
    ?aliases:string list ->
    ?full_flag_required:unit -> string -> 'Flag.t -> doc:string -> 'a param
  val anon : 'Anons.t -> 'a param
  val const : '-> 'Command.Spec.param
  val pair :
    'Command.Spec.param ->
    'Command.Spec.param -> ('a * 'b) Command.Spec.param
  type ('main_in, 'main_out) t
  val empty : ('m, 'm) Command.Spec.t
  val ( ++ ) :
    ('m1, 'm2) Command.Spec.t ->
    ('m2, 'm3) Command.Spec.t -> ('m1, 'm3) Command.Spec.t
  val ( +> ) :
    ('m1, '-> 'm2) Command.Spec.t ->
    'Command.Spec.param -> ('m1, 'm2) Command.Spec.t
  val ( +< ) :
    ('m1, 'm2) Command.Spec.t ->
    'Command.Spec.param -> ('-> 'm1, 'm2) Command.Spec.t
  val step : ('m1 -> 'm2) -> ('m1, 'm2) Command.Spec.t
  val wrap :
    (run:('m1 -> 'r1) -> main:'m2 -> 'r2) ->
    ('m1, 'r1) Command.Spec.t -> ('m2, 'r2) Command.Spec.t
  val of_params : ('a, 'b) Command.Param.Args.t -> ('a, 'b) Command.Spec.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
  type 'a flag = 'Command.Flag.t
  val required : 'Arg_type.t -> 'a flag
  val optional : 'Arg_type.t -> 'a option flag
  val optional_with_default : '-> 'Arg_type.t -> 'a flag
  val listed : 'Arg_type.t -> 'a list flag
  val one_or_more : 'Arg_type.t -> ('a * 'a list) flag
  val no_arg : bool flag
  val no_arg_register :
    key:'Core_kernel.Std.Univ_map.With_default.Key.t ->
    value:'-> bool flag
  val no_arg_abort :
    exit:(unit -> Core_kernel.Std.never_returns) -> unit flag
  val escape : string list option flag
  val map_flag : 'Command.Spec.flag -> f:('-> 'b) -> 'Command.Spec.flag
  val flags_of_args_exn :
    Core_kernel.Std.Arg.t list -> ('a, 'a) Command.Spec.t
  type 'a anons = 'Command.Anons.t
  val ( %: ) : string -> 'Arg_type.t -> 'a anons
  val sequence : 'a anons -> 'a list anons
  val non_empty_sequence : 'a anons -> ('a * 'a list) anons
  val maybe : 'a anons -> 'a option anons
  val maybe_with_default : '-> 'a anons -> 'a anons
  val t2 : 'a anons -> 'b anons -> ('a * 'b) anons
  val t3 : 'a anons -> 'b anons -> 'c anons -> ('a * 'b * 'c) anons
  val t4 :
    'a anons -> 'b anons -> 'c anons -> 'd anons -> ('a * 'b * 'c * 'd) anons
  val map_anons :
    'Command.Spec.anons -> f:('-> 'b) -> 'Command.Spec.anons
end