# Module Extended_hashtbl.Access_control

    module Access_control: sig .. end

    type ('key, 'data, -'z) any

    module Immutable: sig .. end

    module Read_only: sig .. end

    module Read_write: sig .. end

    val of_hashtbl : ('key, 'data) Core.Std.Hashtbl.t ->
           ('key, 'data, [< 'a Core.Std.perms ]) any

    val clear : ('a, 'b) Read_write.t -> unit

    val copy : ('a, 'b, [> Core.Std.read ]) any ->
           ('a, 'b, [< 'c Core.Std.perms ]) any

    val fold : ('a, 'b, [> Core.Std.read ]) any ->
           init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c

    val iter : ('a, 'b, [> Core.Std.read ]) any ->
           f:(key:'a -> data:'b -> unit) -> unit

    val existsi : ('a, 'b, [> Core.Std.read ]) any ->
           f:(key:'a -> data:'b -> bool) -> bool

    val exists : ('a, 'b, [> Core.Std.read ]) any ->
           f:('b -> bool) -> bool

    val length : ('a, 'b, 'c) any -> int

    val is_empty : ('a, 'b, 'c) any -> bool

    val mem : ('a, 'b, [> Core.Std.read ]) any ->
           'a -> bool

    val remove : ('a, 'b) Read_write.t -> 'a -> unit

    val remove_one : ('a, 'b list) Read_write.t -> 'a -> unit

    val replace : ('a, 'b) Read_write.t ->
           key:'a -> data:'b -> unit

    val set : ('a, 'b) Read_write.t ->
           key:'a -> data:'b -> unit

    val add : ('a, 'b) Read_write.t ->
           key:'a -> data:'b -> [ `Duplicate | `Ok ]

    val add_exn : ('a, 'b) Read_write.t ->
           key:'a -> data:'b -> unit

    val change : ('a, 'b) Read_write.t ->
           'a -> ('b option -> 'b option) -> unit

    val add_multi : ('a, 'b list) Read_write.t ->
           key:'a -> data:'b -> unit

    val map : ('a, 'b, [> Core.Std.read ]) any ->
           f:('b -> 'c) ->
           ('a, 'c, [< 'd Core.Std.perms ]) any

    val mapi : ('a, 'b, [> Core.Std.read ]) any ->
           f:(key:'a -> data:'b -> 'c) ->
           ('a, 'c, [< 'd Core.Std.perms ]) any

    val filter_map : ('a, 'b, [> Core.Std.read ]) any ->
           f:('b -> 'c option) ->
           ('a, 'c, [< 'd Core.Std.perms ]) any

    val filter_mapi : ('a, 'b, [> Core.Std.read ]) any ->
           f:(key:'a -> data:'b -> 'c option) ->
           ('a, 'c, [< 'd Core.Std.perms ]) any

    val filter : ('a, 'b, [> Core.Std.read ]) any ->
           f:('b -> bool) ->
           ('a, 'b, [< 'c Core.Std.perms ]) any

    val filteri : ('a, 'b, [> Core.Std.read ]) any ->
           f:(key:'a -> data:'b -> bool) ->
           ('a, 'b, [< 'c Core.Std.perms ]) any

    val find_or_add : ('a, 'b) Read_write.t ->
           'a -> default:(unit -> 'b) -> 'b

    val find : ('a, 'b, [> Core.Std.read ]) any ->
           'a -> 'b option

    val find_exn : ('a, 'b, [> Core.Std.read ]) any -> 'a -> 'b

    val iter_vals : ('a, 'b, [> Core.Std.read ]) any ->
           f:('b -> unit) -> unit

    val merge : ('k, 'a, [> Core.Std.read ]) any ->
           ('k, 'b, [> Core.Std.read ]) any ->
           f:(key:'k -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
           ('k, 'c, [< 'd Core.Std.perms ]) any

    val merge_into : f:(key:'a -> 'b -> 'b option -> 'b option) ->
           src:('a, 'b, [> Core.Std.read ]) any ->
           dst:('a, 'b) Read_write.t -> unit

    val keys : ('a, 'b, [> Core.Std.read ]) any -> 'a list

    val data : ('a, 'b, [> Core.Std.read ]) any -> 'b list

    val filter_inplace : ('a, 'b) Read_write.t ->
           f:('b -> bool) -> unit

    val filteri_inplace : ('a, 'b) Read_write.t ->
           f:('a -> 'b -> bool) -> unit

    val equal : ('a, 'b, [> Core.Std.read ]) any ->
           ('a, 'b, [> Core.Std.read ]) any ->
           ('b -> 'b -> bool) -> bool

    val to_alist : ('a, 'b, [> Core.Std.read ]) any ->
           ('a * 'b) list

    val incr : ?by:int ->
           ('a, int) Read_write.t -> 'a -> unit