sig

  module type S =
    sig
      type key
      type !'a t
      val create : int -> 'a Ephemeron.S.t
      val clear : 'a Ephemeron.S.t -> unit
      val reset : 'a Ephemeron.S.t -> unit
      val copy : 'a Ephemeron.S.t -> 'a Ephemeron.S.t
      val add : 'a Ephemeron.S.t -> Ephemeron.S.key -> 'a -> unit
      val remove : 'a Ephemeron.S.t -> Ephemeron.S.key -> unit
      val find : 'a Ephemeron.S.t -> Ephemeron.S.key -> 'a
      val find_opt : 'a Ephemeron.S.t -> Ephemeron.S.key -> 'a option
      val find_all : 'a Ephemeron.S.t -> Ephemeron.S.key -> 'a list
      val replace : 'a Ephemeron.S.t -> Ephemeron.S.key -> 'a -> unit
      val mem : 'a Ephemeron.S.t -> Ephemeron.S.key -> bool
      val length : 'a Ephemeron.S.t -> int
      val stats : 'a Ephemeron.S.t -> Stdlib.Hashtbl.statistics
      val add_seq :
        'a Ephemeron.S.t -> (Ephemeron.S.key * 'a) Stdlib.Seq.t -> unit
      val replace_seq :
        'a Ephemeron.S.t -> (Ephemeron.S.key * 'a) Stdlib.Seq.t -> unit
      val of_seq : (Ephemeron.S.key * 'a) Stdlib.Seq.t -> 'a Ephemeron.S.t
      val clean : 'a Ephemeron.S.t -> unit
      val stats_alive : 'a Ephemeron.S.t -> Stdlib.Hashtbl.statistics
    end
  module type SeededS =
    sig
      type key
      type !'a t
      val create : ?random:bool -> int -> 'a Ephemeron.SeededS.t
      val clear : 'a Ephemeron.SeededS.t -> unit
      val reset : 'a Ephemeron.SeededS.t -> unit
      val copy : 'a Ephemeron.SeededS.t -> 'a Ephemeron.SeededS.t
      val add : 'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key -> 'a -> unit
      val remove : 'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key -> unit
      val find : 'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key -> 'a
      val find_opt :
        'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key -> 'a option
      val find_all :
        'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key -> 'a list
      val replace :
        'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key -> 'a -> unit
      val mem : 'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key -> bool
      val length : 'a Ephemeron.SeededS.t -> int
      val stats : 'a Ephemeron.SeededS.t -> Stdlib.Hashtbl.statistics
      val add_seq :
        'a Ephemeron.SeededS.t ->
        (Ephemeron.SeededS.key * 'a) Stdlib.Seq.t -> unit
      val replace_seq :
        'a Ephemeron.SeededS.t ->
        (Ephemeron.SeededS.key * 'a) Stdlib.Seq.t -> unit
      val of_seq :
        (Ephemeron.SeededS.key * 'a) Stdlib.Seq.t -> 'a Ephemeron.SeededS.t
      val clean : 'a Ephemeron.SeededS.t -> unit
      val stats_alive : 'a Ephemeron.SeededS.t -> Stdlib.Hashtbl.statistics
    end
  module K1 :
    sig
      type ('k, 'd) t
      val make : 'k -> 'd -> ('k, 'd) Ephemeron.K1.t
      val query : ('k, 'd) Ephemeron.K1.t -> 'k -> 'd option
      module Make :
        functor (H : Hashtbl.HashedType) ->
          sig
            type key = H.t
            type !'a t
            val create : int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> 'a -> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> 'a -> unit
            val mem : 'a t -> key -> bool
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            val clean : 'a t -> unit
            val stats_alive : 'a t -> Hashtbl.statistics
          end
      module MakeSeeded :
        functor (H : Hashtbl.SeededHashedType) ->
          sig
            type key = H.t
            type !'a t
            val create : ?random:bool -> int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> 'a -> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> 'a -> unit
            val mem : 'a t -> key -> bool
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            val clean : 'a t -> unit
            val stats_alive : 'a t -> Hashtbl.statistics
          end
      module Bucket :
        sig
          type ('k, 'd) t
          val make : unit -> ('k, 'd) Ephemeron.K1.Bucket.t
          val add : ('k, 'd) Ephemeron.K1.Bucket.t -> 'k -> 'd -> unit
          val remove : ('k, 'd) Ephemeron.K1.Bucket.t -> 'k -> unit
          val find : ('k, 'd) Ephemeron.K1.Bucket.t -> 'k -> 'd option
          val length : ('k, 'd) Ephemeron.K1.Bucket.t -> int
          val clear : ('k, 'd) Ephemeron.K1.Bucket.t -> unit
        end
    end
  module K2 :
    sig
      type ('k1, 'k2, 'd) t
      val make : 'k1 -> 'k2 -> 'd -> ('k1, 'k2, 'd) Ephemeron.K2.t
      val query : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'k1 -> 'k2 -> 'd option
      module Make :
        functor (H1 : Hashtbl.HashedType) (H2 : Hashtbl.HashedType) ->
          sig
            type key = H1.t * H2.t
            type !'a t
            val create : int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> 'a -> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> 'a -> unit
            val mem : 'a t -> key -> bool
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            val clean : 'a t -> unit
            val stats_alive : 'a t -> Hashtbl.statistics
          end
      module MakeSeeded :
        functor (H1 : Hashtbl.SeededHashedType)
          (H2 : Hashtbl.SeededHashedType) ->
          sig
            type key = H1.t * H2.t
            type !'a t
            val create : ?random:bool -> int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> 'a -> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> 'a -> unit
            val mem : 'a t -> key -> bool
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            val clean : 'a t -> unit
            val stats_alive : 'a t -> Hashtbl.statistics
          end
      module Bucket :
        sig
          type ('k1, 'k2, 'd) t
          val make : unit -> ('k1, 'k2, 'd) Ephemeron.K2.Bucket.t
          val add :
            ('k1, 'k2, 'd) Ephemeron.K2.Bucket.t -> 'k1 -> 'k2 -> 'd -> unit
          val remove :
            ('k1, 'k2, 'd) Ephemeron.K2.Bucket.t -> 'k1 -> 'k2 -> unit
          val find :
            ('k1, 'k2, 'd) Ephemeron.K2.Bucket.t -> 'k1 -> 'k2 -> 'd option
          val length : ('k1, 'k2, 'd) Ephemeron.K2.Bucket.t -> int
          val clear : ('k1, 'k2, 'd) Ephemeron.K2.Bucket.t -> unit
        end
    end
  module Kn :
    sig
      type ('k, 'd) t
      val make : 'k array -> 'd -> ('k, 'd) Ephemeron.Kn.t
      val query : ('k, 'd) Ephemeron.Kn.t -> 'k array -> 'd option
      module Make :
        functor (H : Hashtbl.HashedType) ->
          sig
            type key = H.t array
            type !'a t
            val create : int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> 'a -> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> 'a -> unit
            val mem : 'a t -> key -> bool
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            val clean : 'a t -> unit
            val stats_alive : 'a t -> Hashtbl.statistics
          end
      module MakeSeeded :
        functor (H : Hashtbl.SeededHashedType) ->
          sig
            type key = H.t array
            type !'a t
            val create : ?random:bool -> int -> 'a t
            val clear : 'a t -> unit
            val reset : 'a t -> unit
            val copy : 'a t -> 'a t
            val add : 'a t -> key -> 'a -> unit
            val remove : 'a t -> key -> unit
            val find : 'a t -> key -> 'a
            val find_opt : 'a t -> key -> 'a option
            val find_all : 'a t -> key -> 'a list
            val replace : 'a t -> key -> 'a -> unit
            val mem : 'a t -> key -> bool
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            val clean : 'a t -> unit
            val stats_alive : 'a t -> Hashtbl.statistics
          end
      module Bucket :
        sig
          type ('k, 'd) t
          val make : unit -> ('k, 'd) Ephemeron.Kn.Bucket.t
          val add : ('k, 'd) Ephemeron.Kn.Bucket.t -> 'k array -> 'd -> unit
          val remove : ('k, 'd) Ephemeron.Kn.Bucket.t -> 'k array -> unit
          val find : ('k, 'd) Ephemeron.Kn.Bucket.t -> 'k array -> 'd option
          val length : ('k, 'd) Ephemeron.Kn.Bucket.t -> int
          val clear : ('k, 'd) Ephemeron.Kn.Bucket.t -> unit
        end
    end
end