sig
  type path = As_path.t
  type t = As_path.abs
  val root : As_path.abs
  val add : As_path.abs -> string -> As_path.abs
  val concat : As_path.abs -> As_path.rel -> As_path.abs
  val ( / ) : As_path.abs -> string -> As_path.abs
  val ( // ) : As_path.abs -> As_path.rel -> As_path.abs
  val basename : As_path.abs -> string
  val dirname : As_path.abs -> As_path.abs
  val rem_prefix : As_path.abs -> As_path.abs -> As_path.rel option
  val find_prefix : As_path.abs -> As_path.abs -> As_path.abs
  val is_root : As_path.abs -> bool
  val is_prefix : As_path.abs -> As_path.abs -> bool
  val equal : As_path.abs -> As_path.abs -> bool
  val compare : As_path.abs -> As_path.abs -> int
  val to_segs : As_path.abs -> string list
  val of_segs : string list -> As_path.abs
  val to_string : As_path.abs -> string
  val quote : As_path.abs -> string
  val pp : Format.formatter -> As_path.abs -> unit
  val ext : As_path.abs -> As_path.ext option
  val get_ext : As_path.abs -> As_path.ext
  val add_ext : As_path.abs -> As_path.ext -> As_path.abs
  val rem_ext : As_path.abs -> As_path.abs
  val change_ext : As_path.abs -> As_path.ext -> As_path.abs
  val ( + ) : As_path.abs -> As_path.ext -> As_path.abs
  val has_ext : As_path.ext -> As_path.abs -> bool
  val ext_matches : As_path.ext list -> As_path.abs -> bool
  module Set :
    sig
      type elt = abs
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (elt -> unit) -> t -> unit
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val filter : (elt -> bool) -> t -> t
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val find : elt -> t -> elt
      val of_list : elt list -> As_path.Abs.t
    end
  module Map :
    sig
      type key = abs
      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 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 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 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 max_binding : 'a t -> key * 'a
      val choose : 'a t -> key * 'a
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val find : key -> 'a t -> 'a
      val map : ('a -> 'b) -> 'a t -> 'b t
      val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
      val dom : 'a As_path.Abs.t -> As_path.Abs.Set.t
    end
end