sig
  module Arg_type :
    sig
      type 'a 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) -> 'Command.Arg_type.t
      val of_map :
        ?key:'Core_kernel.Std.Univ_map.Multi.Key.t ->
        'Core_kernel.Std.String.Map.t -> 'Command.Arg_type.t
      val of_alist_exn :
        ?key:'Core_kernel.Std.Univ_map.Multi.Key.t ->
        (string * 'a) list -> 'Command.Arg_type.t
      val file :
        ?key:'Core_kernel.Std.Univ_map.Multi.Key.t ->
        (string -> 'a) -> 'Command.Arg_type.t
      module Export :
        sig
          val string : string Command.Arg_type.t
          val int : int Command.Arg_type.t
          val char : char Command.Arg_type.t
          val float : float Command.Arg_type.t
          val bool : bool Command.Arg_type.t
          val date : Date.t Command.Arg_type.t
          val time : Time.t Command.Arg_type.t
          val time_ofday : Time.Ofday.Zoned.t Command.Arg_type.t
          val time_ofday_unzoned : Time.Ofday.t Command.Arg_type.t
          val time_span : Time.Span.t Command.Arg_type.t
          val file : string Command.Arg_type.t
        end
    end
  module Flag :
    sig
      type 'a t
      val required : 'Command.Arg_type.t -> 'Command.Flag.t
      val optional : 'Command.Arg_type.t -> 'a option Command.Flag.t
      val optional_with_default :
        '-> 'Command.Arg_type.t -> 'Command.Flag.t
      val listed : 'Command.Arg_type.t -> 'a list Command.Flag.t
      val one_or_more :
        'Command.Arg_type.t -> ('a * 'a list) Command.Flag.t
      val no_arg : bool Command.Flag.t
      val no_arg_register :
        key:'Core_kernel.Std.Univ_map.With_default.Key.t ->
        value:'-> bool Command.Flag.t
      val no_arg_abort :
        exit:(unit -> Core_kernel.Std.never_returns) -> unit Command.Flag.t
      val escape : string list option Command.Flag.t
    end
  module Anons :
    sig
      type 'a t
      val ( %: ) : string -> 'Command.Arg_type.t -> 'Command.Anons.t
      val sequence : 'Command.Anons.t -> 'a list Command.Anons.t
      val non_empty_sequence :
        'Command.Anons.t -> ('a * 'a list) Command.Anons.t
      val maybe : 'Command.Anons.t -> 'a option Command.Anons.t
      val maybe_with_default : '-> 'Command.Anons.t -> 'Command.Anons.t
      val t2 :
        'Command.Anons.t -> 'Command.Anons.t -> ('a * 'b) Command.Anons.t
      val t3 :
        'Command.Anons.t ->
        'Command.Anons.t ->
        'Command.Anons.t -> ('a * 'b * 'c) Command.Anons.t
      val t4 :
        'Command.Anons.t ->
        'Command.Anons.t ->
        'Command.Anons.t ->
        'Command.Anons.t -> ('a * 'b * 'c * 'd) Command.Anons.t
    end
  module Param :
    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
  module Spec :
    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
  type t
  type ('main, 'result) basic_command =
      summary:string ->
      ?readme:(unit -> string) ->
      ('main, unit -> 'result) Command.Spec.t -> 'main -> Command.t
  val basic : ('main, unit) Command.basic_command
  type ('main, 'result) basic_command' =
      summary:string ->
      ?readme:(unit -> string) ->
      ('main, unit -> 'result) Command.Param.Args.t -> 'main -> Command.t
  val basic' : ('main, unit) Command.basic_command'
  val group :
    summary:string ->
    ?readme:(unit -> string) ->
    ?preserve_subcommand_order:unit ->
    ?body:(path:string list -> unit) ->
    (string * Command.t) list -> Command.t
  val exec :
    summary:string ->
    ?readme:(unit -> string) ->
    path_to_exe:[ `Absolute of string | `Relative_to_me of string ] ->
    unit -> Command.t
  val summary : Command.t -> string
  module Shape :
    sig
      type t =
          Basic
        | Group of (string * Command.Shape.t) list
        | Exec of (unit -> Command.Shape.t)
    end
  val shape : Command.t -> Command.Shape.t
  val run :
    ?version:string ->
    ?build_info:string ->
    ?argv:string list ->
    ?extend:(string list -> string list) -> Command.t -> unit
  module Deprecated :
    sig
      module Spec :
        sig
          val no_arg : hook:(unit -> unit) -> bool Command.Spec.flag
          val escape :
            hook:(string list -> unit) ->
            string list option Command.Spec.flag
          val ad_hoc : usage_arg:string -> string list Command.Spec.anons
        end
      val summary : Command.t -> string
      val help_recursive :
        cmd:string ->
        with_flags:bool ->
        expand_dots:bool -> Command.t -> string -> (string * string) list
      val run :
        Command.t ->
        cmd:string ->
        args:string list ->
        is_help:bool ->
        is_help_rec:bool ->
        is_help_rec_flags:bool -> is_expand_dots:bool -> unit
      val get_flag_names : Command.t -> string list
      val version : string
      val build_info : string
    end
end