# <!-- rdoc-file=object.c -->
# A Module is a collection of methods and constants. The methods in a module may
# be instance methods or module methods. Instance methods appear as methods in a
# class when the module is included, module methods do not. Conversely, module
# methods may be called without creating an encapsulating object, while instance
# methods may not. (See Module#module_function.)
#
# In the descriptions that follow, the parameter *sym* refers to a symbol, which
# is either a quoted string or a Symbol (such as `:name`).
#
#     module Mod
#       include Math
#       CONST = 1
#       def meth
#         #  ...
#       end
#     end
#     Mod.class              #=> Module
#     Mod.constants          #=> [:CONST, :PI, :E]
#     Mod.instance_methods   #=> [:meth]
#
class Module < Object
  # <!--
  #   rdoc-file=eval.c
  #   - Module.constants   -> array
  #   - Module.constants(inherited)   -> array
  # -->
  # In the first form, returns an array of the names of all constants accessible
  # from the point of call. This list includes the names of all modules and
  # classes defined in the global scope.
  #
  #     Module.constants.first(4)
  #        # => [:ARGF, :ARGV, :ArgumentError, :Array]
  #
  #     Module.constants.include?(:SEEK_SET)   # => false
  #
  #     class IO
  #       Module.constants.include?(:SEEK_SET) # => true
  #     end
  #
  # The second form calls the instance method `constants`.
  #
  def self.constants: () -> ::Array[Integer]

  # <!--
  #   rdoc-file=eval.c
  #   - Module.nesting    -> array
  # -->
  # Returns the list of `Modules` nested at the point of call.
  #
  #     module M1
  #       module M2
  #         $a = Module.nesting
  #       end
  #     end
  #     $a           #=> [M1::M2, M1]
  #     $a[0].name   #=> "M1::M2"
  #
  def self.nesting: () -> ::Array[Module]

  # <!--
  #   rdoc-file=eval.c
  #   - used_modules -> array
  # -->
  # Returns an array of all modules used in the current scope. The ordering of
  # modules in the resulting array is not defined.
  #
  #     module A
  #       refine Object do
  #       end
  #     end
  #
  #     module B
  #       refine Object do
  #       end
  #     end
  #
  #     using A
  #     using B
  #     p Module.used_modules
  #
  # *produces:*
  #
  #     [B, A]
  #
  def self.used_modules: () -> ::Array[Module]

  # <!--
  #   rdoc-file=eval.c
  #   - used_refinements -> array
  # -->
  # Returns an array of all modules used in the current scope. The ordering of
  # modules in the resulting array is not defined.
  #
  #     module A
  #       refine Object do
  #       end
  #     end
  #
  #     module B
  #       refine Object do
  #       end
  #     end
  #
  #     using A
  #     using B
  #     p Module.used_refinements
  #
  # *produces:*
  #
  #     [#<refinement:Object@B>, #<refinement:Object@A>]
  #
  def self.used_refinements: () -> Array[Refinement]

  # <!--
  #   rdoc-file=object.c
  #   - mod < other   ->  true, false, or nil
  # -->
  # Returns true if *mod* is a subclass of *other*. Returns `false` if *mod* is
  # the same as *other* or *mod* is an ancestor of *other*. Returns `nil` if
  # there's no relationship between the two. (Think of the relationship in terms
  # of the class definition: "class A < B" implies "A < B".)
  #
  def <: (Module other) -> bool?

  # <!--
  #   rdoc-file=object.c
  #   - mod <= other   ->  true, false, or nil
  # -->
  # Returns true if *mod* is a subclass of *other* or is the same as *other*.
  # Returns `nil` if there's no relationship between the two. (Think of the
  # relationship in terms of the class definition: "class A < B" implies "A < B".)
  #
  def <=: (Module other) -> bool?

  # <!--
  #   rdoc-file=object.c
  #   - module <=> other_module   -> -1, 0, +1, or nil
  # -->
  # Comparison---Returns -1, 0, +1 or nil depending on whether `module` includes
  # `other_module`, they are the same, or if `module` is included by
  # `other_module`.
  #
  # Returns `nil` if `module` has no relationship with `other_module`, if
  # `other_module` is not a module, or if the two values are incomparable.
  #
  def <=>: (untyped other) -> Integer?

  # <!--
  #   rdoc-file=object.c
  #   - obj == other        -> true or false
  #   - obj.equal?(other)   -> true or false
  #   - obj.eql?(other)     -> true or false
  # -->
  # Equality --- At the Object level, #== returns `true` only if `obj` and `other`
  # are the same object.  Typically, this method is overridden in descendant
  # classes to provide class-specific meaning.
  #
  # Unlike #==, the #equal? method should never be overridden by subclasses as it
  # is used to determine object identity (that is, `a.equal?(b)` if and only if
  # `a` is the same object as `b`):
  #
  #     obj = "a"
  #     other = obj.dup
  #
  #     obj == other      #=> true
  #     obj.equal? other  #=> false
  #     obj.equal? obj    #=> true
  #
  # The #eql? method returns `true` if `obj` and `other` refer to the same hash
  # key.  This is used by Hash to test members for equality.  For any pair of
  # objects where #eql? returns `true`, the #hash value of both objects must be
  # equal. So any subclass that overrides #eql? should also override #hash
  # appropriately.
  #
  # For objects of class Object, #eql?  is synonymous with #==.  Subclasses
  # normally continue this tradition by aliasing #eql? to their overridden #==
  # method, but there are exceptions. Numeric types, for example, perform type
  # conversion across #==, but not across #eql?, so:
  #
  #     1 == 1.0     #=> true
  #     1.eql? 1.0   #=> false
  #
  def ==: (untyped other) -> bool

  # <!--
  #   rdoc-file=object.c
  #   - mod === obj    -> true or false
  # -->
  # Case Equality---Returns `true` if *obj* is an instance of *mod* or an instance
  # of one of *mod*'s descendants. Of limited use for modules, but can be used in
  # `case` statements to classify objects by class.
  #
  def ===: (untyped other) -> bool

  # <!--
  #   rdoc-file=object.c
  #   - mod > other   ->  true, false, or nil
  # -->
  # Returns true if *mod* is an ancestor of *other*. Returns `false` if *mod* is
  # the same as *other* or *mod* is a descendant of *other*. Returns `nil` if
  # there's no relationship between the two. (Think of the relationship in terms
  # of the class definition: "class A < B" implies "B > A".)
  #
  def >: (Module other) -> bool?

  # <!--
  #   rdoc-file=object.c
  #   - mod >= other   ->  true, false, or nil
  # -->
  # Returns true if *mod* is an ancestor of *other*, or the two modules are the
  # same. Returns `nil` if there's no relationship between the two. (Think of the
  # relationship in terms of the class definition: "class A < B" implies "B > A".)
  #
  def >=: (Module other) -> bool?

  # <!--
  #   rdoc-file=vm_method.c
  #   - alias_method(new_name, old_name)   -> symbol
  # -->
  # Makes *new_name* a new copy of the method *old_name*. This can be used to
  # retain access to methods that are overridden.
  #
  #     module Mod
  #       alias_method :orig_exit, :exit #=> :orig_exit
  #       def exit(code=0)
  #         puts "Exiting with code #{code}"
  #         orig_exit(code)
  #       end
  #     end
  #     include Mod
  #     exit(99)
  #
  # *produces:*
  #
  #     Exiting with code 99
  #
  def alias_method: (interned new_name, interned old_name) -> ::Symbol

  # <!--
  #   rdoc-file=object.c
  #   - mod.ancestors -> array
  # -->
  # Returns a list of modules included/prepended in *mod* (including *mod*
  # itself).
  #
  #     module Mod
  #       include Math
  #       include Comparable
  #       prepend Enumerable
  #     end
  #
  #     Mod.ancestors        #=> [Enumerable, Mod, Comparable, Math]
  #     Math.ancestors       #=> [Math]
  #     Enumerable.ancestors #=> [Enumerable]
  #
  def ancestors: () -> ::Array[Module]

  # <!--
  #   rdoc-file=eval.c
  #   - append_features(mod)   -> mod
  # -->
  # When this module is included in another, Ruby calls #append_features in this
  # module, passing it the receiving module in *mod*. Ruby's default
  # implementation is to add the constants, methods, and module variables of this
  # module to *mod* if this module has not already been added to *mod* or one of
  # its ancestors. See also Module#include.
  #
  def append_features: (Module arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - attr_accessor(symbol, ...)    -> array
  #   - attr_accessor(string, ...)    -> array
  # -->
  # Defines a named attribute for this module, where the name is
  # *symbol.*`id2name`, creating an instance variable (`@name`) and a
  # corresponding access method to read it. Also creates a method called `name=`
  # to set the attribute. String arguments are converted to symbols. Returns an
  # array of defined method names as symbols.
  #
  #     module Mod
  #       attr_accessor(:one, :two) #=> [:one, :one=, :two, :two=]
  #     end
  #     Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]
  #
  def attr_accessor: (*interned arg0) -> Array[Symbol]

  # <!--
  #   rdoc-file=object.c
  #   - attr_reader(symbol, ...)  -> array
  #   - attr(symbol, ...)         -> array
  #   - attr_reader(string, ...)  -> array
  #   - attr(string, ...)         -> array
  # -->
  # Creates instance variables and corresponding methods that return the value of
  # each instance variable. Equivalent to calling ```attr`*:name*'' on each name
  # in turn. String arguments are converted to symbols. Returns an array of
  # defined method names as symbols.
  #
  def attr_reader: (*interned arg0) -> Array[Symbol]

  # <!--
  #   rdoc-file=object.c
  #   - attr_writer(symbol, ...)    -> array
  #   - attr_writer(string, ...)    -> array
  # -->
  # Creates an accessor method to allow assignment to the attribute
  # *symbol*`.id2name`. String arguments are converted to symbols. Returns an
  # array of defined method names as symbols.
  #
  def attr_writer: (*interned arg0) -> Array[Symbol]

  # <!--
  #   rdoc-file=load.c
  #   - mod.autoload(const, filename)   -> nil
  # -->
  # Registers *filename* to be loaded (using Kernel::require) the first time that
  # *const* (which may be a String or a symbol) is accessed in the namespace of
  # *mod*.
  #
  #     module A
  #     end
  #     A.autoload(:B, "b")
  #     A::B.doit            # autoloads "b"
  #
  # If *const* in *mod* is defined as autoload, the file name to be loaded is
  # replaced with *filename*.  If *const* is defined but not as autoload, does
  # nothing.
  #
  def autoload: (interned _module, String filename) -> NilClass

  # <!--
  #   rdoc-file=load.c
  #   - mod.autoload?(name, inherit=true)   -> String or nil
  # -->
  # Returns *filename* to be loaded if *name* is registered as `autoload` in the
  # namespace of *mod* or one of its ancestors.
  #
  #     module A
  #     end
  #     A.autoload(:B, "b")
  #     A.autoload?(:B)            #=> "b"
  #
  # If `inherit` is false, the lookup only checks the autoloads in the receiver:
  #
  #     class A
  #       autoload :CONST, "const.rb"
  #     end
  #
  #     class B < A
  #     end
  #
  #     B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
  #     B.autoload?(:CONST, false)   #=> nil, not found in B itself
  #
  def autoload?: (interned name, ?boolish inherit) -> String?

  # <!-- rdoc-file=vm_eval.c -->
  # Evaluates the string or block in the context of *mod*, except that when a
  # block is given, constant/class variable lookup is not affected. This can be
  # used to add methods to a class. `module_eval` returns the result of evaluating
  # its argument. The optional *filename* and *lineno* parameters set the text for
  # error messages.
  #
  #     class Thing
  #     end
  #     a = %q{def hello() "Hello there!" end}
  #     Thing.module_eval(a)
  #     puts Thing.new.hello()
  #     Thing.module_eval("invalid code", "dummy", 123)
  #
  # *produces:*
  #
  #     Hello there!
  #     dummy:123:in `module_eval': undefined local variable
  #         or method `code' for Thing:Class
  #
  def class_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
                | [U] () { (self m) [self: self] -> U } -> U

  # <!-- rdoc-file=vm_eval.c -->
  # Evaluates the given block in the context of the class/module. The method
  # defined in the block will belong to the receiver. Any arguments passed to the
  # method will be passed to the block. This can be used if the block needs to
  # access instance variables.
  #
  #     class Thing
  #     end
  #     Thing.class_exec{
  #       def hello() "Hello there!" end
  #     }
  #     puts Thing.new.hello()
  #
  # *produces:*
  #
  #     Hello there!
  #
  def class_exec: [U] (*untyped, **untyped) { (?) [self: self] -> U } -> U

  # <!--
  #   rdoc-file=object.c
  #   - obj.class_variable_defined?(symbol)    -> true or false
  #   - obj.class_variable_defined?(string)    -> true or false
  # -->
  # Returns `true` if the given class variable is defined in *obj*. String
  # arguments are converted to symbols.
  #
  #     class Fred
  #       @@foo = 99
  #     end
  #     Fred.class_variable_defined?(:@@foo)    #=> true
  #     Fred.class_variable_defined?(:@@bar)    #=> false
  #
  def class_variable_defined?: (interned arg0) -> bool

  # <!--
  #   rdoc-file=object.c
  #   - mod.class_variable_get(symbol)    -> obj
  #   - mod.class_variable_get(string)    -> obj
  # -->
  # Returns the value of the given class variable (or throws a NameError
  # exception). The `@@` part of the variable name should be included for regular
  # class variables. String arguments are converted to symbols.
  #
  #     class Fred
  #       @@foo = 99
  #     end
  #     Fred.class_variable_get(:@@foo)     #=> 99
  #
  def class_variable_get: (interned arg0) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - obj.class_variable_set(symbol, obj)    -> obj
  #   - obj.class_variable_set(string, obj)    -> obj
  # -->
  # Sets the class variable named by *symbol* to the given object. If the class
  # variable name is passed as a string, that string is converted to a symbol.
  #
  #     class Fred
  #       @@foo = 99
  #       def foo
  #         @@foo
  #       end
  #     end
  #     Fred.class_variable_set(:@@foo, 101)     #=> 101
  #     Fred.new.foo                             #=> 101
  #
  def class_variable_set: (interned arg0, untyped arg1) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - mod.class_variables(inherit=true)    -> array
  # -->
  # Returns an array of the names of class variables in *mod*. This includes the
  # names of class variables in any included modules, unless the *inherit*
  # parameter is set to `false`.
  #
  #     class One
  #       @@var1 = 1
  #     end
  #     class Two < One
  #       @@var2 = 2
  #     end
  #     One.class_variables          #=> [:@@var1]
  #     Two.class_variables          #=> [:@@var2, :@@var1]
  #     Two.class_variables(false)   #=> [:@@var2]
  #
  def class_variables: (?boolish inherit) -> ::Array[Symbol]

  # <!--
  #   rdoc-file=object.c
  #   - const_added(const_name)
  # -->
  # Invoked as a callback whenever a constant is assigned on the receiver
  #
  #     module Chatty
  #       def self.const_added(const_name)
  #         super
  #         puts "Added #{const_name.inspect}"
  #       end
  #       FOO = 1
  #     end
  #
  # *produces:*
  #
  #     Added :FOO
  #
  def const_added: (Symbol) -> void

  # <!--
  #   rdoc-file=object.c
  #   - mod.const_defined?(sym, inherit=true)   -> true or false
  #   - mod.const_defined?(str, inherit=true)   -> true or false
  # -->
  # Says whether *mod* or its ancestors have a constant with the given name:
  #
  #     Float.const_defined?(:EPSILON)      #=> true, found in Float itself
  #     Float.const_defined?("String")      #=> true, found in Object (ancestor)
  #     BasicObject.const_defined?(:Hash)   #=> false
  #
  # If *mod* is a `Module`, additionally `Object` and its ancestors are checked:
  #
  #     Math.const_defined?(:String)   #=> true, found in Object
  #
  # In each of the checked classes or modules, if the constant is not present but
  # there is an autoload for it, `true` is returned directly without autoloading:
  #
  #     module Admin
  #       autoload :User, 'admin/user'
  #     end
  #     Admin.const_defined?(:User)   #=> true
  #
  # If the constant is not found the callback `const_missing` is **not** called
  # and the method returns `false`.
  #
  # If `inherit` is false, the lookup only checks the constants in the receiver:
  #
  #     IO.const_defined?(:SYNC)          #=> true, found in File::Constants (ancestor)
  #     IO.const_defined?(:SYNC, false)   #=> false, not found in IO itself
  #
  # In this case, the same logic for autoloading applies.
  #
  # If the argument is not a valid constant name a `NameError` is raised with the
  # message "wrong constant name *name*":
  #
  #     Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar
  #
  def const_defined?: (interned name, ?boolish inherit) -> bool

  # <!--
  #   rdoc-file=object.c
  #   - mod.const_get(sym, inherit=true)    -> obj
  #   - mod.const_get(str, inherit=true)    -> obj
  # -->
  # Checks for a constant with the given name in *mod*. If `inherit` is set, the
  # lookup will also search the ancestors (and `Object` if *mod* is a `Module`).
  #
  # The value of the constant is returned if a definition is found, otherwise a
  # `NameError` is raised.
  #
  #     Math.const_get(:PI)   #=> 3.14159265358979
  #
  # This method will recursively look up constant names if a namespaced class name
  # is provided.  For example:
  #
  #     module Foo; class Bar; end end
  #     Object.const_get 'Foo::Bar'
  #
  # The `inherit` flag is respected on each lookup.  For example:
  #
  #     module Foo
  #       class Bar
  #         VAL = 10
  #       end
  #
  #       class Baz < Bar; end
  #     end
  #
  #     Object.const_get 'Foo::Baz::VAL'         # => 10
  #     Object.const_get 'Foo::Baz::VAL', false  # => NameError
  #
  # If the argument is not a valid constant name a `NameError` will be raised with
  # a warning "wrong constant name".
  #
  #     Object.const_get 'foobar' #=> NameError: wrong constant name foobar
  #
  def const_get: (interned name, ?boolish inherit) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - mod.const_missing(sym)    -> obj
  # -->
  # Invoked when a reference is made to an undefined constant in *mod*. It is
  # passed a symbol for the undefined constant, and returns a value to be used for
  # that constant. For example, consider:
  #
  #     def Foo.const_missing(name)
  #       name # return the constant name as Symbol
  #     end
  #
  #     Foo::UNDEFINED_CONST    #=> :UNDEFINED_CONST: symbol returned
  #
  # As the example above shows, `const_missing` is not required to create the
  # missing constant in *mod*, though that is often a side-effect. The caller gets
  # its return value when triggered. If the constant is also defined, further
  # lookups won't hit `const_missing` and will return the value stored in the
  # constant as usual. Otherwise, `const_missing` will be invoked again.
  #
  # In the next example, when a reference is made to an undefined constant,
  # `const_missing` attempts to load a file whose path is the lowercase version of
  # the constant name (thus class `Fred` is assumed to be in file `fred.rb`). If
  # defined as a side-effect of loading the file, the method returns the value
  # stored in the constant. This implements an autoload feature similar to
  # Kernel#autoload and Module#autoload, though it differs in important ways.
  #
  #     def Object.const_missing(name)
  #       @looked_for ||= {}
  #       str_name = name.to_s
  #       raise "Constant not found: #{name}" if @looked_for[str_name]
  #       @looked_for[str_name] = 1
  #       file = str_name.downcase
  #       require file
  #       const_get(name, false)
  #     end
  #
  def const_missing: (Symbol arg0) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - mod.const_set(sym, obj)    -> obj
  #   - mod.const_set(str, obj)    -> obj
  # -->
  # Sets the named constant to the given object, returning that object. Creates a
  # new constant if no constant with the given name previously existed.
  #
  #     Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0)   #=> 3.14285714285714
  #     Math::HIGH_SCHOOL_PI - Math::PI              #=> 0.00126448926734968
  #
  # If `sym` or `str` is not a valid constant name a `NameError` will be raised
  # with a warning "wrong constant name".
  #
  #     Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar
  #
  def const_set: (interned arg0, untyped arg1) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - mod.const_source_location(sym, inherit=true)   -> [String, Integer]
  #   - mod.const_source_location(str, inherit=true)   -> [String, Integer]
  # -->
  # Returns the Ruby source filename and line number containing the definition of
  # the constant specified. If the named constant is not found, `nil` is returned.
  # If the constant is found, but its source location can not be extracted
  # (constant is defined in C code), empty array is returned.
  #
  # *inherit* specifies whether to lookup in `mod.ancestors` (`true` by default).
  #
  #     # test.rb:
  #     class A         # line 1
  #       C1 = 1
  #       C2 = 2
  #     end
  #
  #     module M        # line 6
  #       C3 = 3
  #     end
  #
  #     class B < A     # line 10
  #       include M
  #       C4 = 4
  #     end
  #
  #     class A # continuation of A definition
  #       C2 = 8 # constant redefinition; warned yet allowed
  #     end
  #
  #     p B.const_source_location('C4')           # => ["test.rb", 12]
  #     p B.const_source_location('C3')           # => ["test.rb", 7]
  #     p B.const_source_location('C1')           # => ["test.rb", 2]
  #
  #     p B.const_source_location('C3', false)    # => nil  -- don't lookup in ancestors
  #
  #     p A.const_source_location('C2')           # => ["test.rb", 16] -- actual (last) definition place
  #
  #     p Object.const_source_location('B')       # => ["test.rb", 10] -- top-level constant could be looked through Object
  #     p Object.const_source_location('A')       # => ["test.rb", 1] -- class reopening is NOT considered new definition
  #
  #     p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
  #     p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules
  #
  #     p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
  #     p Object.const_source_location('String')  # => []  -- constant is defined in C code
  #
  def const_source_location: (interned name, ?boolish inherit) -> ([ String, Integer ] | [ ] | nil)

  # <!--
  #   rdoc-file=object.c
  #   - mod.constants(inherit=true)    -> array
  # -->
  # Returns an array of the names of the constants accessible in *mod*. This
  # includes the names of constants in any included modules (example at start of
  # section), unless the *inherit* parameter is set to `false`.
  #
  # The implementation makes no guarantees about the order in which the constants
  # are yielded.
  #
  #     IO.constants.include?(:SYNC)        #=> true
  #     IO.constants(false).include?(:SYNC) #=> false
  #
  # Also see Module#const_defined?.
  #
  def constants: (?boolish inherit) -> ::Array[Symbol]

  # <!--
  #   rdoc-file=proc.c
  #   - define_method(symbol, method)     -> symbol
  #   - define_method(symbol) { block }   -> symbol
  # -->
  # Defines an instance method in the receiver. The *method* parameter can be a
  # `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, it
  # is used as the method body. If a block or the *method* parameter has
  # parameters, they're used as method parameters. This block is evaluated using
  # #instance_eval.
  #
  #     class A
  #       def fred
  #         puts "In Fred"
  #       end
  #       def create_method(name, &block)
  #         self.class.define_method(name, &block)
  #       end
  #       define_method(:wilma) { puts "Charge it!" }
  #       define_method(:flint) {|name| puts "I'm #{name}!"}
  #     end
  #     class B < A
  #       define_method(:barney, instance_method(:fred))
  #     end
  #     a = B.new
  #     a.barney
  #     a.wilma
  #     a.flint('Dino')
  #     a.create_method(:betty) { p self }
  #     a.betty
  #
  # *produces:*
  #
  #     In Fred
  #     Charge it!
  #     I'm Dino!
  #     #<B:0x401b39e8>
  #
  def define_method: (interned symbol, ^() [self: instance] -> untyped | Method | UnboundMethod method) -> Symbol
                   | (interned symbol) { () [self: instance] -> untyped } -> Symbol

  # <!--
  #   rdoc-file=object.c
  #   - mod.deprecate_constant(symbol, ...)    => mod
  # -->
  # Makes a list of existing constants deprecated. Attempt to refer to them will
  # produce a warning.
  #
  #     module HTTP
  #       NotFound = Exception.new
  #       NOT_FOUND = NotFound # previous version of the library used this name
  #
  #       deprecate_constant :NOT_FOUND
  #     end
  #
  #     HTTP::NOT_FOUND
  #     # warning: constant HTTP::NOT_FOUND is deprecated
  #
  def deprecate_constant: (*interned) -> self

  def eql?: (untyped other) -> bool

  def equal?: (untyped other) -> bool

  # <!--
  #   rdoc-file=eval.c
  #   - extend_object(obj)    -> obj
  # -->
  # Extends the specified object by adding this module's constants and methods
  # (which are added as singleton methods). This is the callback method used by
  # Object#extend.
  #
  #     module Picky
  #       def Picky.extend_object(o)
  #         if String === o
  #           puts "Can't add Picky to a String"
  #         else
  #           puts "Picky added to #{o.class}"
  #           super
  #         end
  #       end
  #     end
  #     (s = Array.new).extend Picky  # Call Object.extend
  #     (s = "quick brown fox").extend Picky
  #
  # *produces:*
  #
  #     Picky added to Array
  #     Can't add Picky to a String
  #
  def extend_object: (untyped arg0) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - extended(othermod)
  # -->
  # The equivalent of `included`, but for extended modules.
  #
  #     module A
  #       def self.extended(mod)
  #         puts "#{self} extended in #{mod}"
  #       end
  #     end
  #     module Enumerable
  #       extend A
  #     end
  #      # => prints "A extended in Enumerable"
  #
  def extended: (Module othermod) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - mod.freeze       -> mod
  # -->
  # Prevents further modifications to *mod*.
  #
  # This method returns self.
  #
  def freeze: () -> self

  # <!--
  #   rdoc-file=eval.c
  #   - include(module, ...)    -> self
  # -->
  # Invokes Module.append_features on each parameter in reverse order.
  #
  def include: (Module, *Module arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - mod.include?(module)    -> true or false
  # -->
  # Returns `true` if *module* is included or prepended in *mod* or one of *mod*'s
  # ancestors.
  #
  #     module A
  #     end
  #     class B
  #       include A
  #     end
  #     class C < B
  #     end
  #     B.include?(A)   #=> true
  #     C.include?(A)   #=> true
  #     A.include?(A)   #=> false
  #
  def include?: (Module arg0) -> bool

  # <!--
  #   rdoc-file=object.c
  #   - included(othermod)
  # -->
  # Callback invoked whenever the receiver is included in another module or class.
  # This should be used in preference to `Module.append_features` if your code
  # wants to perform some action when a module is included in another.
  #
  #     module A
  #       def A.included(mod)
  #         puts "#{self} included in #{mod}"
  #       end
  #     end
  #     module Enumerable
  #       include A
  #     end
  #      # => prints "A included in Enumerable"
  #
  def included: (Module othermod) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - mod.included_modules -> array
  # -->
  # Returns the list of modules included or prepended in *mod* or one of *mod*'s
  # ancestors.
  #
  #     module Sub
  #     end
  #
  #     module Mixin
  #       prepend Sub
  #     end
  #
  #     module Outer
  #       include Mixin
  #     end
  #
  #     Mixin.included_modules   #=> [Sub]
  #     Outer.included_modules   #=> [Sub, Mixin]
  #
  def included_modules: () -> ::Array[Module]

  # <!--
  #   rdoc-file=object.c
  #   - Module.new                  -> mod
  #   - Module.new {|mod| block }   -> mod
  # -->
  # Creates a new anonymous module. If a block is given, it is passed the module
  # object, and the block is evaluated in the context of this module like
  # #module_eval.
  #
  #     fred = Module.new do
  #       def meth1
  #         "hello"
  #       end
  #       def meth2
  #         "bye"
  #       end
  #     end
  #     a = "my string"
  #     a.extend(fred)   #=> "my string"
  #     a.meth1          #=> "hello"
  #     a.meth2          #=> "bye"
  #
  # Assign the module to a constant (name starting uppercase) if you want to treat
  # it like a regular module.
  #
  def initialize: () -> void
                | () { (Module arg0) -> untyped } -> void

  # <!--
  #   rdoc-file=proc.c
  #   - mod.instance_method(symbol)   -> unbound_method
  # -->
  # Returns an `UnboundMethod` representing the given instance method in *mod*.
  #
  #     class Interpreter
  #       def do_a() print "there, "; end
  #       def do_d() print "Hello ";  end
  #       def do_e() print "!\n";     end
  #       def do_v() print "Dave";    end
  #       Dispatcher = {
  #         "a" => instance_method(:do_a),
  #         "d" => instance_method(:do_d),
  #         "e" => instance_method(:do_e),
  #         "v" => instance_method(:do_v)
  #       }
  #       def interpret(string)
  #         string.each_char {|b| Dispatcher[b].bind(self).call }
  #       end
  #     end
  #
  #     interpreter = Interpreter.new
  #     interpreter.interpret('dave')
  #
  # *produces:*
  #
  #     Hello there, Dave!
  #
  def instance_method: (interned arg0) -> UnboundMethod

  # <!--
  #   rdoc-file=object.c
  #   - mod.instance_methods(include_super=true)   -> array
  # -->
  # Returns an array containing the names of the public and protected instance
  # methods in the receiver. For a module, these are the public and protected
  # methods; for a class, they are the instance (not singleton) methods. If the
  # optional parameter is `false`, the methods of any ancestors are not included.
  #
  #     module A
  #       def method1()  end
  #     end
  #     class B
  #       include A
  #       def method2()  end
  #     end
  #     class C < B
  #       def method3()  end
  #     end
  #
  #     A.instance_methods(false)                   #=> [:method1]
  #     B.instance_methods(false)                   #=> [:method2]
  #     B.instance_methods(true).include?(:method1) #=> true
  #     C.instance_methods(false)                   #=> [:method3]
  #     C.instance_methods.include?(:method2)       #=> true
  #
  # Note that method visibility changes in the current class, as well as aliases,
  # are considered as methods of the current class by this method:
  #
  #     class C < B
  #       alias method4 method2
  #       protected :method2
  #     end
  #     C.instance_methods(false).sort               #=> [:method2, :method3, :method4]
  #
  def instance_methods: (?boolish include_super) -> ::Array[Symbol]

  # <!--
  #   rdoc-file=object.c
  #   - method_added(method_name)
  # -->
  # Invoked as a callback whenever an instance method is added to the receiver.
  #
  #     module Chatty
  #       def self.method_added(method_name)
  #         puts "Adding #{method_name.inspect}"
  #       end
  #       def self.some_class_method() end
  #       def some_instance_method() end
  #     end
  #
  # *produces:*
  #
  #     Adding :some_instance_method
  #
  def method_added: (Symbol meth) -> untyped

  # <!--
  #   rdoc-file=vm_method.c
  #   - mod.method_defined?(symbol, inherit=true)    -> true or false
  #   - mod.method_defined?(string, inherit=true)    -> true or false
  # -->
  # Returns `true` if the named method is defined by *mod*.  If *inherit* is set,
  # the lookup will also search *mod*'s ancestors. Public and protected methods
  # are matched. String arguments are converted to symbols.
  #
  #     module A
  #       def method1()  end
  #       def protected_method1()  end
  #       protected :protected_method1
  #     end
  #     class B
  #       def method2()  end
  #       def private_method2()  end
  #       private :private_method2
  #     end
  #     class C < B
  #       include A
  #       def method3()  end
  #     end
  #
  #     A.method_defined? :method1              #=> true
  #     C.method_defined? "method1"             #=> true
  #     C.method_defined? "method2"             #=> true
  #     C.method_defined? "method2", true       #=> true
  #     C.method_defined? "method2", false      #=> false
  #     C.method_defined? "method3"             #=> true
  #     C.method_defined? "protected_method1"   #=> true
  #     C.method_defined? "method4"             #=> false
  #     C.method_defined? "private_method2"     #=> false
  #
  def method_defined?: (interned name, ?boolish inherit) -> bool

  # <!--
  #   rdoc-file=object.c
  #   - method_removed(method_name)
  # -->
  # Invoked as a callback whenever an instance method is removed from the
  # receiver.
  #
  #     module Chatty
  #       def self.method_removed(method_name)
  #         puts "Removing #{method_name.inspect}"
  #       end
  #       def self.some_class_method() end
  #       def some_instance_method() end
  #       class << self
  #         remove_method :some_class_method
  #       end
  #       remove_method :some_instance_method
  #     end
  #
  # *produces:*
  #
  #     Removing :some_instance_method
  #
  def method_removed: (Symbol method_name) -> untyped

  # <!--
  #   rdoc-file=vm_eval.c
  #   - mod.class_eval(string [, filename [, lineno]])  -> obj
  #   - mod.class_eval {|mod| block }                   -> obj
  #   - mod.module_eval(string [, filename [, lineno]]) -> obj
  #   - mod.module_eval {|mod| block }                  -> obj
  # -->
  # Evaluates the string or block in the context of *mod*, except that when a
  # block is given, constant/class variable lookup is not affected. This can be
  # used to add methods to a class. `module_eval` returns the result of evaluating
  # its argument. The optional *filename* and *lineno* parameters set the text for
  # error messages.
  #
  #     class Thing
  #     end
  #     a = %q{def hello() "Hello there!" end}
  #     Thing.module_eval(a)
  #     puts Thing.new.hello()
  #     Thing.module_eval("invalid code", "dummy", 123)
  #
  # *produces:*
  #
  #     Hello there!
  #     dummy:123:in `module_eval': undefined local variable
  #         or method `code' for Thing:Class
  #
  def module_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
                 | [U] () { (self m) [self: self] -> U } -> U

  # <!--
  #   rdoc-file=vm_eval.c
  #   - mod.module_exec(arg...) {|var...| block }       -> obj
  #   - mod.class_exec(arg...) {|var...| block }        -> obj
  # -->
  # Evaluates the given block in the context of the class/module. The method
  # defined in the block will belong to the receiver. Any arguments passed to the
  # method will be passed to the block. This can be used if the block needs to
  # access instance variables.
  #
  #     class Thing
  #     end
  #     Thing.class_exec{
  #       def hello() "Hello there!" end
  #     }
  #     puts Thing.new.hello()
  #
  # *produces:*
  #
  #     Hello there!
  #
  def module_exec: [U] (*untyped, **untyped) { (?) [self: self] -> U } -> U

  # <!--
  #   rdoc-file=vm_method.c
  #   - module_function                                -> nil
  #   - module_function(method_name)                   -> method_name
  #   - module_function(method_name, method_name, ...) -> array
  # -->
  # Creates module functions for the named methods. These functions may be called
  # with the module as a receiver, and also become available as instance methods
  # to classes that mix in the module. Module functions are copies of the
  # original, and so may be changed independently. The instance-method versions
  # are made private. If used with no arguments, subsequently defined methods
  # become module functions. String arguments are converted to symbols. If a
  # single argument is passed, it is returned. If no argument is passed, nil is
  # returned. If multiple arguments are passed, the arguments are returned as an
  # array.
  #
  #     module Mod
  #       def one
  #         "This is one"
  #       end
  #       module_function :one
  #     end
  #     class Cls
  #       include Mod
  #       def call_one
  #         one
  #       end
  #     end
  #     Mod.one     #=> "This is one"
  #     c = Cls.new
  #     c.call_one  #=> "This is one"
  #     module Mod
  #       def one
  #         "This is the new one"
  #       end
  #     end
  #     Mod.one     #=> "This is one"
  #     c.call_one  #=> "This is the new one"
  #
  def module_function: () -> nil
                     | (Symbol method_name) -> Symbol
                     | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
                     | (string method_name) -> string
                     | (interned, interned, *interned method_name) -> Array[interned]

  # <!--
  #   rdoc-file=object.c
  #   - mod.name    -> string or nil
  # -->
  # Returns the name of the module *mod*.  Returns `nil` for anonymous modules.
  #
  def name: () -> String?

  # <!--
  #   rdoc-file=eval.c
  #   - prepend(module, ...)    -> self
  # -->
  # Invokes Module.prepend_features on each parameter in reverse order.
  #
  def prepend: (Module, *Module arg0) -> self

  # <!--
  #   rdoc-file=eval.c
  #   - prepend_features(mod)   -> mod
  # -->
  # When this module is prepended in another, Ruby calls #prepend_features in this
  # module, passing it the receiving module in *mod*. Ruby's default
  # implementation is to overlay the constants, methods, and module variables of
  # this module to *mod* if this module has not already been added to *mod* or one
  # of its ancestors. See also Module#prepend.
  #
  def prepend_features: (Module arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - prepended(othermod)
  # -->
  # The equivalent of `included`, but for prepended modules.
  #
  #     module A
  #       def self.prepended(mod)
  #         puts "#{self} prepended to #{mod}"
  #       end
  #     end
  #     module Enumerable
  #       prepend A
  #     end
  #      # => prints "A prepended to Enumerable"
  #
  def prepended: (Module othermod) -> untyped

  # <!--
  #   rdoc-file=vm_method.c
  #   - private                                -> nil
  #   - private(method_name)                   -> method_name
  #   - private(method_name, method_name, ...) -> array
  #   - private(array)                         -> array
  # -->
  # With no arguments, sets the default visibility for subsequently defined
  # methods to private. With arguments, sets the named methods to have private
  # visibility. String arguments are converted to symbols. An Array of Symbols
  # and/or Strings is also accepted. If a single argument is passed, it is
  # returned. If no argument is passed, nil is returned. If multiple arguments are
  # passed, the arguments are returned as an array.
  #
  #     module Mod
  #       def a()  end
  #       def b()  end
  #       private
  #       def c()  end
  #       private :a
  #     end
  #     Mod.private_instance_methods   #=> [:a, :c]
  #
  # Note that to show a private method on RDoc, use `:doc:`.
  #
  def private: () -> nil
             | (Symbol method_name) -> Symbol
             | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
             | (string method_name) -> string
             | (interned, interned, *interned method_name) -> Array[interned]
             | (Array[interned]) -> Array[interned]

  # <!--
  #   rdoc-file=vm_method.c
  #   - mod.private_class_method(symbol, ...)   -> mod
  #   - mod.private_class_method(string, ...)   -> mod
  #   - mod.private_class_method(array)         -> mod
  # -->
  # Makes existing class methods private. Often used to hide the default
  # constructor `new`.
  #
  # String arguments are converted to symbols. An Array of Symbols and/or Strings
  # is also accepted.
  #
  #     class SimpleSingleton  # Not thread safe
  #       private_class_method :new
  #       def SimpleSingleton.create(*args, &block)
  #         @me = new(*args, &block) if ! @me
  #         @me
  #       end
  #     end
  #
  def private_class_method: (*interned arg0) -> self
                          | (Array[interned] arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - mod.private_constant(symbol, ...)    => mod
  # -->
  # Makes a list of existing constants private.
  #
  def private_constant: (*interned arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - mod.private_instance_methods(include_super=true)    -> array
  # -->
  # Returns a list of the private instance methods defined in *mod*. If the
  # optional parameter is `false`, the methods of any ancestors are not included.
  #
  #     module Mod
  #       def method1()  end
  #       private :method1
  #       def method2()  end
  #     end
  #     Mod.instance_methods           #=> [:method2]
  #     Mod.private_instance_methods   #=> [:method1]
  #
  def private_instance_methods: (?boolish include_super) -> ::Array[Symbol]

  # <!--
  #   rdoc-file=vm_method.c
  #   - mod.private_method_defined?(symbol, inherit=true)    -> true or false
  #   - mod.private_method_defined?(string, inherit=true)    -> true or false
  # -->
  # Returns `true` if the named private method is defined by *mod*.  If *inherit*
  # is set, the lookup will also search *mod*'s ancestors. String arguments are
  # converted to symbols.
  #
  #     module A
  #       def method1()  end
  #     end
  #     class B
  #       private
  #       def method2()  end
  #     end
  #     class C < B
  #       include A
  #       def method3()  end
  #     end
  #
  #     A.method_defined? :method1                   #=> true
  #     C.private_method_defined? "method1"          #=> false
  #     C.private_method_defined? "method2"          #=> true
  #     C.private_method_defined? "method2", true    #=> true
  #     C.private_method_defined? "method2", false   #=> false
  #     C.method_defined? "method2"                  #=> false
  #
  def private_method_defined?: (interned name, ?boolish inherit) -> bool

  # <!--
  #   rdoc-file=vm_method.c
  #   - protected                                -> nil
  #   - protected(method_name)                   -> method_name
  #   - protected(method_name, method_name, ...) -> array
  #   - protected(array)                         -> array
  # -->
  # With no arguments, sets the default visibility for subsequently defined
  # methods to protected. With arguments, sets the named methods to have protected
  # visibility. String arguments are converted to symbols. An Array of Symbols
  # and/or Strings is also accepted. If a single argument is passed, it is
  # returned. If no argument is passed, nil is returned. If multiple arguments are
  # passed, the arguments are returned as an array.
  #
  # If a method has protected visibility, it is callable only where `self` of the
  # context is the same as the method. (method definition or instance_eval). This
  # behavior is different from Java's protected method. Usually `private` should
  # be used.
  #
  # Note that a protected method is slow because it can't use inline cache.
  #
  # To show a private method on RDoc, use `:doc:` instead of this.
  #
  def protected: () -> nil
               | (Symbol method_name) -> Symbol
               | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
               | (string method_name) -> string
               | (interned, interned, *interned method_name) -> Array[interned]
               | (Array[interned]) -> Array[interned]

  # <!--
  #   rdoc-file=object.c
  #   - mod.protected_instance_methods(include_super=true)   -> array
  # -->
  # Returns a list of the protected instance methods defined in *mod*. If the
  # optional parameter is `false`, the methods of any ancestors are not included.
  #
  def protected_instance_methods: (?boolish include_super) -> ::Array[Symbol]

  # <!--
  #   rdoc-file=vm_method.c
  #   - mod.protected_method_defined?(symbol, inherit=true)   -> true or false
  #   - mod.protected_method_defined?(string, inherit=true)   -> true or false
  # -->
  # Returns `true` if the named protected method is defined *mod*.  If *inherit*
  # is set, the lookup will also search *mod*'s ancestors. String arguments are
  # converted to symbols.
  #
  #     module A
  #       def method1()  end
  #     end
  #     class B
  #       protected
  #       def method2()  end
  #     end
  #     class C < B
  #       include A
  #       def method3()  end
  #     end
  #
  #     A.method_defined? :method1                    #=> true
  #     C.protected_method_defined? "method1"         #=> false
  #     C.protected_method_defined? "method2"         #=> true
  #     C.protected_method_defined? "method2", true   #=> true
  #     C.protected_method_defined? "method2", false  #=> false
  #     C.method_defined? "method2"                   #=> true
  #
  def protected_method_defined?: (interned name, ?boolish inherit) -> bool

  # <!--
  #   rdoc-file=vm_method.c
  #   - public                                -> nil
  #   - public(method_name)                   -> method_name
  #   - public(method_name, method_name, ...) -> array
  #   - public(array)                         -> array
  # -->
  # With no arguments, sets the default visibility for subsequently defined
  # methods to public. With arguments, sets the named methods to have public
  # visibility. String arguments are converted to symbols. An Array of Symbols
  # and/or Strings is also accepted. If a single argument is passed, it is
  # returned. If no argument is passed, nil is returned. If multiple arguments are
  # passed, the arguments are returned as an array.
  #
  def public: () -> nil
            | (Symbol method_name) -> Symbol
            | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
            | (string method_name) -> string
            | (interned, interned, *interned method_name) -> Array[interned]
            | (Array[interned]) -> Array[interned]

  # <!--
  #   rdoc-file=vm_method.c
  #   - mod.public_class_method(symbol, ...)    -> mod
  #   - mod.public_class_method(string, ...)    -> mod
  #   - mod.public_class_method(array)          -> mod
  # -->
  # Makes a list of existing class methods public.
  #
  # String arguments are converted to symbols. An Array of Symbols and/or Strings
  # is also accepted.
  #
  def public_class_method: (*interned arg0) -> self
                         | (Array[interned] arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - mod.public_constant(symbol, ...)    => mod
  # -->
  # Makes a list of existing constants public.
  #
  def public_constant: (*interned arg0) -> self

  # <!--
  #   rdoc-file=proc.c
  #   - mod.public_instance_method(symbol)   -> unbound_method
  # -->
  # Similar to *instance_method*, searches public method only.
  #
  def public_instance_method: (interned arg0) -> UnboundMethod

  # <!--
  #   rdoc-file=object.c
  #   - mod.public_instance_methods(include_super=true)   -> array
  # -->
  # Returns a list of the public instance methods defined in *mod*. If the
  # optional parameter is `false`, the methods of any ancestors are not included.
  #
  def public_instance_methods: (?boolish include_super) -> ::Array[Symbol]

  # <!--
  #   rdoc-file=vm_method.c
  #   - mod.public_method_defined?(symbol, inherit=true)   -> true or false
  #   - mod.public_method_defined?(string, inherit=true)   -> true or false
  # -->
  # Returns `true` if the named public method is defined by *mod*.  If *inherit*
  # is set, the lookup will also search *mod*'s ancestors. String arguments are
  # converted to symbols.
  #
  #     module A
  #       def method1()  end
  #     end
  #     class B
  #       protected
  #       def method2()  end
  #     end
  #     class C < B
  #       include A
  #       def method3()  end
  #     end
  #
  #     A.method_defined? :method1                 #=> true
  #     C.public_method_defined? "method1"         #=> true
  #     C.public_method_defined? "method1", true   #=> true
  #     C.public_method_defined? "method1", false  #=> true
  #     C.public_method_defined? "method2"         #=> false
  #     C.method_defined? "method2"                #=> true
  #
  def public_method_defined?: (interned name, ?boolish inherit) -> bool

  # <!--
  #   rdoc-file=eval.c
  #   - refine(mod) { block }   -> module
  # -->
  # Refine *mod* in the receiver.
  #
  # Returns a module, where refined methods are defined.
  #
  def refine: (Module mod) { () [self: Refinement] -> void } -> Refinement

  # <!--
  #   rdoc-file=eval.c
  #   - refinements -> array
  # -->
  # Returns an array of `Refinement` defined within the receiver.
  #
  #     module A
  #       refine Integer do
  #       end
  #
  #       refine String do
  #       end
  #     end
  #
  #     p A.refinements
  #
  # *produces:*
  #
  #     [#<refinement:Integer@A>, #<refinement:String@A>]
  #
  def refinements: () -> Array[Refinement]

  # <!--
  #   rdoc-file=object.c
  #   - remove_class_variable(sym)    -> obj
  # -->
  # Removes the named class variable from the receiver, returning that variable's
  # value.
  #
  #     class Example
  #       @@var = 99
  #       puts remove_class_variable(:@@var)
  #       p(defined? @@var)
  #     end
  #
  # *produces:*
  #
  #     99
  #     nil
  #
  def remove_class_variable: (interned arg0) -> untyped

  # <!--
  #   rdoc-file=object.c
  #   - remove_const(sym)   -> obj
  # -->
  # Removes the definition of the given constant, returning that constant's
  # previous value.  If that constant referred to a module, this will not change
  # that module's name and can lead to confusion.
  #
  def remove_const: (interned arg0) -> untyped

  # <!--
  #   rdoc-file=vm_method.c
  #   - remove_method(symbol)   -> self
  #   - remove_method(string)   -> self
  # -->
  # Removes the method identified by *symbol* from the current class. For an
  # example, see Module#undef_method. String arguments are converted to symbols.
  #
  def remove_method: (*interned arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - mod.set_temporary_name(string) -> self
  #   - mod.set_temporary_name(nil) -> self
  # -->
  # Sets the temporary name of the module. This name is reflected in introspection
  # of the module and the values that are related to it, such as instances,
  # constants, and methods.
  #
  # The name should be `nil` or a non-empty string that is not a valid constant
  # path (to avoid confusing between permanent and temporary names).
  #
  # The method can be useful to distinguish dynamically generated classes and
  # modules without assigning them to constants.
  #
  # If the module is given a permanent name by assigning it to a constant, the
  # temporary name is discarded. A temporary name can't be assigned to modules
  # that have a permanent name.
  #
  # If the given name is `nil`, the module becomes anonymous again.
  #
  # Example:
  #
  #     m = Module.new # => #<Module:0x0000000102c68f38>
  #     m.name #=> nil
  #
  #     m.set_temporary_name("fake_name") # => fake_name
  #     m.name #=> "fake_name"
  #
  #     m.set_temporary_name(nil) # => #<Module:0x0000000102c68f38>
  #     m.name #=> nil
  #
  #     c = Class.new
  #     c.set_temporary_name("MyClass(with description)")
  #
  #     c.new # => #<MyClass(with description):0x0....>
  #
  #     c::M = m
  #     c::M.name #=> "MyClass(with description)::M"
  #
  #     # Assigning to a constant replaces the name with a permanent one
  #     C = c
  #
  #     C.name #=> "C"
  #     C::M.name #=> "C::M"
  #     c.new # => #<C:0x0....>
  #
  def set_temporary_name: (string?) -> self

  # <!--
  #   rdoc-file=object.c
  #   - mod.singleton_class?    -> true or false
  # -->
  # Returns `true` if *mod* is a singleton class or `false` if it is an ordinary
  # class or module.
  #
  #     class C
  #     end
  #     C.singleton_class?                  #=> false
  #     C.singleton_class.singleton_class?  #=> true
  #
  def singleton_class?: () -> bool

  # <!--
  #   rdoc-file=object.c
  #   - mod.to_s   -> string
  # -->
  # Returns a string representing this module or class. For basic classes and
  # modules, this is the name. For singletons, we show information on the thing
  # we're attached to as well.
  #
  def to_s: () -> String

  # <!--
  #   rdoc-file=vm_method.c
  #   - undef_method(symbol)    -> self
  #   - undef_method(string)    -> self
  # -->
  # Prevents the current class from responding to calls to the named method.
  # Contrast this with `remove_method`, which deletes the method from the
  # particular class; Ruby will still search superclasses and mixed-in modules for
  # a possible receiver. String arguments are converted to symbols.
  #
  #     class Parent
  #       def hello
  #         puts "In parent"
  #       end
  #     end
  #     class Child < Parent
  #       def hello
  #         puts "In child"
  #       end
  #     end
  #
  #     c = Child.new
  #     c.hello
  #
  #     class Child
  #       remove_method :hello  # remove from child, still in parent
  #     end
  #     c.hello
  #
  #     class Child
  #       undef_method :hello   # prevent any calls to 'hello'
  #     end
  #     c.hello
  #
  # *produces:*
  #
  #     In child
  #     In parent
  #     prog.rb:23: undefined method 'hello' for #<Child:0x401b3bb4> (NoMethodError)
  #
  def undef_method: (*interned arg0) -> self

  # <!--
  #   rdoc-file=object.c
  #   - mod.undefined_instance_methods   -> array
  # -->
  # Returns a list of the undefined instance methods defined in *mod*. The
  # undefined methods of any ancestors are not included.
  #
  def undefined_instance_methods: () -> Array[Symbol]

  # <!--
  #   rdoc-file=eval.c
  #   - using(module)    -> self
  # -->
  # Import class refinements from *module* into the current class or module
  # definition.
  #
  def using: (Module arg0) -> self

  # <!-- rdoc-file=object.c -->
  # Returns a string representing this module or class. For basic classes and
  # modules, this is the name. For singletons, we show information on the thing
  # we're attached to as well.
  #
  def inspect: () -> String

  # <!--
  #   rdoc-file=object.c
  #   - attr(name, ...) -> array
  #   - attr(name, true) -> array
  #   - attr(name, false) -> array
  # -->
  # The first form is equivalent to #attr_reader. The second form is equivalent to
  # `attr_accessor(name)` but deprecated. The last form is equivalent to
  # `attr_reader(name)` but deprecated. Returns an array of defined method names
  # as symbols.
  #
  def attr: (*interned arg0) -> Array[Symbol]

  # A previous incarnation of `interned` for backward-compatibility (see #1499)
  %a{steep:deprecated}
  type id = interned
end
