# A Hash is a dictionary-like collection of unique keys and their values. Also
# called associative arrays, they are similar to Arrays, but where an Array uses
# integers as its index, a Hash allows you to use any object type.
#
# Hashes enumerate their values in the order that the corresponding keys were
# inserted.
#
# A Hash can be easily created by using its implicit form:
#
#     grades = { "Jane Doe" => 10, "Jim Doe" => 6 }
#
# Hashes allow an alternate syntax for keys that are symbols. Instead of
#
#     options = { :font_size => 10, :font_family => "Arial" }
#
# You could write it as:
#
#     options = { font_size: 10, font_family: "Arial" }
#
# Each named key is a symbol you can access in hash:
#
#     options[:font_size]  # => 10
#
# A Hash can also be created through its ::new method:
#
#     grades = Hash.new
#     grades["Dorothy Doe"] = 9
#
# Hashes have a *default value* that is returned when accessing keys that do not
# exist in the hash. If no default is set `nil` is used. You can set the default
# value by sending it as an argument to Hash.new:
#
#     grades = Hash.new(0)
#
# Or by using the #default= method:
#
#     grades = {"Timmy Doe" => 8}
#     grades.default = 0
#
# Accessing a value in a Hash requires using its key:
#
#     puts grades["Jane Doe"] # => 0
#
# ### Common Uses
#
# Hashes are an easy way to represent data structures, such as
#
#     books         = {}
#     books[:matz]  = "The Ruby Programming Language"
#     books[:black] = "The Well-Grounded Rubyist"
#
# Hashes are also commonly used as a way to have named parameters in functions.
# Note that no brackets are used below. If a hash is the last argument on a
# method call, no braces are needed, thus creating a really clean interface:
#
#     Person.create(name: "John Doe", age: 27)
#
#     def self.create(params)
#       @name = params[:name]
#       @age  = params[:age]
#     end
#
# ### Hash Keys
#
# Two objects refer to the same hash key when their `hash` value is identical
# and the two objects are `eql?` to each other.
#
# A user-defined class may be used as a hash key if the `hash` and `eql?`
# methods are overridden to provide meaningful behavior.  By default, separate
# instances refer to separate hash keys.
#
# A typical implementation of `hash` is based on the object's data while `eql?`
# is usually aliased to the overridden `==` method:
#
#     class Book
#       attr_reader :author, :title
#
#       def initialize(author, title)
#         @author = author
#         @title = title
#       end
#
#       def ==(other)
#         self.class === other and
#           other.author == @author and
#           other.title == @title
#       end
#
#       alias eql? ==
#
#       def hash
#         @author.hash ^ @title.hash # XOR
#       end
#     end
#
#     book1 = Book.new 'matz', 'Ruby in a Nutshell'
#     book2 = Book.new 'matz', 'Ruby in a Nutshell'
#
#     reviews = {}
#
#     reviews[book1] = 'Great reference!'
#     reviews[book2] = 'Nice and compact!'
#
#     reviews.length #=> 1
#
# See also Object#hash and Object#eql?
#
class Hash[unchecked out K, unchecked out V] < Object
  include Enumerable[[K, V]]

  # Creates a new hash populated with the given objects.
  #
  # Similar to the literal `{ *key* => *value*, ... }`. In the first form, keys
  # and values occur in pairs, so there must be an even number of arguments.
  #
  # The second and third form take a single argument which is either an array of
  # key-value pairs or an object convertible to a hash.
  #
  #     Hash["a", 100, "b", 200]             #=> {"a"=>100, "b"=>200}
  #     Hash[ [ ["a", 100], ["b", 200] ] ]   #=> {"a"=>100, "b"=>200}
  #     Hash["a" => 100, "b" => 200]         #=> {"a"=>100, "b"=>200}
  #
  def self.[]: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
             | [U, V] (Array[[ U, V ]]) -> ::Hash[U, V]
             | (*untyped) -> ::Hash[untyped, untyped]

  # Try to convert *obj* into a hash, using to_hash method. Returns converted hash
  # or nil if *obj* cannot be converted for any reason.
  #
  #     Hash.try_convert({1=>2})   # => {1=>2}
  #     Hash.try_convert("1=>2")   # => nil
  #
  def self.try_convert: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
                      | (untyped) -> (::Hash[untyped, untyped] | nil)

  public

  # Returns `true` if *hash* is subset of *other*.
  #
  #     h1 = {a:1, b:2}
  #     h2 = {a:1, b:2, c:3}
  #     h1 < h2    #=> true
  #     h2 < h1    #=> false
  #     h1 < h1    #=> false
  #
  def <: [A, B] (::Hash[A, B]) -> bool

  # Returns `true` if *hash* is subset of *other* or equals to *other*.
  #
  #     h1 = {a:1, b:2}
  #     h2 = {a:1, b:2, c:3}
  #     h1 <= h2   #=> true
  #     h2 <= h1   #=> false
  #     h1 <= h1   #=> true
  #
  def <=: [A, B] (::Hash[A, B]) -> bool

  # Equality---Two hashes are equal if they each contain the same number of keys
  # and if each key-value pair is equal to (according to Object#==) the
  # corresponding elements in the other hash.
  #
  #     h1 = { "a" => 1, "c" => 2 }
  #     h2 = { 7 => 35, "c" => 2, "a" => 1 }
  #     h3 = { "a" => 1, "c" => 2, 7 => 35 }
  #     h4 = { "a" => 1, "d" => 2, "f" => 35 }
  #     h1 == h2   #=> false
  #     h2 == h3   #=> true
  #     h3 == h4   #=> false
  #
  # The orders of each hashes are not compared.
  #
  #     h1 = { "a" => 1, "c" => 2 }
  #     h2 = { "c" => 2, "a" => 1 }
  #     h1 == h2   #=> true
  #
  def ==: (untyped other) -> bool

  # Returns `true` if *other* is subset of *hash*.
  #
  #     h1 = {a:1, b:2}
  #     h2 = {a:1, b:2, c:3}
  #     h1 > h2    #=> false
  #     h2 > h1    #=> true
  #     h1 > h1    #=> false
  #
  def >: [A, B] (::Hash[A, B]) -> bool

  # Returns `true` if *other* is subset of *hash* or equals to *hash*.
  #
  #     h1 = {a:1, b:2}
  #     h2 = {a:1, b:2, c:3}
  #     h1 >= h2   #=> false
  #     h2 >= h1   #=> true
  #     h1 >= h1   #=> true
  #
  def >=: [A, B] (::Hash[A, B]) -> bool

  # Element Reference---Retrieves the *value* object corresponding to the *key*
  # object. If not found, returns the default value (see Hash::new for details).
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h["a"]   #=> 100
  #     h["c"]   #=> nil
  #
  def []: (K arg0) -> V

  # ## Element Assignment
  #
  # Associates the value given by `value` with the key given by `key`.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h["a"] = 9
  #     h["c"] = 4
  #     h   #=> {"a"=>9, "b"=>200, "c"=>4}
  #     h.store("d", 42) #=> 42
  #     h   #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
  #
  # `key` should not have its value changed while it is in use as a key (an
  # `unfrozen String` passed as a key will be duplicated and frozen).
  #
  #     a = "a"
  #     b = "b".freeze
  #     h = { a => 100, b => 200 }
  #     h.key(100).equal? a #=> false
  #     h.key(200).equal? b #=> true
  #
  def []=: (K arg0, V arg1) -> V

  # See also Enumerable#any?
  #
  def any?: () -> bool
          | (untyped pattern) -> bool
          | () { (K, V) -> boolish } -> bool

  # Searches through the hash comparing *obj* with the key using `==`. Returns the
  # key-value pair (two elements array) or `nil` if no match is found.  See
  # Array#assoc.
  #
  #     h = {"colors"  => ["red", "blue", "green"],
  #          "letters" => ["a", "b", "c" ]}
  #     h.assoc("letters")  #=> ["letters", ["a", "b", "c"]]
  #     h.assoc("foo")      #=> nil
  #
  def assoc: (K arg0) -> [K, V]?

  # Removes all key-value pairs from *hsh*.
  #
  #     h = { "a" => 100, "b" => 200 }   #=> {"a"=>100, "b"=>200}
  #     h.clear                          #=> {}
  #
  def clear: () -> self

  # Returns a new hash with the nil values/key pairs removed
  #
  #     h = { a: 1, b: false, c: nil }
  #     h.compact     #=> { a: 1, b: false }
  #     h             #=> { a: 1, b: false, c: nil }
  #
  def compact: () -> self

  # Removes all nil values from the hash. Returns nil if no changes were made,
  # otherwise returns the hash.
  #
  #     h = { a: 1, b: false, c: nil }
  #     h.compact!     #=> { a: 1, b: false }
  #
  def compact!: () -> self?

  # Makes *hsh* compare its keys by their identity, i.e. it will consider exact
  # same objects as same keys.
  #
  #     h1 = { "a" => 100, "b" => 200, :c => "c" }
  #     h1["a"]        #=> 100
  #     h1.compare_by_identity
  #     h1.compare_by_identity? #=> true
  #     h1["a".dup]    #=> nil  # different objects.
  #     h1[:c]         #=> "c"  # same symbols are all same.
  #
  def compare_by_identity: () -> self

  # Returns `true` if *hsh* will compare its keys by their identity.  Also see
  # Hash#compare_by_identity.
  #
  def compare_by_identity?: () -> bool

  def deconstruct_keys: (Array[K] | nil) -> self

  # Returns the default value, the value that would be returned by *[hsh](key)* if
  # *key* did not exist in *hsh*. See also Hash::new and Hash#default=.
  #
  #     h = Hash.new                            #=> {}
  #     h.default                               #=> nil
  #     h.default(2)                            #=> nil
  #
  #     h = Hash.new("cat")                     #=> {}
  #     h.default                               #=> "cat"
  #     h.default(2)                            #=> "cat"
  #
  #     h = Hash.new {|h,k| h[k] = k.to_i*10}   #=> {}
  #     h.default                               #=> nil
  #     h.default(2)                            #=> 20
  #
  def default: (?K arg0) -> V?

  # Sets the default value, the value returned for a key that does not exist in
  # the hash. It is not possible to set the default to a Proc that will be
  # executed on each key lookup.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.default = "Go fish"
  #     h["a"]     #=> 100
  #     h["z"]     #=> "Go fish"
  #     # This doesn't do what you might hope...
  #     h.default = proc do |hash, key|
  #       hash[key] = key + key
  #     end
  #     h[2]       #=> #<Proc:0x401b3948@-:6>
  #     h["cat"]   #=> #<Proc:0x401b3948@-:6>
  #
  def default=: (V arg0) -> V

  # If Hash::new was invoked with a block, return that block, otherwise return
  # `nil`.
  #
  #     h = Hash.new {|h,k| h[k] = k*k }   #=> {}
  #     p = h.default_proc                 #=> #<Proc:0x401b3d08@-:1>
  #     a = []                             #=> []
  #     p.call(a, 2)
  #     a                                  #=> [nil, nil, 4]
  #
  def default_proc: () -> (Proc | nil)

  # Sets the default proc to be executed on each failed key lookup.
  #
  #     h.default_proc = proc do |hash, key|
  #       hash[key] = key + key
  #     end
  #     h[2]       #=> 4
  #     h["cat"]   #=> "catcat"
  #
  def default_proc=: (Proc | _ToProc | nil) -> (Proc | _ToProc | nil)

  # Deletes the key-value pair and returns the value from *hsh* whose key is equal
  # to *key*. If the key is not found, it returns *nil*. If the optional code
  # block is given and the key is not found, pass in the key and return the result
  # of *block*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.delete("a")                              #=> 100
  #     h.delete("z")                              #=> nil
  #     h.delete("z") { |el| "#{el} not found" }   #=> "z not found"
  #
  def delete: (K arg0) -> V?
            | [U] (K arg0) { (K arg0) -> U } -> (U | V)

  # Deletes every key-value pair from *hsh* for which *block* evaluates to `true`.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200, "c" => 300 }
  #     h.delete_if {|key, value| key >= "b" }   #=> {"a"=>100}
  #
  def delete_if: () { (K, V) -> boolish } -> self
               | () -> ::Enumerator[[ K, V ], self]

  # Extracts the nested value specified by the sequence of *key* objects by
  # calling `dig` at each step, returning `nil` if any intermediate step is `nil`.
  #
  #     h = { foo: {bar: {baz: 1}}}
  #
  #     h.dig(:foo, :bar, :baz)     #=> 1
  #     h.dig(:foo, :zot, :xyz)     #=> nil
  #
  #     g = { foo: [10, 11, 12] }
  #     g.dig(:foo, 1)              #=> 11
  #     g.dig(:foo, 1, 0)           #=> TypeError: Integer does not have #dig method
  #     g.dig(:foo, :bar)           #=> TypeError: no implicit conversion of Symbol into Integer
  #
  def dig: (*untyped) -> untyped

  # Calls *block* once for each key in *hsh*, passing the key-value pair as
  # parameters.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.each {|key, value| puts "#{key} is #{value}" }
  #
  # *produces:*
  #
  #     a is 100
  #     b is 200
  #
  def each: () { ([ K, V ] arg0) -> untyped } -> self
          | () -> ::Enumerator[[ K, V ], self]

  # Calls *block* once for each key in *hsh*, passing the key as a parameter.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.each_key {|key| puts key }
  #
  # *produces:*
  #
  #     a
  #     b
  #
  def each_key: () { (K arg0) -> untyped } -> ::Hash[K, V]
              | () -> ::Enumerator[K, self]

  # Calls *block* once for each key in *hsh*, passing the key-value pair as
  # parameters.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.each {|key, value| puts "#{key} is #{value}" }
  #
  # *produces:*
  #
  #     a is 100
  #     b is 200
  #
  alias each_pair each

  # Calls *block* once for each key in *hsh*, passing the value as a parameter.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.each_value {|value| puts value }
  #
  # *produces:*
  #
  #     100
  #     200
  #
  def each_value: () { (V arg0) -> untyped } -> self
                | () -> ::Enumerator[V, self]

  # Returns `true` if *hsh* contains no key-value pairs.
  #
  #     {}.empty?   #=> true
  #
  def empty?: () -> bool

  # Returns `true` if *hash* and *other* are both hashes with the same content.
  # The orders of each hashes are not compared.
  #
  def eql?: (untyped) -> bool

  # Returns a value from the hash for the given key. If the key can't be found,
  # there are several options: With no other arguments, it will raise a KeyError
  # exception; if *default* is given, then that will be returned; if the optional
  # code block is specified, then that will be run and its result returned.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.fetch("a")                            #=> 100
  #     h.fetch("z", "go fish")                 #=> "go fish"
  #     h.fetch("z") { |el| "go fish, #{el}"}   #=> "go fish, z"
  #
  # The following example shows that an exception is raised if the key is not
  # found and a default value is not supplied.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.fetch("z")
  #
  # *produces:*
  #
  #     prog.rb:2:in `fetch': key not found (KeyError)
  #      from prog.rb:2
  #
  def fetch: (K arg0) -> V
           | [X] (K arg0, X arg1) -> (V | X)
           | [X] (K arg0) { (K arg0) -> X } -> (V | X)

  # Returns an array containing the values associated with the given keys but also
  # raises KeyError when one of keys can't be found. Also see Hash#values_at and
  # Hash#fetch.
  #
  #     h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
  #
  #     h.fetch_values("cow", "cat")                   #=> ["bovine", "feline"]
  #     h.fetch_values("cow", "bird")                  # raises KeyError
  #     h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"]
  #
  def fetch_values: (*K) -> Array[V]
                  | [X] (*K) { (K) -> X } -> (V | X)

  # Returns a new hash consisting of entries for which the block returns true.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200, "c" => 300 }
  #     h.select {|k,v| k > "a"}  #=> {"b" => 200, "c" => 300}
  #     h.select {|k,v| v < 200}  #=> {"a" => 100}
  #
  # Hash#filter is an alias for Hash#select.
  #
  def filter: () { (K, V) -> boolish } -> self
            | () -> ::Enumerator[[ K, V ], self]

  # Equivalent to Hash#keep_if, but returns `nil` if no changes were made.
  #
  # Hash#filter! is an alias for Hash#select!.
  #
  def filter!: () { (K, V) -> boolish } -> self?
             | () -> ::Enumerator[[ K, V ], self?]

  # Returns a new array that is a one-dimensional flattening of this hash. That
  # is, for every key or value that is an array, extract its elements into the new
  # array.  Unlike Array#flatten, this method does not flatten recursively by
  # default.  The optional *level* argument determines the level of recursion to
  # flatten.
  #
  #     a =  {1=> "one", 2 => [2,"two"], 3 => "three"}
  #     a.flatten    # => [1, "one", 2, [2, "two"], 3, "three"]
  #     a.flatten(2) # => [1, "one", 2, 2, "two", 3, "three"]
  #
  def flatten: () -> ::Array[K | V]
             | (1 level) -> ::Array[K | V]
             | (Integer level) -> Array[untyped]

  # Returns `true` if the given key is present in *hsh*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.has_key?("a")   #=> true
  #     h.has_key?("z")   #=> false
  #
  # Note that #include? and #member? do not test member equality using `==` as do
  # other Enumerables.
  #
  # See also Enumerable#include?
  #
  def has_key?: (K arg0) -> bool

  # Returns `true` if the given value is present for some key in *hsh*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.value?(100)   #=> true
  #     h.value?(999)   #=> false
  #
  def has_value?: (V arg0) -> bool

  # Compute a hash-code for this hash. Two hashes with the same content will have
  # the same hash code (and will compare using `eql?`).
  #
  # See also Object#hash.
  #
  def hash: () -> Integer

  # Returns `true` if the given key is present in *hsh*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.has_key?("a")   #=> true
  #     h.has_key?("z")   #=> false
  #
  # Note that #include? and #member? do not test member equality using `==` as do
  # other Enumerables.
  #
  # See also Enumerable#include?
  #
  alias include? has_key?

  def index: (V) -> K?

  # Return the contents of this hash as a string.
  #
  #     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
  #     h.to_s   #=> "{\"c\"=>300, \"a\"=>100, \"d\"=>400}"
  #
  def inspect: () -> String

  # Returns a new hash created by using *hsh*'s values as keys, and the keys as
  # values. If a key with the same value already exists in the *hsh*, then the
  # last one defined will be used, the earlier value(s) will be discarded.
  #
  #     h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
  #     h.invert   #=> {0=>"a", 100=>"m", 200=>"d", 300=>"y"}
  #
  # If there is no key with the same value, Hash#invert is involutive.
  #
  #     h = { a: 1, b: 3, c: 4 }
  #     h.invert.invert == h #=> true
  #
  # The condition, no key with the same value, can be tested by comparing the size
  # of inverted hash.
  #
  #     # no key with the same value
  #     h = { a: 1, b: 3, c: 4 }
  #     h.size == h.invert.size #=> true
  #
  #     # two (or more) keys has the same value
  #     h = { a: 1, b: 3, c: 1 }
  #     h.size == h.invert.size #=> false
  #
  def invert: () -> ::Hash[V, K]

  # Deletes every key-value pair from *hsh* for which *block* evaluates to
  # `false`.
  #
  # If no block is given, an enumerator is returned instead.
  #
  # See also Hash#select!.
  #
  def keep_if: () { (K, V) -> boolish } -> self
             | () -> ::Enumerator[[ K, V ], self]

  # Returns the key of an occurrence of a given value. If the value is not found,
  # returns `nil`.
  #
  #     h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 }
  #     h.key(200)   #=> "b"
  #     h.key(300)   #=> "c"
  #     h.key(999)   #=> nil
  #
  alias key index

  # Returns `true` if the given key is present in *hsh*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.has_key?("a")   #=> true
  #     h.has_key?("z")   #=> false
  #
  # Note that #include? and #member? do not test member equality using `==` as do
  # other Enumerables.
  #
  # See also Enumerable#include?
  #
  alias key? has_key?

  # Returns a new array populated with the keys from this hash. See also
  # Hash#values.
  #
  #     h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
  #     h.keys   #=> ["a", "b", "c", "d"]
  #
  def keys: () -> ::Array[K]

  # Returns the number of key-value pairs in the hash.
  #
  #     h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
  #     h.size          #=> 4
  #     h.delete("a")   #=> 200
  #     h.size          #=> 3
  #     h.length        #=> 3
  #
  # Hash#length is an alias for Hash#size.
  #
  def length: () -> Integer

  # Returns `true` if the given key is present in *hsh*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.has_key?("a")   #=> true
  #     h.has_key?("z")   #=> false
  #
  # Note that #include? and #member? do not test member equality using `==` as do
  # other Enumerables.
  #
  # See also Enumerable#include?
  #
  alias member? has_key?

  # Returns a new hash that combines the contents of the receiver and the contents
  # of the given hashes.
  #
  # If no block is given, entries with duplicate keys are overwritten with the
  # values from each `other_hash` successively, otherwise the value for each
  # duplicate key is determined by calling the block with the key, its value in
  # the receiver and its value in each `other_hash`.
  #
  # When called without any argument, returns a copy of the receiver.
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h2 = { "b" => 246, "c" => 300 }
  #     h3 = { "b" => 357, "d" => 400 }
  #     h1.merge          #=> {"a"=>100, "b"=>200}
  #     h1.merge(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
  #     h1.merge(h2, h3)  #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
  #     h1.merge(h2) {|key, oldval, newval| newval - oldval}
  #                       #=> {"a"=>100, "b"=>46,  "c"=>300}
  #     h1.merge(h2, h3) {|key, oldval, newval| newval - oldval}
  #                       #=> {"a"=>100, "b"=>311, "c"=>300, "d"=>400}
  #     h1                #=> {"a"=>100, "b"=>200}
  #
  def merge: [A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V]
           | [A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> (C) } -> ::Hash[A | K, B | V | C]

  # Adds the contents of the given hashes to the receiver.
  #
  # If no block is given, entries with duplicate keys are overwritten with the
  # values from each `other_hash` successively, otherwise the value for each
  # duplicate key is determined by calling the block with the key, its value in
  # the receiver and its value in each `other_hash`.
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h1.merge!          #=> {"a"=>100, "b"=>200}
  #     h1                 #=> {"a"=>100, "b"=>200}
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h2 = { "b" => 246, "c" => 300 }
  #     h1.merge!(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
  #     h1                 #=> {"a"=>100, "b"=>246, "c"=>300}
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h2 = { "b" => 246, "c" => 300 }
  #     h3 = { "b" => 357, "d" => 400 }
  #     h1.merge!(h2, h3)
  #                        #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
  #     h1                 #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h2 = { "b" => 246, "c" => 300 }
  #     h3 = { "b" => 357, "d" => 400 }
  #     h1.merge!(h2, h3) {|key, v1, v2| v1 }
  #                        #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
  #     h1                 #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
  #
  # Hash#update is an alias for Hash#merge!.
  #
  def merge!: (*::Hash[K, V] other_hashes) -> self
            | (*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> (V) } -> self

  # Searches through the hash comparing *obj* with the value using `==`. Returns
  # the first key-value pair (two-element array) that matches. See also
  # Array#rassoc.
  #
  #     a = {1=> "one", 2 => "two", 3 => "three", "ii" => "two"}
  #     a.rassoc("two")    #=> [2, "two"]
  #     a.rassoc("four")   #=> nil
  #
  def rassoc: (V) -> [K, V]?

  # Rebuilds the hash based on the current hash values for each key. If values of
  # key objects have changed since they were inserted, this method will reindex
  # *hsh*. If Hash#rehash is called while an iterator is traversing the hash, a
  # RuntimeError will be raised in the iterator.
  #
  #     a = [ "a", "b" ]
  #     c = [ "c", "d" ]
  #     h = { a => 100, c => 300 }
  #     h[a]       #=> 100
  #     a[0] = "z"
  #     h[a]       #=> nil
  #     h.rehash   #=> {["z", "b"]=>100, ["c", "d"]=>300}
  #     h[a]       #=> 100
  #
  def rehash: () -> self

  # Returns a new hash consisting of entries for which the block returns false.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200, "c" => 300 }
  #     h.reject {|k,v| k < "b"}  #=> {"b" => 200, "c" => 300}
  #     h.reject {|k,v| v > 100}  #=> {"a" => 100}
  #
  def reject: () -> ::Enumerator[[ K, V ], self]
            | () { (K, V) -> boolish } -> self

  # Equivalent to Hash#delete_if, but returns `nil` if no changes were made.
  #
  def reject!: () -> ::Enumerator[[ K, V ], self?]
            | () { (K, V) -> boolish } -> self?

  # Replaces the contents of *hsh* with the contents of *other_hash*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}
  #
  def replace: (Hash[K, V]) -> self

  # Returns a new hash consisting of entries for which the block returns true.
  #
  # If no block is given, an enumerator is returned instead.
  #
  #     h = { "a" => 100, "b" => 200, "c" => 300 }
  #     h.select {|k,v| k > "a"}  #=> {"b" => 200, "c" => 300}
  #     h.select {|k,v| v < 200}  #=> {"a" => 100}
  #
  # Hash#filter is an alias for Hash#select.
  #
  alias select filter

  # Equivalent to Hash#keep_if, but returns `nil` if no changes were made.
  #
  # Hash#filter! is an alias for Hash#select!.
  #
  alias select! filter!

  # Removes a key-value pair from *hsh* and returns it as the two-item array `[`
  # *key, value* `]`, or the hash's default value if the hash is empty.
  #
  #     h = { 1 => "a", 2 => "b", 3 => "c" }
  #     h.shift   #=> [1, "a"]
  #     h         #=> {2=>"b", 3=>"c"}
  #
  def shift: () -> [ K, V ]?

  # Returns the number of key-value pairs in the hash.
  #
  #     h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
  #     h.size          #=> 4
  #     h.delete("a")   #=> 200
  #     h.size          #=> 3
  #     h.length        #=> 3
  #
  # Hash#length is an alias for Hash#size.
  #
  alias size length

  # Returns a hash containing only the given keys and their values.
  #
  #     h = { a: 100, b: 200, c: 300 }
  #     h.slice(:a)           #=> {:a=>100}
  #     h.slice(:b, :c, :d)   #=> {:b=>200, :c=>300}
  #
  def slice: (*K) -> self

  # ## Element Assignment
  #
  # Associates the value given by `value` with the key given by `key`.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h["a"] = 9
  #     h["c"] = 4
  #     h   #=> {"a"=>9, "b"=>200, "c"=>4}
  #     h.store("d", 42) #=> 42
  #     h   #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
  #
  # `key` should not have its value changed while it is in use as a key (an
  # `unfrozen String` passed as a key will be duplicated and frozen).
  #
  #     a = "a"
  #     b = "b".freeze
  #     h = { a => 100, b => 200 }
  #     h.key(100).equal? a #=> false
  #     h.key(200).equal? b #=> true
  #
  alias store []=

  # Converts *hsh* to a nested array of `[` *key, value* `]` arrays.
  #
  #     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
  #     h.to_a   #=> [["c", 300], ["a", 100], ["d", 400]]
  #
  def to_a: () -> ::Array[[ K, V ]]

  # Returns `self`. If called on a subclass of Hash, converts the receiver to a
  # Hash object.
  #
  # If a block is given, the results of the block on each pair of the receiver
  # will be used as pairs.
  #
  def to_h: () -> Hash[K, V]
          | [A, B] () { (K, V) -> [ A, B ] } -> Hash[A, B]

  # Returns `self`.
  #
  def to_hash: () -> ::Hash[K, V]

  # Returns a Proc which maps keys to values.
  #
  #     h = {a:1, b:2}
  #     hp = h.to_proc
  #     hp.call(:a)          #=> 1
  #     hp.call(:b)          #=> 2
  #     hp.call(:c)          #=> nil
  #     [:a, :b, :c].map(&h) #=> [1, 2, nil]
  #
  def to_proc: () -> ^(K) -> V?

  alias to_s inspect

  # Returns a new hash with the results of running the block once for every key.
  # This method does not change the values.
  #
  #     h = { a: 1, b: 2, c: 3 }
  #     h.transform_keys {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
  #     h.transform_keys(&:to_s)        #=> { "a" => 1, "b" => 2, "c" => 3 }
  #     h.transform_keys.with_index {|k, i| "#{k}.#{i}" }
  #                                     #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }
  #
  # If no block is given, an enumerator is returned instead.
  #
  def transform_keys: () -> Enumerator[K, Hash[untyped, V]]
                    | [A] () { (K) -> A } -> Hash[A, V]

  # Invokes the given block once for each key in *hsh*, replacing it with the new
  # key returned by the block, and then returns *hsh*. This method does not change
  # the values.
  #
  #     h = { a: 1, b: 2, c: 3 }
  #     h.transform_keys! {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
  #     h.transform_keys!(&:to_sym)      #=> { a: 1, b: 2, c: 3 }
  #     h.transform_keys!.with_index {|k, i| "#{k}.#{i}" }
  #                                      #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }
  #
  # If no block is given, an enumerator is returned instead.
  #
  def transform_keys!: () -> Enumerator[K, Hash[untyped, V]]
                     | () { (K) -> K } -> Hash[K, V]

  # Returns a new hash with the results of running the block once for every value.
  # This method does not change the keys.
  #
  #     h = { a: 1, b: 2, c: 3 }
  #     h.transform_values {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
  #     h.transform_values(&:to_s)           #=> { a: "1", b: "2", c: "3" }
  #     h.transform_values.with_index {|v, i| "#{v}.#{i}" }
  #                                          #=> { a: "1.0", b: "2.1", c: "3.2" }
  #
  # If no block is given, an enumerator is returned instead.
  #
  def transform_values: () -> Enumerator[K, Hash[K, untyped]]
                      | [A] () { (V) -> A } -> Hash[K, A]

  # Invokes the given block once for each value in *hsh*, replacing it with the
  # new value returned by the block, and then returns *hsh*. This method does not
  # change the keys.
  #
  #     h = { a: 1, b: 2, c: 3 }
  #     h.transform_values! {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
  #     h.transform_values!(&:to_s)           #=> { a: "2", b: "5", c: "10" }
  #     h.transform_values!.with_index {|v, i| "#{v}.#{i}" }
  #                                           #=> { a: "2.0", b: "5.1", c: "10.2" }
  #
  # If no block is given, an enumerator is returned instead.
  #
  def transform_values!: () -> Enumerator[K, Hash[K, untyped]]
                       | () { (V) -> V } -> Hash[K, V]

  # Adds the contents of the given hashes to the receiver.
  #
  # If no block is given, entries with duplicate keys are overwritten with the
  # values from each `other_hash` successively, otherwise the value for each
  # duplicate key is determined by calling the block with the key, its value in
  # the receiver and its value in each `other_hash`.
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h1.merge!          #=> {"a"=>100, "b"=>200}
  #     h1                 #=> {"a"=>100, "b"=>200}
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h2 = { "b" => 246, "c" => 300 }
  #     h1.merge!(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
  #     h1                 #=> {"a"=>100, "b"=>246, "c"=>300}
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h2 = { "b" => 246, "c" => 300 }
  #     h3 = { "b" => 357, "d" => 400 }
  #     h1.merge!(h2, h3)
  #                        #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
  #     h1                 #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
  #
  #     h1 = { "a" => 100, "b" => 200 }
  #     h2 = { "b" => 246, "c" => 300 }
  #     h3 = { "b" => 357, "d" => 400 }
  #     h1.merge!(h2, h3) {|key, v1, v2| v1 }
  #                        #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
  #     h1                 #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
  #
  # Hash#update is an alias for Hash#merge!.
  #
  alias update merge!

  # Returns `true` if the given value is present for some key in *hsh*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.value?(100)   #=> true
  #     h.value?(999)   #=> false
  #
  alias value? has_value?

  # Returns a new array populated with the values from *hsh*. See also Hash#keys.
  #
  #     h = { "a" => 100, "b" => 200, "c" => 300 }
  #     h.values   #=> [100, 200, 300]
  #
  def values: () -> ::Array[V]

  # Return an array containing the values associated with the given keys. Also see
  # Hash.select.
  #
  #     h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
  #     h.values_at("cow", "cat")  #=> ["bovine", "feline"]
  #
  def values_at: (*K arg0) -> ::Array[V?]

  private

  # Returns a new, empty hash. If this hash is subsequently accessed by a key that
  # doesn't correspond to a hash entry, the value returned depends on the style of
  # `new` used to create the hash. In the first form, the access returns `nil`. If
  # *obj* is specified, this single object will be used for all *default values*.
  # If a block is specified, it will be called with the hash object and the key,
  # and should return the default value. It is the block's responsibility to store
  # the value in the hash if required.
  #
  #     h = Hash.new("Go Fish")
  #     h["a"] = 100
  #     h["b"] = 200
  #     h["a"]           #=> 100
  #     h["c"]           #=> "Go Fish"
  #     # The following alters the single default object
  #     h["c"].upcase!   #=> "GO FISH"
  #     h["d"]           #=> "GO FISH"
  #     h.keys           #=> ["a", "b"]
  #
  #     # While this creates a new default object each time
  #     h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
  #     h["c"]           #=> "Go Fish: c"
  #     h["c"].upcase!   #=> "GO FISH: C"
  #     h["d"]           #=> "Go Fish: d"
  #     h.keys           #=> ["c", "d"]
  #
  def initialize: () -> void
                             | (untyped default) -> void
                             | [A, B] () { (Hash[A, B] hash, A key) -> B } -> void

  # Replaces the contents of *hsh* with the contents of *other_hash*.
  #
  #     h = { "a" => 100, "b" => 200 }
  #     h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}
  #
  def initialize_copy: (self object) -> self
end