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 iter : (Ephemeron.S.key -> 'a -> unit) -> 'a Ephemeron.S.t -> unit
      val filter_map_inplace :
        (Ephemeron.S.key -> 'a -> 'a option) -> 'a Ephemeron.S.t -> unit
      val fold :
        (Ephemeron.S.key -> 'a -> 'b -> 'b) -> 'a Ephemeron.S.t -> 'b -> 'b
      val length : 'a Ephemeron.S.t -> int
      val stats : 'a Ephemeron.S.t -> Stdlib.Hashtbl.statistics
      val to_seq : 'a Ephemeron.S.t -> (Ephemeron.S.key * 'a) Stdlib.Seq.t
      val to_seq_keys : 'a Ephemeron.S.t -> Ephemeron.S.key Stdlib.Seq.t
      val to_seq_values : 'a Ephemeron.S.t -> 'a Stdlib.Seq.t
      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 iter :
        (Ephemeron.SeededS.key -> 'a -> unit) ->
        'a Ephemeron.SeededS.t -> unit
      val filter_map_inplace :
        (Ephemeron.SeededS.key -> 'a -> 'a option) ->
        'a Ephemeron.SeededS.t -> unit
      val fold :
        (Ephemeron.SeededS.key -> 'a -> 'b -> 'b) ->
        'a Ephemeron.SeededS.t -> 'b -> 'b
      val length : 'a Ephemeron.SeededS.t -> int
      val stats : 'a Ephemeron.SeededS.t -> Stdlib.Hashtbl.statistics
      val to_seq :
        'a Ephemeron.SeededS.t -> (Ephemeron.SeededS.key * 'a) Stdlib.Seq.t
      val to_seq_keys :
        'a Ephemeron.SeededS.t -> Ephemeron.SeededS.key Stdlib.Seq.t
      val to_seq_values : 'a Ephemeron.SeededS.t -> 'a Stdlib.Seq.t
      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 create : unit -> ('k, 'd) Ephemeron.K1.t
      val get_key : ('k, 'd) Ephemeron.K1.t -> 'k option
      val get_key_copy : ('k, 'd) Ephemeron.K1.t -> 'k option
      val set_key : ('k, 'd) Ephemeron.K1.t -> 'k -> unit
      val unset_key : ('k, 'd) Ephemeron.K1.t -> unit
      val check_key : ('k, 'd) Ephemeron.K1.t -> bool
      val blit_key :
        ('k, 'a) Ephemeron.K1.t -> ('k, 'b) Ephemeron.K1.t -> unit
      val get_data : ('k, 'd) Ephemeron.K1.t -> 'd option
      val get_data_copy : ('k, 'd) Ephemeron.K1.t -> 'd option
      val set_data : ('k, 'd) Ephemeron.K1.t -> 'd -> unit
      val unset_data : ('k, 'd) Ephemeron.K1.t -> unit
      val check_data : ('k, 'd) Ephemeron.K1.t -> bool
      val blit_data :
        ('a, 'd) Ephemeron.K1.t -> ('b, 'd) Ephemeron.K1.t -> unit
      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 iter : (key -> 'a -> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'a Seq.t
            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 iter : (key -> 'a -> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'a Seq.t
            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 create : unit -> ('k1, 'k2, 'd) Ephemeron.K2.t
      val get_key1 : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'k1 option
      val get_key1_copy : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'k1 option
      val set_key1 : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'k1 -> unit
      val unset_key1 : ('k1, 'k2, 'd) Ephemeron.K2.t -> unit
      val check_key1 : ('k1, 'k2, 'd) Ephemeron.K2.t -> bool
      val get_key2 : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'k2 option
      val get_key2_copy : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'k2 option
      val set_key2 : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'k2 -> unit
      val unset_key2 : ('k1, 'k2, 'd) Ephemeron.K2.t -> unit
      val check_key2 : ('k1, 'k2, 'd) Ephemeron.K2.t -> bool
      val blit_key1 :
        ('k1, 'a, 'b) Ephemeron.K2.t -> ('k1, 'c, 'd) Ephemeron.K2.t -> unit
      val blit_key2 :
        ('a, 'k2, 'b) Ephemeron.K2.t -> ('c, 'k2, 'd) Ephemeron.K2.t -> unit
      val blit_key12 :
        ('k1, 'k2, 'a) Ephemeron.K2.t ->
        ('k1, 'k2, 'b) Ephemeron.K2.t -> unit
      val get_data : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'd option
      val get_data_copy : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'd option
      val set_data : ('k1, 'k2, 'd) Ephemeron.K2.t -> 'd -> unit
      val unset_data : ('k1, 'k2, 'd) Ephemeron.K2.t -> unit
      val check_data : ('k1, 'k2, 'd) Ephemeron.K2.t -> bool
      val blit_data :
        ('k1, 'k2, 'd) Ephemeron.K2.t ->
        ('k1, 'k2, 'd) Ephemeron.K2.t -> unit
      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 iter : (key -> 'a -> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'a Seq.t
            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 iter : (key -> 'a -> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'a Seq.t
            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 create : int -> ('k, 'd) Ephemeron.Kn.t
      val get_key : ('k, 'd) Ephemeron.Kn.t -> int -> 'k option
      val get_key_copy : ('k, 'd) Ephemeron.Kn.t -> int -> 'k option
      val set_key : ('k, 'd) Ephemeron.Kn.t -> int -> 'k -> unit
      val unset_key : ('k, 'd) Ephemeron.Kn.t -> int -> unit
      val check_key : ('k, 'd) Ephemeron.Kn.t -> int -> bool
      val blit_key :
        ('k, 'a) Ephemeron.Kn.t ->
        int -> ('k, 'b) Ephemeron.Kn.t -> int -> int -> unit
      val get_data : ('k, 'd) Ephemeron.Kn.t -> 'd option
      val get_data_copy : ('k, 'd) Ephemeron.Kn.t -> 'd option
      val set_data : ('k, 'd) Ephemeron.Kn.t -> 'd -> unit
      val unset_data : ('k, 'd) Ephemeron.Kn.t -> unit
      val check_data : ('k, 'd) Ephemeron.Kn.t -> bool
      val blit_data :
        ('k, 'd) Ephemeron.Kn.t -> ('k, 'd) Ephemeron.Kn.t -> unit
      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 iter : (key -> 'a -> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'a Seq.t
            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 iter : (key -> 'a -> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'a Seq.t
            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
  module GenHashTable :
    sig
      type equal = ETrue | EFalse | EDead
      module MakeSeeded :
        functor
          (H : sig
                 type t
                 type 'a container
                 val hash : int -> Ephemeron.GenHashTable.MakeSeeded.t -> int
                 val equal :
                   'a Ephemeron.GenHashTable.MakeSeeded.container ->
                   Ephemeron.GenHashTable.MakeSeeded.t ->
                   Ephemeron.GenHashTable.equal
                 val create :
                   Ephemeron.GenHashTable.MakeSeeded.t ->
                   'a -> 'a Ephemeron.GenHashTable.MakeSeeded.container
                 val get_key :
                   'a Ephemeron.GenHashTable.MakeSeeded.container ->
                   Ephemeron.GenHashTable.MakeSeeded.t option
                 val get_data :
                   'a Ephemeron.GenHashTable.MakeSeeded.container ->
                   'a option
                 val set_key_data :
                   'a Ephemeron.GenHashTable.MakeSeeded.container ->
                   Ephemeron.GenHashTable.MakeSeeded.t -> 'a -> unit
                 val check_key :
                   'a Ephemeron.GenHashTable.MakeSeeded.container -> bool
               end)
          ->
          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 iter : (key -> 'a -> unit) -> 'a t -> unit
            val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'a Seq.t
            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
    end
end