steep 0.13.0 → 0.16.2

data/vendor/ruby-signature/stdlib/builtin/string_io.rbs

@@ -1,13 +0,0 @@
-class StringIO
-  def initialize: (?String, ?String) -> untyped
-  def puts: (*untyped) -> void
-  def readline: () -> String
-              | (String) -> String
-  def write: (String) -> void
-  def flush: () -> void
-  def string: -> String
-  def close_read: -> nil
-  def closed_read?: -> bool
-  def close_write: -> nil
-  def closed_write?: -> bool
-end

data/vendor/ruby-signature/stdlib/builtin/struct.rbs

@@ -1,40 +0,0 @@
-# A [Struct](Struct) is a convenient way to bundle a
-# number of attributes together, using accessor methods, without having to
-# write an explicit class.
-# 
-# The [Struct](Struct) class generates new subclasses
-# that hold a set of members and their values. For each member a reader
-# and writer method is created similar to
-# [Module\#attr\_accessor](https://ruby-doc.org/core-2.6.3/Module.html#method-i-attr_accessor)
-# .
-# 
-# ```ruby
-# Customer = Struct.new(:name, :address) do
-#   def greeting
-#     "Hello #{name}!"
-#   end
-# end
-# 
-# dave = Customer.new("Dave", "123 Main")
-# dave.name     #=> "Dave"
-# dave.greeting #=> "Hello Dave!"
-# ```
-# 
-# See [::new](Struct#method-c-new) for further
-# examples of creating struct subclasses and instances.
-# 
-# In the method descriptions that follow, a "member" parameter refers to a
-# struct member which is either a quoted string ( `"name"` ) or a
-# [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html) ( `:name` ).
-class Struct[Elem] < Object
-  include Enumerable[Elem, Struct[Elem]]
-
-  def initialize: (Symbol | String arg0, *Symbol | String arg1, ?keyword_init: bool keyword_init) -> void
-
-  def each: () { (Elem arg0) -> untyped } -> untyped
-          | () -> self
-
-  def self.members: () -> ::Array[Symbol]
-
-  def new: (*untyped args) -> Struct[untyped]
-end

data/vendor/ruby-signature/stdlib/builtin/symbol.rbs

