sig
  val dir_sep : string
  val is_seg : string -> bool
  val is_rel_seg : string -> bool
  type t
  val v : string -> Fpath.t
  val add_seg : Fpath.t -> string -> Fpath.t
  val ( / ) : Fpath.t -> string -> Fpath.t
  val append : Fpath.t -> Fpath.t -> Fpath.t
  val ( // ) : Fpath.t -> Fpath.t -> Fpath.t
  val split_volume : Fpath.t -> string * Fpath.t
  val segs : Fpath.t -> string list
  val is_dir_path : Fpath.t -> bool
  val is_file_path : Fpath.t -> bool
  val to_dir_path : Fpath.t -> Fpath.t
  val filename : Fpath.t -> string
  val split_base : Fpath.t -> Fpath.t * Fpath.t
  val base : Fpath.t -> Fpath.t
  val basename : Fpath.t -> string
  val parent : Fpath.t -> Fpath.t
  val rem_empty_seg : Fpath.t -> Fpath.t
  val normalize : Fpath.t -> Fpath.t
  val is_prefix : Fpath.t -> Fpath.t -> bool
  val find_prefix : Fpath.t -> Fpath.t -> Fpath.t option
  val rem_prefix : Fpath.t -> Fpath.t -> Fpath.t option
  val relativize : root:Fpath.t -> Fpath.t -> Fpath.t option
  val is_rooted : root:Fpath.t -> Fpath.t -> bool
  val is_rel : Fpath.t -> bool
  val is_abs : Fpath.t -> bool
  val is_root : Fpath.t -> bool
  val is_current_dir : ?prefix:bool -> Fpath.t -> bool
  val is_parent_dir : ?prefix:bool -> Fpath.t -> bool
  val is_dotfile : Fpath.t -> bool
  val equal : Fpath.t -> Fpath.t -> bool
  val compare : Fpath.t -> Fpath.t -> int
  val to_string : Fpath.t -> string
  val of_string : string -> (Fpath.t, [ `Msg of string ]) Stdlib.result
  val pp : Stdlib.Format.formatter -> Fpath.t -> unit
  val dump : Stdlib.Format.formatter -> Fpath.t -> unit
  type ext = string
  val get_ext : ?multi:bool -> Fpath.t -> Fpath.ext
  val has_ext : Fpath.ext -> Fpath.t -> bool
  val mem_ext : Fpath.ext list -> Fpath.t -> bool
  val exists_ext : ?multi:bool -> Fpath.t -> bool
  val add_ext : Fpath.ext -> Fpath.t -> Fpath.t
  val rem_ext : ?multi:bool -> Fpath.t -> Fpath.t
  val set_ext : ?multi:bool -> Fpath.ext -> Fpath.t -> Fpath.t
  val split_ext : ?multi:bool -> Fpath.t -> Fpath.t * Fpath.ext
  val ( + ) : Fpath.t -> Fpath.ext -> Fpath.t
  val ( -+ ) : Fpath.t -> Fpath.ext -> Fpath.t
  type path = Fpath.t
  type set
  module Set :
    sig
      val empty : set
      val is_empty : set -> bool
      val mem : path -> set -> bool
      val add : path -> set -> set
      val singleton : path -> set
      val remove : path -> set -> set
      val union : set -> set -> set
      val inter : set -> set -> set
      val disjoint : set -> set -> bool
      val diff : set -> set -> set
      val compare : set -> set -> int
      val equal : set -> set -> bool
      val subset : set -> set -> bool
      val iter : (path -> unit) -> set -> unit
      val map : (path -> path) -> set -> set
      val fold : (path -> '-> 'a) -> set -> '-> 'a
      val for_all : (path -> bool) -> set -> bool
      val exists : (path -> bool) -> set -> bool
      val filter : (path -> bool) -> set -> set
      val filter_map : (path -> path option) -> set -> set
      val partition : (path -> bool) -> set -> set * set
      val cardinal : set -> int
      val elements : set -> path list
      val min_elt_opt : set -> path option
      val max_elt_opt : set -> path option
      val choose_opt : set -> path option
      val split : path -> set -> set * bool * set
      val find_opt : path -> set -> path option
      val find_first : (path -> bool) -> set -> path
      val find_first_opt : (path -> bool) -> set -> path option
      val find_last : (path -> bool) -> set -> path
      val find_last_opt : (path -> bool) -> set -> path option
      val to_seq_from : path -> set -> path Seq.t
      val to_seq : set -> path Seq.t
      val to_rev_seq : set -> path Seq.t
      val add_seq : path Seq.t -> set -> set
      val of_seq : path Seq.t -> set
      type t = Fpath.set
      val min_elt : Fpath.set -> Fpath.path option
      val get_min_elt : Fpath.set -> Fpath.path
      val max_elt : Fpath.set -> Fpath.path option
      val get_max_elt : Fpath.set -> Fpath.path
      val choose : Fpath.set -> Fpath.path option
      val get_any_elt : Fpath.set -> Fpath.path
      val find : Fpath.path -> Fpath.set -> Fpath.path option
      val get : Fpath.path -> Fpath.set -> Fpath.path
      val of_list : Fpath.path list -> Fpath.set
      val pp :
        ?sep:(Stdlib.Format.formatter -> unit -> unit) ->
        (Stdlib.Format.formatter -> Fpath.path -> unit) ->
        Stdlib.Format.formatter -> Fpath.set -> unit
      val dump : Stdlib.Format.formatter -> Fpath.set -> unit
    end
  module Map :
    sig
      type +!'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val mem : t -> 'a t -> bool
      val add : t -> '-> 'a t -> 'a t
      val update : t -> ('a option -> 'a option) -> 'a t -> 'a t
      val singleton : t -> '-> 'a t
      val remove : t -> 'a t -> 'a t
      val merge :
        (t -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
      val union : (t -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val iter : (t -> '-> unit) -> 'a t -> unit
      val fold : (t -> '-> '-> 'b) -> 'a t -> '-> 'b
      val for_all : (t -> '-> bool) -> 'a t -> bool
      val exists : (t -> '-> bool) -> 'a t -> bool
      val filter : (t -> '-> bool) -> 'a t -> 'a t
      val filter_map : (t -> '-> 'b option) -> 'a t -> 'b t
      val partition : (t -> '-> bool) -> 'a t -> 'a t * 'a t
      val cardinal : 'a t -> int
      val bindings : 'a t -> (t * 'a) list
      val min_binding_opt : 'a t -> (t * 'a) option
      val max_binding_opt : 'a t -> (t * 'a) option
      val choose_opt : 'a t -> (t * 'a) option
      val split : t -> 'a t -> 'a t * 'a option * 'a t
      val find_opt : t -> 'a t -> 'a option
      val find_first : (t -> bool) -> 'a t -> t * 'a
      val find_first_opt : (t -> bool) -> 'a t -> (t * 'a) option
      val find_last : (t -> bool) -> 'a t -> t * 'a
      val find_last_opt : (t -> bool) -> 'a t -> (t * 'a) option
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (t -> '-> 'b) -> 'a t -> 'b t
      val to_seq : 'a t -> (t * 'a) Seq.t
      val to_rev_seq : 'a t -> (t * 'a) Seq.t
      val to_seq_from : t -> 'a t -> (t * 'a) Seq.t
      val add_seq : (t * 'a) Seq.t -> 'a t -> 'a t
      val of_seq : (t * 'a) Seq.t -> 'a t
      val min_binding : 'Fpath.t -> (Fpath.path * 'a) option
      val get_min_binding : 'Fpath.t -> Fpath.path * 'a
      val max_binding : 'Fpath.t -> (Fpath.path * 'a) option
      val get_max_binding : 'Fpath.t -> string * 'a
      val choose : 'Fpath.t -> (Fpath.path * 'a) option
      val get_any_binding : 'Fpath.t -> Fpath.path * 'a
      val find : Fpath.path -> 'Fpath.t -> 'a option
      val get : Fpath.path -> 'Fpath.t -> 'a
      val dom : 'Fpath.t -> Fpath.set
      val of_list : (Fpath.path * 'a) list -> 'Fpath.t
      val pp :
        ?sep:(Stdlib.Format.formatter -> unit -> unit) ->
        (Stdlib.Format.formatter -> Fpath.path * '-> unit) ->
        Stdlib.Format.formatter -> 'Fpath.t -> unit
      val dump :
        (Stdlib.Format.formatter -> '-> unit) ->
        Stdlib.Format.formatter -> 'Fpath.t -> unit
    end
  type 'a map = 'Fpath.Map.t
end