sig
  type kind = [ `Base | `Bin | `Dir | `Doc | `Lib | `Pkg | `Run | `Unit ]
  val pp_kind : Format.formatter -> As_part.kind -> unit
  type usage = [ `Build | `Dev | `Doc | `Other of string | `Outcome | `Test ]
  val pp_usage : Format.formatter -> As_part.usage -> unit
  type meta
  val meta_key : unit -> ('a -> As_part.meta) * (As_part.meta -> 'a option)
  val meta_nil : As_part.meta
  type +'a t constraint 'a = [< As_part.kind ]
  val v_kind :
    ?usage:As_part.usage ->
    ?exists:bool As_conf.value ->
    ?args:As_args.t ->
    ?meta:As_part.meta ->
    ?needs:[< As_part.kind ] As_part.t list ->
    ?root:As_path.rel As_conf.value ->
    ?actions:(As_part.kind As_part.t -> As_action.t list As_conf.value) ->
    ?check:(As_part.kind As_part.t -> bool As_conf.value) ->
    string -> ([< As_part.kind ] as 'a) -> 'a As_part.t
  val v :
    ?usage:As_part.usage ->
    ?exists:bool As_conf.value ->
    ?args:As_args.t ->
    ?meta:As_part.meta ->
    ?needs:[< As_part.kind ] As_part.t list ->
    ?root:As_path.rel As_conf.value ->
    ?actions:(As_part.kind As_part.t -> As_action.t list As_conf.value) ->
    ?check:(As_part.kind As_part.t -> bool As_conf.value) ->
    string -> [< As_part.kind > `Base ] As_part.t
  val kind : [< As_part.kind ] As_part.t -> As_part.kind
  val name : [< As_part.kind ] As_part.t -> string
  val usage : [< As_part.kind ] As_part.t -> As_part.usage
  val exists : [< As_part.kind ] As_part.t -> bool As_conf.value
  val meta : [< As_part.kind ] As_part.t -> As_part.meta
  val get_meta :
    (As_part.meta -> 'a option) -> [< As_part.kind ] As_part.t -> 'a
  val needs : [< As_part.kind ] As_part.t -> As_part.kind As_part.t list
  val root : [< As_part.kind ] As_part.t -> As_path.rel As_conf.value
  val root_path : [< As_part.kind ] As_part.t -> As_path.t As_conf.value
  val args : [< As_part.kind ] As_part.t -> As_args.t
  val actions : [< As_part.kind ] As_part.t -> As_action.t list As_conf.value
  val check : [< As_part.kind ] As_part.t -> bool As_conf.value
  val id : [< As_part.kind ] As_part.t -> int
  val equal :
    [< As_part.kind ] As_part.t -> [< As_part.kind ] As_part.t -> bool
  val compare :
    [< As_part.kind ] As_part.t -> [< As_part.kind ] As_part.t -> int
  val deps : [< As_part.kind ] As_part.t -> As_conf.Key.Set.t
  val ctx : [< As_part.kind ] As_part.t -> As_ctx.t
  val redefine :
    ?check:(As_part.kind As_part.t -> bool As_conf.value) ->
    ?actions:(As_part.kind As_part.t -> As_action.t list As_conf.value) ->
    ([< As_part.kind ] as 'a) As_part.t -> 'a As_part.t
  val integrate :
    ?add_need:(As_part.kind As_part.t -> bool) ->
    ([< As_part.kind ] as 'a) As_part.t ->
    [< As_part.kind ] As_part.t -> 'a As_part.t
  val coerce :
    ([< As_part.kind ] as 'a) -> [< As_part.kind ] As_part.t -> 'a As_part.t
  val coerce_if :
    ([< As_part.kind ] as 'a) ->
    [< As_part.kind ] As_part.t -> 'a As_part.t option
  val file :
    ?usage:As_part.usage ->
    ?exists:bool As_conf.value ->
    As_path.t -> [< As_part.kind > `Base ] As_part.t
  val list_actions :
    As_part.kind As_part.t list -> As_action.t list As_conf.value
  val list_uniquify :
    As_part.kind As_part.t list -> As_part.kind As_part.t list
  val list_keep :
    (([< As_part.kind ] as 'a) As_part.t -> bool) ->
    'a As_part.t list -> 'a As_part.t list
  val list_keep_map :
    (([< As_part.kind ] as 'a) As_part.t -> 'b option) ->
    'a As_part.t list -> 'b list
  val list_keep_kind :
    ([< As_part.kind ] as 'a) ->
    [< As_part.kind ] As_part.t list -> 'a As_part.t list
  val list_keep_kinds :
    As_part.kind list ->
    ([< As_part.kind ] as 'a) As_part.t list -> 'a As_part.t list
  val list_fold :
    ('a -> ([< As_part.kind ] as 'b) As_part.t -> 'a) ->
    'a -> 'b As_part.t list -> 'a
  val list_fold_kind :
    ([< As_part.kind ] as 'b) ->
    ('a -> 'b As_part.t -> 'a) ->
    'a -> [< As_part.kind ] As_part.t list -> 'a
  val list_fold_rec :
    ('a -> As_part.kind As_part.t -> 'a) ->
    'a -> As_part.kind As_part.t list -> 'a
  val list_fold_kind_rec :
    ([< As_part.kind ] as 'b) ->
    ('a -> 'b As_part.t -> 'a) -> 'a -> As_part.kind As_part.t list -> 'a
  module Set :
    sig
      type elt = kind t
      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_part.t
    end
  module Map :
    sig
      type key = kind 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 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_part.t -> As_part.Set.t
    end
end