sig
  module Make :
    functor
      (S : sig
             module Key :
               sig
                 type t
                 val of_string : string -> Arg_helper.Make.Key.t
                 module Map :
                   sig
                     type key = t
                     type +!'a t
                     val empty : 'a t
                     val is_empty : 'a t -> bool
                     val mem : key -> 'a t -> bool
                     val add : key -> 'a -> 'a t -> 'a t
                     val update :
                       key -> ('a option -> 'a option) -> 'a t -> 'a t
                     val singleton : key -> 'a -> '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 -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
                     val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                     val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                     val iter : (key -> 'a -> unit) -> 'a t -> unit
                     val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
                     val for_all : (key -> 'a -> bool) -> 'a t -> bool
                     val exists : (key -> 'a -> bool) -> 'a t -> bool
                     val filter : (key -> 'a -> bool) -> 'a t -> 'a t
                     val filter_map :
                       (key -> 'a -> 'b option) -> 'a t -> 'b t
                     val partition :
                       (key -> 'a -> bool) -> '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 split : key -> 'a t -> 'a t * 'a option * 'a t
                     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 map : ('a -> 'b) -> 'a t -> 'b t
                     val mapi : (key -> 'a -> 'b) -> 'a t -> 'b 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 Value :
               sig
                 type t
                 val of_string : string -> Arg_helper.Make.Value.t
               end
           end)
      ->
      sig
        type parsed
        val default : S.Value.t -> Arg_helper.Make.parsed
        val set_base_default :
          S.Value.t -> Arg_helper.Make.parsed -> Arg_helper.Make.parsed
        val add_base_override :
          S.Key.t ->
          S.Value.t -> Arg_helper.Make.parsed -> Arg_helper.Make.parsed
        val reset_base_overrides :
          Arg_helper.Make.parsed -> Arg_helper.Make.parsed
        val set_user_default :
          S.Value.t -> Arg_helper.Make.parsed -> Arg_helper.Make.parsed
        val add_user_override :
          S.Key.t ->
          S.Value.t -> Arg_helper.Make.parsed -> Arg_helper.Make.parsed
        val parse :
          string -> string -> Arg_helper.Make.parsed Stdlib.ref -> unit
        type parse_result = Ok | Parse_failed of exn
        val parse_no_error :
          string ->
          Arg_helper.Make.parsed Stdlib.ref -> Arg_helper.Make.parse_result
        val get : key:S.Key.t -> Arg_helper.Make.parsed -> S.Value.t
      end
end