(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 add : key -> 'a -> 'a t -> 'a t
               val add_to_list : key -> 'a -> 'a list t -> 'a list 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 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 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 iter : (key -> 'a -> unit) -> 'a t -> unit
               val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
               val map : ('a -> 'b) -> 'a t -> 'b t
               val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
               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 split : key -> 'a t -> 'a t * 'a option * 'a t
               val is_empty : 'a t -> bool
               val mem : key -> 'a t -> bool
               val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
               val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
               val for_all : (key -> 'a -> bool) -> 'a t -> bool
               val exists : (key -> 'a -> bool) -> 'a t -> bool
               val to_list : 'a t -> (key * 'a) list
               val of_list : (key * 'a) list -> 'a 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