@@ -1,230 +0,0 @@
-# Symbol objects represent names inside the Ruby interpreter. They are generated
-# using the `:name` and `:"string"` literals syntax, and by the various `to_sym`
-# methods. The same Symbol object will be created for a given name or string for
-# the duration of a program's execution, regardless of the context or meaning of
-# that name. Thus if `Fred` is a constant in one context, a method in another,
-# and a class in a third, the Symbol `:Fred` will be the same object in all
-# three contexts.
-#
-#     module One
-#       class Fred
-#       end
-#       $f1 = :Fred
-#     end
-#     module Two
-#       Fred = 1
-#       $f2 = :Fred
-#     end
-#     def Fred()
-#     end
-#     $f3 = :Fred
-#     $f1.object_id   #=> 2514190
-#     $f2.object_id   #=> 2514190
-#     $f3.object_id   #=> 2514190
-#
-class Symbol
-  include Comparable
-
-  # Returns an array of all the symbols currently in Ruby's symbol table.
-  #
-  #     Symbol.all_symbols.size    #=> 903
-  #     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
-  #                                     :chown, :EOFError, :$;, :String,
-  #                                     :LOCK_SH, :"setuid?", :$<,
-  #                                     :default_proc, :compact, :extend,
-  #                                     :Tms, :getwd, :$=, :ThreadGroup,
-  #                                     :wait2, :$>]
-  #
-  def self.all_symbols: () -> ::Array[Symbol]
-
-  public
-
-  # Compares `symbol` with `other_symbol` after calling #to_s on each of the
-  # symbols. Returns -1, 0, +1, or `nil` depending on whether `symbol` is less
-  # than, equal to, or greater than `other_symbol`.
-  #
-  # `nil` is returned if the two values are incomparable.
-  #
-  # See String#<=> for more information.
-  #
-  def <=>: (Symbol other) -> Integer
-         | (untyped other) -> Integer?
-
-  # Equality---If *sym* and *obj* are exactly the same symbol, returns `true`.
-  #
-  def ==: (untyped obj) -> bool
-
-  # Equality---If *sym* and *obj* are exactly the same symbol, returns `true`.
-  #
-  def ===: (untyped obj) -> bool
-
-  # Returns `sym.to_s =~ obj`.
-  #
-  def =~: (untyped obj) -> Integer?
-
-  # Returns `sym.to_s[]`.
-  #
-  def []: (Integer index) -> String?
-        | (Integer start, Integer length) -> String?
-        | (Range[Integer?] range) -> String?
-        | (Regexp regexp) -> String?
-        | (Regexp regexp, Integer | String capture) -> String?
-        | (String match_str) -> String?
-
-  # Same as `sym.to_s.capitalize.intern`.
-  #
-  def capitalize: () -> Symbol
-                | (:ascii | :lithuanian | :turkic) -> Symbol
-                | (:lithuanian, :turkic) -> Symbol
-                | (:turkic, :lithuanian) -> Symbol
-
-  # Case-insensitive version of Symbol#<=>. Currently, case-insensitivity only
-  # works on characters A-Z/a-z, not all of Unicode. This is different from
-  # Symbol#casecmp?.
-  #
-  #     :aBcDeF.casecmp(:abcde)     #=> 1
-  #     :aBcDeF.casecmp(:abcdef)    #=> 0
-  #     :aBcDeF.casecmp(:abcdefg)   #=> -1
-  #     :abcdef.casecmp(:ABCDEF)    #=> 0
-  #
-  # `nil` is returned if the two symbols have incompatible encodings, or if
-  # `other_symbol` is not a symbol.
-  #
-  #     :foo.casecmp(2)   #=> nil
-  #     "\u{e4 f6 fc}".encode("ISO-8859-1").to_sym.casecmp(:"\u{c4 d6 dc}")   #=> nil
-  #
-  def casecmp: (Symbol other) -> Integer?
-             | (untyped other) -> Integer?
-
-  # Returns `true` if `sym` and `other_symbol` are equal after Unicode case
-  # folding, `false` if they are not equal.
-  #
-  #     :aBcDeF.casecmp?(:abcde)     #=> false
-  #     :aBcDeF.casecmp?(:abcdef)    #=> true
-  #     :aBcDeF.casecmp?(:abcdefg)   #=> false
-  #     :abcdef.casecmp?(:ABCDEF)    #=> true
-  #     :"\u{e4 f6 fc}".casecmp?(:"\u{c4 d6 dc}")   #=> true
-  #
-  # `nil` is returned if the two symbols have incompatible encodings, or if
-  # `other_symbol` is not a symbol.
-  #
-  #     :foo.casecmp?(2)   #=> nil
-  #     "\u{e4 f6 fc}".encode("ISO-8859-1").to_sym.casecmp?(:"\u{c4 d6 dc}")   #=> nil
-  #
-  def casecmp?: (Symbol other) -> bool
-              | (untyped other) -> bool
-
-  # Same as `sym.to_s.downcase.intern`.
-  #
-  def downcase: () -> Symbol
-              | (:ascii | :fold | :lithuanian | :turkic) -> Symbol
-              | (:lithuanian, :turkic) -> Symbol
-              | (:turkic, :lithuanian) -> Symbol
-
-  # Returns whether *sym* is :"" or not.
-  #
-  def empty?: () -> bool
-
-  # Returns the Encoding object that represents the encoding of *sym*.
-  #
-  def encoding: () -> Encoding
-
-  # Returns true if `sym` ends with one of the `suffixes` given.
-  #
-  #     :hello.end_with?("ello")               #=> true
-  #
-  #     # returns true if one of the +suffixes+ matches.
-  #     :hello.end_with?("heaven", "ello")     #=> true
-  #     :hello.end_with?("heaven", "paradise") #=> false
-  #
-  def end_with?: (String str, *String str) -> bool
-
-  # Returns the name or string corresponding to *sym*.
-  #
-  #     :fred.id2name   #=> "fred"
-  #     :ginger.to_s    #=> "ginger"
-  #
-  def id2name: () -> String
-
-  # Returns the representation of *sym* as a symbol literal.
-  #
-  #     :fred.inspect   #=> ":fred"
-  #
-  def inspect: () -> String
-
-  # In general, `to_sym` returns the Symbol corresponding to an object. As *sym*
-  # is already a symbol, `self` is returned in this case.
-  #
-  def intern: () -> self
-
-  # Same as `sym.to_s.length`.
-  #
-  def length: () -> Integer
-
-  # Returns `sym.to_s.match`.
-  #
-  def match: (Regexp | String pattern, ?Integer pos) ?{ (MatchData) -> void } -> MatchData?
-
-  # Returns `sym.to_s.match?`.
-  #
-  def match?: (Regexp | String pattern, ?Integer pos) -> bool
-
-  # Same as `sym.to_s.succ.intern`.
-  #
-  def next: () -> Symbol
-
-  # Same as `sym.to_s.length`.
-  #
-  alias size length
-
-  # Returns `sym.to_s[]`.
-  #
-  alias slice `[]`
-
-  # Returns true if `sym` starts with one of the `prefixes` given. Each of the
-  # `prefixes` should be a String or a Regexp.
-  #
-  #     :hello.start_with?("hell")               #=> true
-  #     :hello.start_with?(/H/i)                 #=> true
-  #
-  #     # returns true if one of the prefixes matches.
-  #     :hello.start_with?("heaven", "hell")     #=> true
-  #     :hello.start_with?("heaven", "paradise") #=> false
-  def start_with?: (String str, *String str) -> bool
-
-  # Same as `sym.to_s.succ.intern`.
-  #
-  alias succ next
-
-  # Same as `sym.to_s.swapcase.intern`.
-  #
-  def swapcase: () -> Symbol
-              | (:ascii | :lithuanian | :turkic) -> Symbol
-              | (:lithuanian, :turkic) -> Symbol
-              | (:turkic, :lithuanian) -> Symbol
-
-  # Returns a *Proc* object which responds to the given method by *sym*.
-  #
-  #     (1..3).collect(&:to_s)  #=> ["1", "2", "3"]
-  #
-  def to_proc: () -> Proc
-
-  # Returns the name or string corresponding to *sym*.
-  #
-  #     :fred.id2name   #=> "fred"
-  #     :ginger.to_s    #=> "ginger"
-  #
-  alias to_s id2name
-
-  # In general, `to_sym` returns the Symbol corresponding to an object. As *sym*
-  # is already a symbol, `self` is returned in this case.
-  #
-  alias to_sym intern
-
-  # Same as `sym.to_s.upcase.intern`.
-  #
-  def upcase: () -> Symbol
-            | (:ascii | :lithuanian | :turkic) -> Symbol
-            | (:lithuanian, :turkic) -> Symbol
-            | (:turkic, :lithuanian) -> Symbol
-end

data/vendor/ruby-signature/stdlib/builtin/thread.rbs

