sig
  type kind = Part.kind
  val pp_kind : Format.formatter -> kind -> unit
  type usage = [ `Build | `Dev | `Doc | `Other of string | `Outcome | `Test ]
  val pp_usage : Format.formatter -> usage -> unit
  type meta = Part.meta
  val meta_key : unit -> ('a -> meta) * (meta -> 'a option)
  val meta_nil : meta
  type +'a t = 'a Part.t constraint 'a = [< part_kind ]
  val v :
    ?usage:usage ->
    ?exists:bool Conf.value ->
    ?args:Args.t ->
    ?meta:meta ->
    ?needs:[< part_kind ] part list ->
    ?root:Path.rel Conf.value ->
    ?actions:(kind part -> Action.t list Conf.value) ->
    ?check:(kind part -> bool Conf.value) ->
    string -> [< part_kind > `Base ] part
  val kind : [< part_kind ] part -> kind
  val name : [< part_kind ] part -> string
  val usage : [< part_kind ] part -> usage
  val exists : [< part_kind ] part -> bool Conf.value
  val meta : [< part_kind ] part -> meta
  val get_meta : (meta -> 'a option) -> [< part_kind ] t -> 'a
  val root : [< part_kind ] part -> Path.rel Conf.value
  val root_path : [< part_kind ] part -> Path.t Conf.value
  val needs : [< part_kind ] part -> kind t list
  val actions : [< part_kind ] part -> Action.t list Conf.value
  val check : [< part_kind ] part -> bool Conf.value
  val id : [< part_kind ] part -> int
  val equal : [< part_kind ] part -> [< part_kind ] part -> bool
  val compare : [< part_kind ] part -> [< part_kind ] part -> int
  val redefine :
    ?check:(kind part -> bool Conf.value) ->
    ?actions:(kind part -> Action.t list Conf.value) ->
    ([< part_kind ] as 'a) part -> 'a part
  val file :
    ?usage:usage ->
    ?exists:bool Conf.value -> Path.t -> [< part_kind > `Base ] part
  val integrate :
    ?add_need:(kind part -> bool) ->
    ([< part_kind ] as 'a) part -> [< part_kind ] part -> 'a part
  val coerce : ([< part_kind ] as 'a) -> [< part_kind ] part -> 'a part
  val coerce_if :
    ([< part_kind ] as 'a) -> [< part_kind ] part -> 'a part option
  val list_actions : kind part list -> Action.t list Conf.value
  val list_uniquify : kind part list -> kind part list
  val list_keep :
    (([< part_kind ] as 'a) part -> bool) -> 'a part list -> 'a part list
  val list_keep_map :
    (([< part_kind ] as 'a) part -> 'b option) -> 'a part list -> 'b list
  val list_keep_kind :
    ([< part_kind ] as 'a) -> [< part_kind ] part list -> 'a part list
  val list_keep_kinds :
    kind list -> ([< part_kind ] as 'a) part list -> 'a part list
  val list_fold :
    ('a -> ([< part_kind ] as 'b) part -> 'a) -> 'a -> 'b part list -> 'a
  val list_fold_kind :
    ([< part_kind ] as 'b) ->
    ('a -> 'b part -> 'a) -> 'a -> [< part_kind ] part list -> 'a
  val list_fold_rec : ('a -> kind part -> 'a) -> 'a -> kind part list -> 'a
  val list_fold_kind_rec :
    ([< part_kind ] as 'b) -> ('a -> 'b t -> 'a) -> 'a -> kind t list -> 'a
  module Set :
    sig
      type elt = kind part
      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 : kind part list -> t
    end
  module Map :
    sig
      type key = kind part
      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 t -> Set.t
    end
  val args :
    [< Assemblage.part_kind ] Assemblage.part -> Assemblage.Private.Args.t
  val ctx : [< Assemblage.part_kind ] Assemblage.part -> Assemblage.Ctx.t
  val deps :
    [< Assemblage.part_kind ] Assemblage.part ->
    Assemblage.Private.Conf.Key.Set.t
end