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_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