@@ -1,1112 +0,0 @@
-# Threads are the Ruby implementation for a concurrent programming model.
-# 
-# Programs that require multiple threads of execution are a perfect
-# candidate for Ruby's [Thread](Thread) class.
-# 
-# For example, we can create a new thread separate from the main thread's
-# execution using [::new](Thread#method-c-new).
-# 
-# ```ruby
-# thr = Thread.new { puts "Whats the big deal" }
-# ```
-# 
-# Then we are able to pause the execution of the main thread and allow our
-# new thread to finish, using
-# [join](Thread#method-i-join):
-# 
-# ```ruby
-# thr.join #=> "Whats the big deal"
-# ```
-# 
-# If we don't call `thr.join` before the main thread terminates, then all
-# other threads including `thr` will be killed.
-# 
-# Alternatively, you can use an array for handling multiple threads at
-# once, like in the following example:
-# 
-# ```ruby
-# threads = []
-# threads << Thread.new { puts "Whats the big deal" }
-# threads << Thread.new { 3.times { puts "Threads are fun!" } }
-# ```
-# 
-# After creating a few threads we wait for them all to finish
-# consecutively.
-# 
-# ```ruby
-# threads.each { |thr| thr.join }
-# ```
-# 
-# 
-# In order to create new threads, Ruby provides
-# [::new](Thread#method-c-new),
-# [::start](Thread#method-c-start), and
-# [::fork](Thread#method-c-fork). A block must be
-# provided with each of these methods, otherwise a
-# [ThreadError](https://ruby-doc.org/core-2.6.3/ThreadError.html) will be
-# raised.
-# 
-# When subclassing the [Thread](Thread) class, the
-# `initialize` method of your subclass will be ignored by
-# [::start](Thread#method-c-start) and
-# [::fork](Thread#method-c-fork). Otherwise, be sure
-# to call super in your `initialize` method.
-# 
-# 
-# For terminating threads, Ruby provides a variety of ways to do this.
-# 
-# The class method [::kill](Thread#method-c-kill), is
-# meant to exit a given thread:
-# 
-#     thr = Thread.new { ... }
-#     Thread.kill(thr) # sends exit() to thr
-# 
-# Alternatively, you can use the instance method
-# [exit](Thread#method-i-exit), or any of its aliases
-# [kill](Thread#method-i-kill) or
-# [terminate](Thread#method-i-terminate).
-# 
-# ```ruby
-# thr.exit
-# ```
-# 
-# 
-# Ruby provides a few instance methods for querying the state of a given
-# thread. To get a string with the current thread's state use
-# [status](Thread#method-i-status)
-# 
-# ```ruby
-# thr = Thread.new { sleep }
-# thr.status # => "sleep"
-# thr.exit
-# thr.status # => false
-# ```
-# 
-# You can also use [alive?](Thread#method-i-alive-3F)
-# to tell if the thread is running or sleeping, and
-# [stop?](Thread#method-i-stop-3F) if the thread is
-# dead or sleeping.
-# 
-# 
-# Since threads are created with blocks, the same rules apply to other
-# Ruby blocks for variable scope. Any local variables created within this
-# block are accessible to only this thread.
-# 
-# 
-# Each fiber has its own bucket for
-# [\#\[\]](Thread#method-i-5B-5D) storage. When you
-# set a new fiber-local it is only accessible within this
-# [Fiber](https://ruby-doc.org/core-2.6.3/Fiber.html). To illustrate:
-# 
-# ```ruby
-# Thread.new {
-#   Thread.current[:foo] = "bar"
-#   Fiber.new {
-#     p Thread.current[:foo] # => nil
-#   }.resume
-# }.join
-# ```
-# 
-# This example uses [\[\]](Thread#method-i-5B-5D) for
-# getting and [\[\]=](Thread#method-i-5B-5D-3D) for
-# setting fiber-locals, you can also use
-# [keys](Thread#method-i-keys) to list the
-# fiber-locals for a given thread and
-# [key?](Thread#method-i-key-3F) to check if a
-# fiber-local exists.
-# 
-# When it comes to thread-locals, they are accessible within the entire
-# scope of the thread. Given the following example:
-# 
-# ```ruby
-# Thread.new{
-#   Thread.current.thread_variable_set(:foo, 1)
-#   p Thread.current.thread_variable_get(:foo) # => 1
-#   Fiber.new{
-#     Thread.current.thread_variable_set(:foo, 2)
-#     p Thread.current.thread_variable_get(:foo) # => 2
-#   }.resume
-#   p Thread.current.thread_variable_get(:foo)   # => 2
-# }.join
-# ```
-# 
-# You can see that the thread-local `:foo` carried over into the fiber and
-# was changed to `2` by the end of the thread.
-# 
-# This example makes use of
-# [thread\_variable\_set](Thread#method-i-thread_variable_set)
-# to create new thread-locals, and
-# [thread\_variable\_get](Thread#method-i-thread_variable_get)
-# to reference them.
-# 
-# There is also
-# [thread\_variables](Thread#method-i-thread_variables)
-# to list all thread-locals, and
-# [thread\_variable?](Thread#method-i-thread_variable-3F)
-# to check if a given thread-local exists.
-# 
-# 
-# Any thread can raise an exception using the
-# [raise](Thread#method-i-raise) instance method,
-# which operates similarly to
-# [Kernel\#raise](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-raise)
-# .
-# 
-# However, it's important to note that an exception that occurs in any
-# thread except the main thread depends on
-# [abort\_on\_exception](Thread#method-i-abort_on_exception)
-# . This option is `false` by default, meaning that any unhandled
-# exception will cause the thread to terminate silently when waited on by
-# either [join](Thread#method-i-join) or
-# [value](Thread#method-i-value). You can change this
-# default by either
-# [abort\_on\_exception=](Thread#method-i-abort_on_exception-3D)
-# `true` or setting $DEBUG to `true` .
-# 
-# With the addition of the class method
-# [::handle\_interrupt](Thread#method-c-handle_interrupt)
-# , you can now handle exceptions asynchronously with threads.
-# 
-# 
-# Ruby provides a few ways to support scheduling threads in your program.
-# 
-# The first way is by using the class method
-# [::stop](Thread#method-c-stop), to put the current
-# running thread to sleep and schedule the execution of another thread.
-# 
-# Once a thread is asleep, you can use the instance method
-# [wakeup](Thread#method-i-wakeup) to mark your thread
-# as eligible for scheduling.
-# 
-# You can also try [::pass](Thread#method-c-pass),
-# which attempts to pass execution to another thread but is dependent on
-# the OS whether a running thread will switch or not. The same goes for
-# [priority](Thread#method-i-priority), which lets
-# you hint to the thread scheduler which threads you want to take
-# precedence when passing execution. This method is also dependent on the
-# OS and may be ignored on some platforms.
-class Thread < Object
-  def self.current: () -> Thread
-
-  # Returns the main thread.
-  def self.main: () -> Thread
-
-  def []: (String | Symbol key) -> untyped
-
-  # Attribute Assignment—Sets or creates the value of a fiber-local
-  # variable, using either a symbol or a string.
-  # 
-  # See also [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D).
-  # 
-  # For thread-local variables, please see
-  # [thread\_variable\_set](Thread.downloaded.ruby_doc#method-i-thread_variable_set)
-  # and
-  # [thread\_variable\_get](Thread.downloaded.ruby_doc#method-i-thread_variable_get)
-  # .
-  def []=: (String | Symbol key, untyped value) -> untyped
-
-  def alive?: () -> bool
-
-  # Terminates `thr` and schedules another thread to be run.
-  # 
-  # If this thread is already marked to be killed,
-  # [exit](Thread.downloaded.ruby_doc#method-i-exit) returns the
-  # [Thread](Thread.downloaded.ruby_doc).
-  # 
-  # If this is the main thread, or the last thread, exits the process.
-  def kill: () -> Thread?
-
-  # Returns the status of the thread-local “abort on exception” condition
-  # for this `thr` .
-  # 
-  # The default is `false` .
-  # 
-  # See also
-  # [abort\_on\_exception=](Thread.downloaded.ruby_doc#method-i-abort_on_exception-3D)
-  # .
-  # 
-  # There is also a class level method to set this for all threads, see
-  # [::abort\_on\_exception](Thread.downloaded.ruby_doc#method-c-abort_on_exception)
-  # .
-  def abort_on_exception: () -> bool
-
-  # When set to `true`, if this `thr` is aborted by an exception, the
-  # raised exception will be re-raised in the main thread.
-  # 
-  # See also
-  # [abort\_on\_exception](Thread.downloaded.ruby_doc#method-i-abort_on_exception)
-  # .
-  # 
-  # There is also a class level method to set this for all threads, see
-  # [::abort\_on\_exception=](Thread.downloaded.ruby_doc#method-c-abort_on_exception-3D)
-  # .
-  def abort_on_exception=: (bool abort_on_exception) -> untyped
-
-  # Adds *proc* as a handler for tracing.
-  # 
-  # See
-  # [\#set\_trace\_func](Thread.downloaded.ruby_doc#method-i-set_trace_func)
-  # and
-  # [Kernel\#set\_trace\_func](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-set_trace_func)
-  # .
-  def add_trace_func: (untyped proc) -> untyped
-
-  # Returns the current backtrace of the target thread.
-  def backtrace: (*untyped args) -> ::Array[untyped]
-
-  # Returns the execution stack for the target thread—an array containing
-  # backtrace location objects.
-  # 
-  # See
-  # [Thread::Backtrace::Location](https://ruby-doc.org/core-2.6.3/Thread/Backtrace/Location.html)
-  # for more information.
-  # 
-  # This method behaves similarly to
-  # [Kernel\#caller\_locations](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-caller_locations)
-  # except it applies to a specific thread.
-  def backtrace_locations: (*untyped args) -> ::Array[untyped]?
-
-  # Terminates `thr` and schedules another thread to be run.
-  # 
-  # If this thread is already marked to be killed,
-  # [exit](Thread.downloaded.ruby_doc#method-i-exit) returns the
-  # [Thread](Thread.downloaded.ruby_doc).
-  # 
-  # If this is the main thread, or the last thread, exits the process.
-  def exit: () -> Thread?
-
-  # Returns a fiber-local 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. See [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D)
-  # and
-  # [Hash\#fetch](https://ruby-doc.org/core-2.6.3/Hash.html#method-i-fetch)
-  # .
-  def fetch: (*untyped sym) -> untyped
-
-  def group: () -> ThreadGroup?
-
-  def initialize: (*untyped args) -> Thread
-
-  # The calling thread will suspend execution and run this `thr` .
-  # 
-  # Does not return until `thr` exits or until the given `limit` seconds
-  # have passed.
-  # 
-  # If the time limit expires, `nil` will be returned, otherwise `thr` is
-  # returned.
-  # 
-  # Any threads not joined will be killed when the main program exits.
-  # 
-  # If `thr` had previously raised an exception and the
-  # [::abort\_on\_exception](Thread.downloaded.ruby_doc#method-c-abort_on_exception)
-  # or $DEBUG flags are not set, (so the exception has not yet been
-  # processed), it will be processed at this time.
-  # 
-  # ```ruby
-  # a = Thread.new { print "a"; sleep(10); print "b"; print "c" }
-  # x = Thread.new { print "x"; Thread.pass; print "y"; print "z" }
-  # x.join # Let thread x finish, thread a will be killed on exit.
-  # #=> "axyz"
-  # ```
-  # 
-  # The following example illustrates the `limit` parameter.
-  # 
-  # ```ruby
-  # y = Thread.new { 4.times { sleep 0.1; puts 'tick... ' }}
-  # puts "Waiting" until y.join(0.15)
-  # ```
-  # 
-  # This will produce:
-  # 
-  #     tick...
-  #     Waiting
-  #     tick...
-  #     Waiting
-  #     tick...
-  #     tick...
-  def join: (*untyped limit) -> Thread
-
-  # Returns `true` if the given string (or symbol) exists as a fiber-local
-  # variable.
-  # 
-  # ```ruby
-  # me = Thread.current
-  # me[:oliver] = "a"
-  # me.key?(:oliver)    #=> true
-  # me.key?(:stanley)   #=> false
-  # ```
-  def key?: (Symbol sym) -> bool
-
-  def keys: () -> ::Array[Symbol]
-
-  # show the name of the thread.
-  def name: () -> String
-
-  # set given name to the ruby thread. On some platform, it may set the name
-  # to pthread and/or kernel.
-  def name=: (untyped name) -> untyped
-
-  # Returns whether or not the asynchronous queue is empty for the target
-  # thread.
-  # 
-  # If `error` is given, then check only for `error` type deferred events.
-  # 
-  # See
-  # [::pending\_interrupt?](Thread.downloaded.ruby_doc#method-c-pending_interrupt-3F)
-  # for more information.
-  def pending_interrupt?: (*untyped args) -> bool
-
-  # Returns the priority of *thr* . Default is inherited from the current
-  # thread which creating the new thread, or zero for the initial main
-  # thread; higher-priority thread will run more frequently than
-  # lower-priority threads (but lower-priority threads can also run).
-  # 
-  # This is just hint for Ruby thread scheduler. It may be ignored on some
-  # platform.
-  # 
-  # ```ruby
-  # Thread.current.priority   #=> 0
-  # ```
-  def priority: () -> Integer
-
-  # Sets the priority of *thr* to *integer* . Higher-priority threads will
-  # run more frequently than lower-priority threads (but lower-priority
-  # threads can also run).
-  # 
-  # This is just hint for Ruby thread scheduler. It may be ignored on some
-  # platform.
-  # 
-  # ```ruby
-  # count1 = count2 = 0
-  # a = Thread.new do
-  #       loop { count1 += 1 }
-  #     end
-  # a.priority = -1
-  # 
-  # b = Thread.new do
-  #       loop { count2 += 1 }
-  #     end
-  # b.priority = -2
-  # sleep 1   #=> 1
-  # count1    #=> 622504
-  # count2    #=> 5832
-  # ```
-  def priority=: (Integer priority) -> untyped
-
-  # Returns the status of the thread-local “report on exception” condition
-  # for this `thr` .
-  # 
-  # The default value when creating a [Thread](Thread.downloaded.ruby_doc)
-  # is the value of the global flag
-  # [::report\_on\_exception](Thread.downloaded.ruby_doc#method-c-report_on_exception)
-  # .
-  # 
-  # See also
-  # [report\_on\_exception=](Thread.downloaded.ruby_doc#method-i-report_on_exception-3D)
-  # .
-  # 
-  # There is also a class level method to set this for all new threads, see
-  # [::report\_on\_exception=](Thread.downloaded.ruby_doc#method-c-report_on_exception-3D)
-  # .
-  def report_on_exception: () -> bool
-
-  # When set to `true`, a message is printed on $stderr if an exception
-  # kills this `thr` . See
-  # [::report\_on\_exception](Thread.downloaded.ruby_doc#method-c-report_on_exception)
-  # for details.
-  # 
-  # See also
-  # [report\_on\_exception](Thread.downloaded.ruby_doc#method-i-report_on_exception)
-  # .
-  # 
-  # There is also a class level method to set this for all new threads, see
-  # [::report\_on\_exception=](Thread.downloaded.ruby_doc#method-c-report_on_exception-3D)
-  # .
-  def report_on_exception=: (bool report_on_exception) -> untyped
-
-  # Wakes up `thr`, making it eligible for scheduling.
-  # 
-  # ```ruby
-  # a = Thread.new { puts "a"; Thread.stop; puts "c" }
-  # sleep 0.1 while a.status!='sleep'
-  # puts "Got here"
-  # a.run
-  # a.join
-  # ```
-  # 
-  # This will produce:
-  # 
-  # ```ruby
-  # a
-  # Got here
-  # c
-  # ```
-  # 
-  # See also the instance method
-  # [wakeup](Thread.downloaded.ruby_doc#method-i-wakeup).
-  def run: () -> Thread
-
-  # Returns the safe level.
-  # 
-  # This method is obsolete because $SAFE is a process global state. Simply
-  # check $SAFE.
-  def safe_level: () -> Integer
-
-  def status: () -> (String | bool)?
-
-  # Returns `true` if `thr` is dead or sleeping.
-  # 
-  # ```ruby
-  # a = Thread.new { Thread.stop }
-  # b = Thread.current
-  # a.stop?   #=> true
-  # b.stop?   #=> false
-  # ```
-  # 
-  # See also [alive?](Thread.downloaded.ruby_doc#method-i-alive-3F) and
-  # [status](Thread.downloaded.ruby_doc#method-i-status).
-  def `stop?`: () -> bool
-
-  # Terminates `thr` and schedules another thread to be run.
-  # 
-  # If this thread is already marked to be killed,
-  # [exit](Thread.downloaded.ruby_doc#method-i-exit) returns the
-  # [Thread](Thread.downloaded.ruby_doc).
-  # 
-  # If this is the main thread, or the last thread, exits the process.
-  def terminate: () -> Thread?
-
-  # Returns `true` if the given string (or symbol) exists as a thread-local
-  # variable.
-  # 
-  # ```ruby
-  # me = Thread.current
-  # me.thread_variable_set(:oliver, "a")
-  # me.thread_variable?(:oliver)    #=> true
-  # me.thread_variable?(:stanley)   #=> false
-  # ```
-  # 
-  # Note that these are not fiber local variables. Please see
-  # [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D) and
-  # [\#thread\_variable\_get](Thread.downloaded.ruby_doc#method-i-thread_variable_get)
-  # for more details.
-  def thread_variable?: (String | Symbol key) -> bool
-
-  # Returns the value of a thread local variable that has been set. Note
-  # that these are different than fiber local values. For fiber local
-  # values, please see [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D)
-  # and [\#\[\]=](Thread.downloaded.ruby_doc#method-i-5B-5D-3D).
-  # 
-  # [Thread](Thread.downloaded.ruby_doc) local values are carried along with
-  # threads, and do not respect fibers. For example:
-  # 
-  # ```ruby
-  # Thread.new {
-  #   Thread.current.thread_variable_set("foo", "bar") # set a thread local
-  #   Thread.current["foo"] = "bar"                    # set a fiber local
-  # 
-  #   Fiber.new {
-  #     Fiber.yield [
-  #       Thread.current.thread_variable_get("foo"), # get the thread local
-  #       Thread.current["foo"],                     # get the fiber local
-  #     ]
-  #   }.resume
-  # }.join.value # => ['bar', nil]
-  # ```
-  # 
-  # The value “bar” is returned for the thread local, where nil is returned
-  # for the fiber local. The fiber is executed in the same thread, so the
-  # thread local values are available.
-  def thread_variable_get: (untyped key) -> untyped
-
-  # Sets a thread local with `key` to `value` . Note that these are local to
-  # threads, and not to fibers. Please see
-  # [\#thread\_variable\_get](Thread.downloaded.ruby_doc#method-i-thread_variable_get)
-  # and [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D) for more
-  # information.
-  def thread_variable_set: (untyped key, untyped value) -> untyped
-
-  def thread_variables: () -> ::Array[Symbol]
-
-  # Waits for `thr` to complete, using
-  # [join](Thread.downloaded.ruby_doc#method-i-join), and returns its value
-  # or raises the exception which terminated the thread.
-  # 
-  # ```ruby
-  # a = Thread.new { 2 + 2 }
-  # a.value   #=> 4
-  # 
-  # b = Thread.new { raise 'something went wrong' }
-  # b.value   #=> RuntimeError: something went wrong
-  # ```
-  def value: () -> Object
-
-  # Marks a given thread as eligible for scheduling, however it may still
-  # remain blocked on I/O.
-  # 
-  # **Note:** This does not invoke the scheduler, see
-  # [run](Thread.downloaded.ruby_doc#method-i-run) for more information.
-  # 
-  # ```ruby
-  # c = Thread.new { Thread.stop; puts "hey!" }
-  # sleep 0.1 while c.status!='sleep'
-  # c.wakeup
-  # c.join
-  # #=> "hey!"
-  # ```
-  def wakeup: () -> Thread
-
-  # Returns the status of the global “abort on exception” condition.
-  # 
-  # The default is `false` .
-  # 
-  # When set to `true`, if any thread is aborted by an exception, the
-  # raised exception will be re-raised in the main thread.
-  # 
-  # Can also be specified by the global $DEBUG flag or command line option
-  # `-d` .
-  # 
-  # See also
-  # [::abort\_on\_exception=](Thread.downloaded.ruby_doc#method-c-abort_on_exception-3D)
-  # .
-  # 
-  # There is also an instance level method to set this for a specific
-  # thread, see
-  # [abort\_on\_exception](Thread.downloaded.ruby_doc#method-i-abort_on_exception)
-  # .
-  def self.abort_on_exception: () -> untyped
-
-  # When set to `true`, if any thread is aborted by an exception, the
-  # raised exception will be re-raised in the main thread. Returns the new
-  # state.
-  # 
-  # ```ruby
-  # Thread.abort_on_exception = true
-  # t1 = Thread.new do
-  #   puts  "In new thread"
-  #   raise "Exception from thread"
-  # end
-  # sleep(1)
-  # puts "not reached"
-  # ```
-  # 
-  # This will produce:
-  # 
-  #     In new thread
-  #     prog.rb:4: Exception from thread (RuntimeError)
-  #      from prog.rb:2:in `initialize'
-  #      from prog.rb:2:in `new'
-  #      from prog.rb:2
-  # 
-  # See also
-  # [::abort\_on\_exception](Thread.downloaded.ruby_doc#method-c-abort_on_exception)
-  # .
-  # 
-  # There is also an instance level method to set this for a specific
-  # thread, see
-  # [abort\_on\_exception=](Thread.downloaded.ruby_doc#method-i-abort_on_exception-3D)
-  # .
-  def self.abort_on_exception=: (untyped abort_on_exception) -> untyped
-
-  # Wraps the block in a single, VM-global
-  # [Mutex\#synchronize](https://ruby-doc.org/core-2.6.3/Mutex.html#method-i-synchronize)
-  # , returning the value of the block. A thread executing inside the
-  # exclusive section will only block other threads which also use the
-  # [::exclusive](Thread.downloaded.ruby_doc#method-c-exclusive) mechanism.
-  def self.exclusive: () { () -> untyped } -> untyped
-
-  # Terminates the currently running thread and schedules another thread to
-  # be run.
-  # 
-  # If this thread is already marked to be killed,
-  # [::exit](Thread.downloaded.ruby_doc#method-c-exit) returns the
-  # [Thread](Thread.downloaded.ruby_doc).
-  # 
-  # If this is the main thread, or the last thread, exit the process.
-  def self.exit: () -> untyped
-
-  # Basically the same as [::new](Thread.downloaded.ruby_doc#method-c-new).
-  # However, if class [Thread](Thread.downloaded.ruby_doc) is subclassed,
-  # then calling `start` in that subclass will not invoke the subclass’s
-  # `initialize` method.
-  def self.fork: (*untyped args) -> untyped
-
-  # Changes asynchronous interrupt timing.
-  # 
-  # *interrupt* means asynchronous event and corresponding procedure by
-  # [\#raise](Thread.downloaded.ruby_doc#method-i-raise),
-  # [\#kill](Thread.downloaded.ruby_doc#method-i-kill), signal trap (not
-  # supported yet) and main thread termination (if main thread terminates,
-  # then all other thread will be killed).
-  # 
-  # The given `hash` has pairs like `ExceptionClass => :TimingSymbol` .
-  # Where the ExceptionClass is the interrupt handled by the given block.
-  # The TimingSymbol can be one of the following symbols:
-  # 
-  #   - `:immediate`
-  #     Invoke interrupts immediately.
-  # 
-  #   - `:on_blocking`
-  #     Invoke interrupts while *BlockingOperation* .
-  # 
-  #   - `:never`
-  #     Never invoke all interrupts.
-  # 
-  # *BlockingOperation* means that the operation will block the calling
-  # thread, such as read and write. On CRuby implementation,
-  # *BlockingOperation* is any operation executed without GVL.
-  # 
-  # Masked asynchronous interrupts are delayed until they are enabled. This
-  # method is similar to sigprocmask(3).
-  # 
-  # 
-  # Asynchronous interrupts are difficult to use.
-  # 
-  # If you need to communicate between threads, please consider to use
-  # another way such as [Queue](https://ruby-doc.org/core-2.6.3/Queue.html)
-  # .
-  # 
-  # Or use them with deep understanding about this method.
-  # 
-  # 
-  # In this example, we can guard from
-  # [\#raise](Thread.downloaded.ruby_doc#method-i-raise) exceptions.
-  # 
-  # Using the `:never` TimingSymbol the
-  # [RuntimeError](https://ruby-doc.org/core-2.6.3/RuntimeError.html)
-  # exception will always be ignored in the first block of the main thread.
-  # In the second
-  # [::handle\_interrupt](Thread.downloaded.ruby_doc#method-c-handle_interrupt)
-  # block we can purposefully handle
-  # [RuntimeError](https://ruby-doc.org/core-2.6.3/RuntimeError.html)
-  # exceptions.
-  # 
-  # ```ruby
-  # th = Thread.new do
-  #   Thread.handle_interrupt(RuntimeError => :never) {
-  #     begin
-  #       # You can write resource allocation code safely.
-  #       Thread.handle_interrupt(RuntimeError => :immediate) {
-  #         # ...
-  #       }
-  #     ensure
-  #       # You can write resource deallocation code safely.
-  #     end
-  #   }
-  # end
-  # Thread.pass
-  # # ...
-  # th.raise "stop"
-  # ```
-  # 
-  # While we are ignoring the
-  # [RuntimeError](https://ruby-doc.org/core-2.6.3/RuntimeError.html)
-  # exception, it’s safe to write our resource allocation code. Then, the
-  # ensure block is where we can safely deallocate your resources.
-  # 
-  # 
-  # In the next example, we will guard from the Timeout::Error exception.
-  # This will help prevent from leaking resources when Timeout::Error
-  # exceptions occur during normal ensure clause. For this example we use
-  # the help of the standard library Timeout, from lib/timeout.rb
-  # 
-  # ```ruby
-  # require 'timeout'
-  # Thread.handle_interrupt(Timeout::Error => :never) {
-  #   timeout(10){
-  #     # Timeout::Error doesn't occur here
-  #     Thread.handle_interrupt(Timeout::Error => :on_blocking) {
-  #       # possible to be killed by Timeout::Error
-  #       # while blocking operation
-  #     }
-  #     # Timeout::Error doesn't occur here
-  #   }
-  # }
-  # ```
-  # 
-  # In the first part of the `timeout` block, we can rely on Timeout::Error
-  # being ignored. Then in the `Timeout::Error => :on_blocking` block, any
-  # operation that will block the calling thread is susceptible to a
-  # Timeout::Error exception being raised.
-  # 
-  # 
-  # It’s possible to stack multiple levels of
-  # [::handle\_interrupt](Thread.downloaded.ruby_doc#method-c-handle_interrupt)
-  # blocks in order to control more than one ExceptionClass and TimingSymbol
-  # at a time.
-  # 
-  # ```ruby
-  # Thread.handle_interrupt(FooError => :never) {
-  #   Thread.handle_interrupt(BarError => :never) {
-  #      # FooError and BarError are prohibited.
-  #   }
-  # }
-  # ```
-  # 
-  # 
-  # All exceptions inherited from the ExceptionClass parameter will be
-  # considered.
-  # 
-  # ```ruby
-  # Thread.handle_interrupt(Exception => :never) {
-  #   # all exceptions inherited from Exception are prohibited.
-  # }
-  # ```
-  def self.handle_interrupt: (untyped hash) -> untyped
-
-  def self.kill: (Thread thread) -> untyped
-
-  def self.list: () -> untyped
-
-  # Give the thread scheduler a hint to pass execution to another thread. A
-  # running thread may or may not switch, it depends on OS and processor.
-  def self.pass: () -> untyped
-
-  # Returns whether or not the asynchronous queue is empty.
-  # 
-  # Since
-  # [::handle\_interrupt](Thread.downloaded.ruby_doc#method-c-handle_interrupt)
-  # can be used to defer asynchronous events, this method can be used to
-  # determine if there are any deferred events.
-  # 
-  # If you find this method returns true, then you may finish `:never`
-  # blocks.
-  # 
-  # For example, the following method processes deferred asynchronous events
-  # immediately.
-  # 
-  # ```ruby
-  # def Thread.kick_interrupt_immediately
-  #   Thread.handle_interrupt(Object => :immediate) {
-  #     Thread.pass
-  #   }
-  # end
-  # ```
-  # 
-  # If `error` is given, then check only for `error` type deferred events.
-  # 
-  # 
-  #     th = Thread.new{
-  #       Thread.handle_interrupt(RuntimeError => :on_blocking){
-  #         while true
-  #           ...
-  #           # reach safe point to invoke interrupt
-  #           if Thread.pending_interrupt?
-  #             Thread.handle_interrupt(Object => :immediate){}
-  #           end
-  #           ...
-  #         end
-  #       }
-  #     }
-  #     ...
-  #     th.raise # stop thread
-  # 
-  # This example can also be written as the following, which you should use
-  # to avoid asynchronous interrupts.
-  # 
-  #     flag = true
-  #     th = Thread.new{
-  #       Thread.handle_interrupt(RuntimeError => :on_blocking){
-  #         while true
-  #           ...
-  #           # reach safe point to invoke interrupt
-  #           break if flag == false
-  #           ...
-  #         end
-  #       }
-  #     }
-  #     ...
-  #     flag = false # stop thread
-  def self.pending_interrupt?: (*untyped args) -> bool
-
-  def self.report_on_exception: () -> untyped
-
-  def self.report_on_exception=: (untyped report_on_exception) -> untyped
-
-  # Basically the same as [::new](Thread.downloaded.ruby_doc#method-c-new).
-  # However, if class [Thread](Thread.downloaded.ruby_doc) is subclassed,
-  # then calling `start` in that subclass will not invoke the subclass’s
-  # `initialize` method.
-  def self.start: (*untyped args) -> untyped
-
-  # Stops execution of the current thread, putting it into a “sleep” state,
-  # and schedules execution of another thread.
-  # 
-  # ```ruby
-  # a = Thread.new { print "a"; Thread.stop; print "c" }
-  # sleep 0.1 while a.status!='sleep'
-  # print "b"
-  # a.run
-  # a.join
-  # #=> "abc"
-  # ```
-  def self.`stop`: () -> untyped
-end
-
-class Thread::Backtrace < Object
-end
-
-class Thread::Backtrace::Location
-  def absolute_path: () -> String?
-
-  def base_label: () -> String?
-
-  def label: () -> String?
-
-  def lineno: () -> Integer
-
-  def path: () -> String?
-end
-
-# [ConditionVariable](ConditionVariable) objects
-# augment class [Mutex](https://ruby-doc.org/core-2.6.3/Mutex.html).
-# Using condition variables, it is possible to suspend while in the middle
-# of a critical section until a resource becomes available.
-# 
-# Example:
-# 
-# ```ruby
-# mutex = Mutex.new
-# resource = ConditionVariable.new
-# 
-# a = Thread.new {
-#    mutex.synchronize {
-#      # Thread 'a' now needs the resource
-#      resource.wait(mutex)
-#      # 'a' can now have the resource
-#    }
-# }
-# 
-# b = Thread.new {
-#    mutex.synchronize {
-#      # Thread 'b' has finished using the resource
-#      resource.signal
-#    }
-# }
-# ```
-class Thread::ConditionVariable < Object
-  # Wakes up all threads waiting for this lock.
-  def broadcast: () -> untyped
-
-  def marshal_dump: () -> untyped
-
-  # Wakes up the first thread in line waiting for this lock.
-  def signal: () -> untyped
-
-  # Releases the lock held in `mutex` and waits; reacquires the lock on
-  # wakeup.
-  # 
-  # If `timeout` is given, this method returns after `timeout` seconds
-  # passed, even if no other thread doesn't signal.
-  def wait: (*untyped _) -> untyped
-end
-
-# [Mutex](Mutex) implements a simple semaphore that
-# can be used to coordinate access to shared data from multiple concurrent
-# threads.
-# 
-# Example:
-# 
-# ```ruby
-# semaphore = Mutex.new
-# 
-# a = Thread.new {
-#   semaphore.synchronize {
-#     # access shared resource
-#   }
-# }
-# 
-# b = Thread.new {
-#   semaphore.synchronize {
-#     # access shared resource
-#   }
-# }
-# ```
-class Thread::Mutex < Object
-  # Attempts to grab the lock and waits if it isn’t available. Raises
-  # `ThreadError` if `mutex` was locked by the current thread.
-  def lock: () -> untyped
-
-  # Returns `true` if this lock is currently held by some thread.
-  def locked?: () -> bool
-
-  # Returns `true` if this lock is currently held by current thread.
-  def owned?: () -> bool
-
-  # Obtains a lock, runs the block, and releases the lock when the block
-  # completes. See the example under `Mutex` .
-  def synchronize: () -> untyped
-
-  # Attempts to obtain the lock and returns immediately. Returns `true` if
-  # the lock was granted.
-  def try_lock: () -> bool
-
-  # Releases the lock. Raises `ThreadError` if `mutex` wasn’t locked by the
-  # current thread.
-  def unlock: () -> untyped
-end
-
-# The [Queue](Queue) class implements multi-producer,
-# multi-consumer queues. It is especially useful in threaded programming
-# when information must be exchanged safely between multiple threads. The
-# [Queue](Queue) class implements all the required
-# locking semantics.
-# 
-# The class implements FIFO type of queue. In a FIFO queue, the first
-# tasks added are the first retrieved.
-# 
-# Example:
-# 
-# ```ruby
-# queue = Queue.new
-# 
-# producer = Thread.new do
-#   5.times do |i|
-#      sleep rand(i) # simulate expense
-#      queue << i
-#      puts "#{i} produced"
-#   end
-# end
-# 
-# consumer = Thread.new do
-#   5.times do |i|
-#      value = queue.pop
-#      sleep rand(i/2) # simulate expense
-#      puts "consumed #{value}"
-#   end
-# end
-# 
-# consumer.join
-# ```
-class Thread::Queue < Object
-  # Alias for: [push](Queue.downloaded.ruby_doc#method-i-push)
-  def <<: (untyped obj) -> untyped
-
-  # Removes all objects from the queue.
-  def clear: () -> untyped
-
-  # Closes the queue. A closed queue cannot be re-opened.
-  # 
-  # After the call to close completes, the following are true:
-  # 
-  #   - `closed?` will return true
-  # 
-  #   - `close` will be ignored.
-  # 
-  #   - calling enq/push/\<\< will raise a `ClosedQueueError` .
-  # 
-  #   - when `empty?` is false, calling deq/pop/shift will return an object
-  #     from the queue as usual.
-  # 
-  #   - when `empty?` is true, deq(false) will not suspend the thread and
-  #     will return nil. deq(true) will raise a `ThreadError` .
-  # 
-  # [ClosedQueueError](https://ruby-doc.org/core-2.6.3/ClosedQueueError.html)
-  # is inherited from
-  # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html), so
-  # that you can break loop block.
-  # 
-  #     Example:
-  # 
-  #         q = Queue.new
-  #         Thread.new{
-  #           while e = q.deq # wait for nil to break loop
-  #             # ...
-  #           end
-  #         }
-  #         q.close
-  def close: () -> untyped
-
-  # Returns `true` if the queue is closed.
-  def closed?: () -> bool
-
-  # Alias for: [pop](Queue.downloaded.ruby_doc#method-i-pop)
-  def deq: (*untyped args) -> untyped
-
-  # Returns `true` if the queue is empty.
-  def empty?: () -> bool
-
-  # Alias for: [push](Queue.downloaded.ruby_doc#method-i-push)
-  def enq: (untyped obj) -> untyped
-
-  # Returns the length of the queue.
-  # 
-  # 
-  # 
-  # Also aliased as: [size](Queue.downloaded.ruby_doc#method-i-size)
-  def length: () -> Integer
-
-  def marshal_dump: () -> untyped
-
-  # Returns the number of threads waiting on the queue.
-  def num_waiting: () -> untyped
-
-  # Retrieves data from the queue.
-  # 
-  # If the queue is empty, the calling thread is suspended until data is
-  # pushed onto the queue. If `non_block` is true, the thread isn't
-  # suspended, and `ThreadError` is raised.
-  # 
-  # 
-  # 
-  # Also aliased as: [deq](Queue.downloaded.ruby_doc#method-i-deq),
-  # [shift](Queue.downloaded.ruby_doc#method-i-shift)
-  def pop: (*untyped args) -> untyped
-
-  # Pushes the given `object` to the queue.
-  # 
-  # 
-  # 
-  # Also aliased as: [enq](Queue.downloaded.ruby_doc#method-i-enq),
-  # [\<\<](Queue.downloaded.ruby_doc#method-i-3C-3C)
-  def push: (untyped obj) -> untyped
-
-  # Alias for: [pop](Queue.downloaded.ruby_doc#method-i-pop)
-  def shift: (*untyped args) -> untyped
-
-  # Alias for: [length](Queue.downloaded.ruby_doc#method-i-length)
-  def size: () -> Integer
-end
-
-# This class represents queues of specified size capacity. The push
-# operation may be blocked if the capacity is full.
-# 
-# See [Queue](https://ruby-doc.org/core-2.6.3/Queue.html) for an example
-# of how a [SizedQueue](SizedQueue) works.
-class Thread::SizedQueue < Thread::Queue
-  # Alias for: [push](SizedQueue.downloaded.ruby_doc#method-i-push)
-  def <<: (*untyped args) -> untyped
-
-  # Alias for: [push](SizedQueue.downloaded.ruby_doc#method-i-push)
-  def enq: (*untyped args) -> untyped
-
-  def initialize: (untyped max) -> SizedQueue
-
-  # Returns the maximum size of the queue.
-  def max: () -> Integer
-
-  # Sets the maximum size of the queue to the given `number` .
-  def max=: (Integer max) -> untyped
-
-  # Pushes `object` to the queue.
-  # 
-  # If there is no space left in the queue, waits until space becomes
-  # available, unless `non_block` is true. If `non_block` is true, the
-  # thread isn't suspended, and `ThreadError` is raised.
-  # 
-  # 
-  # 
-  # Also aliased as: [enq](SizedQueue.downloaded.ruby_doc#method-i-enq),
-  # [\<\<](SizedQueue.downloaded.ruby_doc#method-i-3C-3C)
-  def push: (*untyped args) -> untyped
-end
-
-ConditionVariable: untyped
-
-Mutex: untyped
-
-Queue: untyped
-
-SizedQueue: untyped