steep 0.13.0 → 0.16.2

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

@@ -1,10 +0,0 @@
-module RbConfig
-end
-
-RbConfig::CONFIG: Hash[String, String]
-
-RbConfig::DESTDIR: String
-
-RbConfig::MAKEFILE_CONFIG: Hash[String, String]
-
-RbConfig::TOPDIR: String

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

@@ -1,131 +0,0 @@
-class Regexp < Object
-  def self.escape: (String | Symbol arg0) -> String
-
-  def self.last_match: () -> MatchData?
-                     | (Integer n) -> String?
-                     | (Symbol | String n) -> String?
-
-  def self.try_convert: (untyped obj) -> Regexp?
-
-  def ==: (untyped other) -> bool
-
-  def ===: (untyped other) -> bool
-
-  def =~: (String? str) -> Integer?
-
-  # Returns the value of the case-insensitive flag.
-  #
-  # ```ruby
-  # /a/.casefold?           #=> false
-  # /a/i.casefold?          #=> true
-  # /(?i:a)/.casefold?      #=> false
-  # ```
-  def casefold?: () -> bool
-
-  # Returns the [Encoding](https://ruby-doc.org/core-2.6.3/Encoding.html)
-  # object that represents the encoding of obj.
-  def encoding: () -> Encoding
-
-  def fixed_encoding?: () -> bool
-
-  # Produce a hash based on the text and options of this regular expression.
-  #
-  # See also Object\#hash.
-  def hash: () -> Integer
-
-  def initialize: (String arg0, ?untyped options, ?String kcode) -> Object
-                | (Regexp arg0) -> void
-
-  # Produce a nicely formatted string-version of *rxp* . Perhaps
-  # surprisingly, `#inspect` actually produces the more natural version of
-  # the string than `#to_s` .
-  #
-  # ```ruby
-  # /ab+c/ix.inspect        #=> "/ab+c/ix"
-  # ```
-  def inspect: () -> String
-
-  def match: (String? | Symbol | _ToStr arg0, ?Integer arg1) -> MatchData?
-           | (String? | Symbol | _ToStr arg0, ?Integer arg1) { (MatchData) -> untyped } -> untyped
-
-  def match?: (String? | Symbol | _ToStr arg0, ?Integer arg1) -> bool
-
-  def named_captures: () -> ::Hash[String, ::Array[Integer]]
-
-  def names: () -> ::Array[String]
-
-  # Returns the set of bits corresponding to the options used when creating
-  # this [Regexp](Regexp.downloaded.ruby_doc) (see `Regexp::new` for
-  # details. Note that additional bits may be set in the returned options:
-  # these are used internally by the regular expression code. These extra
-  # bits are ignored if the options are passed to `Regexp::new` .
-  #
-  # ```ruby
-  # Regexp::IGNORECASE                  #=> 1
-  # Regexp::EXTENDED                    #=> 2
-  # Regexp::MULTILINE                   #=> 4
-  #
-  # /cat/.options                       #=> 0
-  # /cat/ix.options                     #=> 3
-  # Regexp.new('cat', true).options     #=> 1
-  # /\xa1\xa2/e.options                 #=> 16
-  #
-  # r = /cat/ix
-  # Regexp.new(r.source, r.options)     #=> /cat/ix
-  # ```
-  def options: () -> Integer
-
-  # Returns the original string of the pattern.
-  #
-  # ```ruby
-  # /ab+c/ix.source #=> "ab+c"
-  # ```
-  #
-  # Note that escape sequences are retained as is.
-  #
-  # ```ruby
-  # /\x20\+/.source  #=> "\\x20\\+"
-  # ```
-  def source: () -> String
-
-  # Returns a string containing the regular expression and its options
-  # (using the `(?opts:source)` notation. This string can be fed back in to
-  # `Regexp::new` to a regular expression with the same semantics as the
-  # original. (However, `Regexp#==` may not return true when comparing the
-  # two, as the source of the regular expression itself may differ, as the
-  # example shows). `Regexp#inspect` produces a generally more readable
-  # version of *rxp* .
-  #
-  # ```ruby
-  # r1 = /ab+c/ix           #=> /ab+c/ix
-  # s1 = r1.to_s            #=> "(?ix-m:ab+c)"
-  # r2 = Regexp.new(s1)     #=> /(?ix-m:ab+c)/
-  # r1 == r2                #=> false
-  # r1.source               #=> "ab+c"
-  # r2.source               #=> "(?ix-m:ab+c)"
-  # ```
-  def to_s: () -> String
-
-  def ~: () -> Integer?
-
-  def self.compile: (String arg0, ?untyped options, ?String kcode) -> Regexp
-                  | (Regexp arg0) -> Regexp
-
-  def self.quote: (String | Symbol arg0) -> String
-
-  def self.union: () -> Regexp
-                | (String | Regexp arg0, *String | Regexp args) -> Regexp
-                | (::Array[String | Regexp]) -> Regexp
-
-  def eql?: (untyped other) -> bool
-end
-
-Regexp::EXTENDED: Integer
-
-Regexp::FIXEDENCODING: Integer
-
-Regexp::IGNORECASE: Integer
-
-Regexp::MULTILINE: Integer
-
-Regexp::NOENCODING: Integer

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

@@ -1,14 +0,0 @@
-# The [RubyVM](RubyVM) module provides some access to
-# Ruby internals. This module is for very limited purposes, such as
-# debugging, prototyping, and research. Normal users must not use it.
-class RubyVM < Object
-end
-
-RubyVM::DEFAULT_PARAMS: Hash[Symbol, Integer]
-
-RubyVM::INSTRUCTION_NAMES: Array[String]
-
-RubyVM::OPTS: Array[String]
-
-class RubyVM::InstructionSequence < Object
-end

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

@@ -1,55 +0,0 @@
-# Many operating systems allow signals to be sent to running processes.
-# Some signals have a defined effect on the process, while others may be
-# trapped at the code level and acted upon. For example, your process may
-# trap the USR1 signal and use it to toggle debugging, and may use TERM to
-# initiate a controlled shutdown.
-# 
-# ```ruby
-# pid = fork do
-#   Signal.trap("USR1") do
-#     $debug = !$debug
-#     puts "Debug now: #$debug"
-#   end
-#   Signal.trap("TERM") do
-#     puts "Terminating..."
-#     shutdown()
-#   end
-#   # . . . do some work . . .
-# end
-# 
-# Process.detach(pid)
-# 
-# # Controlling program:
-# Process.kill("USR1", pid)
-# # ...
-# Process.kill("USR1", pid)
-# # ...
-# Process.kill("TERM", pid)
-# ```
-# 
-# produces:
-# 
-# ```
-#  Debug now: true
-#  Debug now: false
-# Terminating...
-# ```
-# 
-# The list of available signal names and their interpretation is system
-# dependent. [Signal](Signal) delivery semantics may
-# also vary between systems; in particular signal delivery may not always
-# be reliable.
-module Signal
-  # Returns a list of signal names mapped to the corresponding underlying
-  # signal numbers.
-  # 
-  # ```ruby
-  # Signal.list   #=> {"EXIT"=>0, "HUP"=>1, "INT"=>2, "QUIT"=>3, "ILL"=>4, "TRAP"=>5, "IOT"=>6, "ABRT"=>6, "FPE"=>8, "KILL"=>9, "BUS"=>7, "SEGV"=>11, "SYS"=>31, "PIPE"=>13, "ALRM"=>14, "TERM"=>15, "URG"=>23, "STOP"=>19, "TSTP"=>20, "CONT"=>18, "CHLD"=>17, "CLD"=>17, "TTIN"=>21, "TTOU"=>22, "IO"=>29, "XCPU"=>24, "XFSZ"=>25, "VTALRM"=>26, "PROF"=>27, "WINCH"=>28, "USR1"=>10, "USR2"=>12, "PWR"=>30, "POLL"=>29}
-  # ```
-  def self.list: () -> ::Hash[String, Integer]
-
-  def self.signame: (Integer arg0) -> String?
-
-  def self.trap: (Integer | String | Symbol signal, ?untyped command) -> (String | Proc)
-               | (Integer | String | Symbol signal) { (Integer arg0) -> untyped } -> (String | Proc)
-end

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

@@ -1,770 +0,0 @@
-# A `String` object holds and manipulates an arbitrary sequence of bytes,
-# typically representing characters. [String](String)
-# objects may be created using `String::new` or as literals.
-# 
-# Because of aliasing issues, users of strings should be aware of the
-# methods that modify the contents of a `String` object. Typically,
-# methods with names ending in “\!” modify their receiver, while those
-# without a “\!” return a new `String` . However, there are exceptions,
-# such as `String#[]=` .
-class String < Object
-  include Comparable
-
-  def %: (Object arg0) -> String
-
-  def *: (Integer arg0) -> String
-
-  def +: (String arg0) -> String
-
-  def <<: (Object arg0) -> String
-
-  def <=>: (String other) -> Integer?
-
-  def ==: (untyped arg0) -> bool
-
-  def ===: (untyped arg0) -> bool
-
-  %a{rbs:test:skip}
-  def =~: (Object arg0) -> Integer?
-
-  def []: (Integer arg0, ?Integer arg1) -> String?
-        | (::Range[Integer] | Regexp arg0) -> String?
-        | (Regexp arg0, ?Integer arg1) -> String?
-        | (Regexp arg0, ?String arg1) -> String?
-        | (String arg0) -> String?
-
-  # Returns true for a string which has only ASCII characters.
-  # 
-  # ```ruby
-  # "abc".force_encoding("UTF-8").ascii_only?          #=> true
-  # "abc\u{6666}".force_encoding("UTF-8").ascii_only?  #=> false
-  # ```
-  def ascii_only?: () -> bool
-
-  # Returns a copied string whose encoding is ASCII-8BIT.
-  def b: () -> String
-
-  # Returns an array of bytes in *str* . This is a shorthand for
-  # `str.each_byte.to_a` .
-  # 
-  # If a block is given, which is a deprecated form, works the same as
-  # `each_byte` .
-  def bytes: () -> Array[String]
-
-  # Returns the length of `str` in bytes.
-  # 
-  #     "\x80\u3042".bytesize  #=> 4
-  #     "hello".bytesize       #=> 5
-  def bytesize: () -> Integer
-
-  def byteslice: (Integer arg0, ?Integer arg1) -> String?
-               | (::Range[Integer] arg0) -> String?
-
-  # Returns a copy of *str* with the first character converted to uppercase
-  # and the remainder to lowercase.
-  # 
-  # See [\#downcase](String.downloaded.ruby_doc#method-i-downcase) for
-  # meaning of `options` and use with different encodings.
-  # 
-  # ```ruby
-  # "hello".capitalize    #=> "Hello"
-  # "HELLO".capitalize    #=> "Hello"
-  # "123ABC".capitalize   #=> "123abc"
-  # ```
-  def capitalize: () -> String
-
-  # Modifies *str* by converting the first character to uppercase and the
-  # remainder to lowercase. Returns `nil` if no changes are made. There is
-  # an exception for modern Georgian (mkhedruli/MTAVRULI), where the result
-  # is the same as for
-  # [\#downcase](String.downloaded.ruby_doc#method-i-downcase), to avoid
-  # mixed case.
-  # 
-  # See [\#downcase](String.downloaded.ruby_doc#method-i-downcase) for
-  # meaning of `options` and use with different encodings.
-  # 
-  # ```ruby
-  # a = "hello"
-  # a.capitalize!   #=> "Hello"
-  # a               #=> "Hello"
-  # a.capitalize!   #=> nil
-  # ```
-  def capitalize!: () -> String?
-
-  def casecmp: (String arg0) -> Integer?
-
-  def center: (Integer arg0, ?String arg1) -> String
-
-  # Returns an array of characters in *str* . This is a shorthand for
-  # `str.each_char.to_a` .
-  # 
-  # If a block is given, which is a deprecated form, works the same as
-  # `each_char` .
-  def chars: () -> Array[String]
-
-  def chomp: (?String arg0) -> String
-
-  def chomp!: (?String arg0) -> String?
-
-  # Returns a new `String` with the last character removed. If the string
-  # ends with `\r\n`, both characters are removed. Applying `chop` to an
-  # empty string returns an empty string. `String#chomp` is often a safer
-  # alternative, as it leaves the string unchanged if it doesn’t end in a
-  # record separator.
-  # 
-  # ```ruby
-  # "string\r\n".chop   #=> "string"
-  # "string\n\r".chop   #=> "string\n"
-  # "string\n".chop     #=> "string"
-  # "string".chop       #=> "strin"
-  # "x".chop.chop       #=> ""
-  # ```
-  def chop: () -> String
-
-  # Processes *str* as for `String#chop`, returning *str* , or `nil` if
-  # *str* is the empty string. See also `String#chomp!` .
-  def chop!: () -> String?
-
-  # Returns a one-character string at the beginning of the string.
-  # 
-  # ```ruby
-  # a = "abcde"
-  # a.chr    #=> "a"
-  # ```
-  def chr: () -> String
-
-  # Makes string empty.
-  # 
-  # ```ruby
-  # a = "abcde"
-  # a.clear    #=> ""
-  # ```
-  def clear: () -> String
-
-  # Returns an array of the `Integer` ordinals of the characters in *str* .
-  # This is a shorthand for `str.each_codepoint.to_a` .
-  # 
-  # If a block is given, which is a deprecated form, works the same as
-  # `each_codepoint` .
-  def codepoints: () -> ::Array[Integer]
-                | () { () -> untyped } -> ::Array[Integer]
-
-  def concat: (Integer | Object arg0) -> String
-
-  def count: (String arg0, *String arg1) -> Integer
-
-  def crypt: (String arg0) -> String
-
-  def delete: (String arg0, *String arg1) -> String
-
-  def delete!: (String arg0, *String arg1) -> String?
-  
-  def delete_prefix: (String) -> String
-
-  def delete_prefix!: (String) -> String?
-
-  def delete_suffix: (String) -> String
-
-  def delete_suffix!: (String) -> String?
-
-  # Returns a copy of *str* with all uppercase letters replaced with their
-  # lowercase counterparts. Which letters exactly are replaced, and by which
-  # other letters, depends on the presence or absence of options, and on the
-  # `encoding` of the string.
-  # 
-  # The meaning of the `options` is as follows:
-  # 
-  #   - No option
-  #     Full Unicode case mapping, suitable for most languages (see :turkic
-  #     and :lithuanian options below for exceptions). Context-dependent
-  #     case mapping as described in Table 3-14 of the Unicode standard is
-  #     currently not supported.
-  # 
-  #   - :ascii
-  #     Only the ASCII region, i.e. the characters “A” to “Z” and “a” to
-  #     “z”, are affected. This option cannot be combined with any other
-  #     option.
-  # 
-  #   - :turkic
-  #     Full Unicode case mapping, adapted for Turkic languages (Turkish,
-  #     Azerbaijani, …). This means that upper case I is mapped to lower
-  #     case dotless i, and so on.
-  # 
-  #   - :lithuanian
-  #     Currently, just full Unicode case mapping. In the future, full
-  #     Unicode case mapping adapted for Lithuanian (keeping the dot on the
-  #     lower case i even if there is an accent on top).
-  # 
-  #   - :fold
-  #     Only available on `downcase` and `downcase!` . Unicode case
-  #     **folding** , which is more far-reaching than Unicode case mapping.
-  #     This option currently cannot be combined with any other option (i.e.
-  #     there is currently no variant for turkic languages).
-  # 
-  # Please note that several assumptions that are valid for ASCII-only case
-  # conversions do not hold for more general case conversions. For example,
-  # the length of the result may not be the same as the length of the input
-  # (neither in characters nor in bytes), some roundtrip assumptions (e.g.
-  # str.downcase == str.upcase.downcase) may not apply, and Unicode
-  # normalization (i.e.
-  # [\#unicode\_normalize](String.downloaded.ruby_doc#method-i-unicode_normalize)
-  # ) is not necessarily maintained by case mapping operations.
-  # 
-  # Non-ASCII case mapping/folding is currently supported for UTF-8,
-  # UTF-16BE/LE, UTF-32BE/LE, and ISO-8859-1\~16 Strings/Symbols. This
-  # support will be extended to other encodings.
-  # 
-  # ```ruby
-  # "hEllO".downcase   #=> "hello"
-  # ```
-  def downcase: () -> String
-
-  # Downcases the contents of *str* , returning `nil` if no changes were
-  # made.
-  # 
-  # See [\#downcase](String.downloaded.ruby_doc#method-i-downcase) for
-  # meaning of `options` and use with different encodings.
-  def downcase!: () -> String?
-
-  # Produces a version of `str` with all non-printing characters replaced by
-  # `\nnn` notation and all special characters escaped.
-  # 
-  # ```ruby
-  # "hello \n ''".dump  #=> "\"hello \\n ''\""
-  # ```
-  def dump: () -> String
-
-  def each_byte: () { (Integer arg0) -> untyped } -> String
-               | () -> ::Enumerator[Integer, self]
-
-  def each_char: () { (String arg0) -> untyped } -> String
-               | () -> ::Enumerator[String, self]
-
-  def each_codepoint: () { (Integer arg0) -> untyped } -> String
-                    | () -> ::Enumerator[Integer, self]
-
-  def each_line: (?String arg0) { (String arg0) -> untyped } -> String
-               | (?String arg0) -> ::Enumerator[String, self]
-
-  # Returns `true` if *str* has a length of zero.
-  # 
-  # ```ruby
-  # "hello".empty?   #=> false
-  # " ".empty?       #=> false
-  # "".empty?        #=> true
-  # ```
-  def empty?: () -> bool
-
-  # Returns the [Encoding](https://ruby-doc.org/core-2.6.3/Encoding.html)
-  # object that represents the encoding of obj.
-  def encoding: () -> Encoding
-
-  def end_with?: (*String arg0) -> bool
-
-  def eql?: (String arg0) -> bool
-
-  def force_encoding: (String | Encoding arg0) -> String
-
-  def getbyte: (Integer arg0) -> Integer?
-
-  def gsub: (Regexp | String arg0, ?String arg1) -> String
-          | (Regexp | String arg0, ?Hash[String, String] arg1) -> String
-          | (Regexp | String arg0) { (String arg0) -> untyped } -> String
-          | (Regexp | String arg0) -> ::Enumerator[String, self]
-          | (Regexp | String arg0) -> String
-
-  def gsub!: (Regexp | String arg0, ?String arg1) -> String?
-           | (Regexp | String arg0) { (String arg0) -> untyped } -> String?
-           | (Regexp | String arg0) -> ::Enumerator[String, self]
-
-  # Returns a hash based on the string’s length, content and encoding.
-  # 
-  # See also Object\#hash.
-  def hash: () -> Integer
-
-  # Treats leading characters from *str* as a string of hexadecimal digits
-  # (with an optional sign and an optional `0x` ) and returns the
-  # corresponding number. Zero is returned on error.
-  # 
-  # ```ruby
-  # "0x0a".hex     #=> 10
-  # "-1234".hex    #=> -4660
-  # "0".hex        #=> 0
-  # "wombat".hex   #=> 0
-  # ```
-  def hex: () -> Integer
-
-  def `include?`: (String arg0) -> bool
-
-  def index: (Regexp | String arg0, ?Integer arg1) -> Integer?
-
-  def initialize: (?String str, ?encoding: Encoding | String, ?capacity: Integer) -> void
-
-  def insert: (Integer arg0, String arg1) -> String
-
-  # Returns a printable version of *str* , surrounded by quote marks, with
-  # special characters escaped.
-  # 
-  # ```ruby
-  # str = "hello"
-  # str[3] = "\b"
-  # str.inspect       #=> "\"hel\\bo\""
-  # ```
-  def inspect: () -> String
-
-  # Returns the `Symbol` corresponding to *str* , creating the symbol if it
-  # did not previously exist. See `Symbol#id2name` .
-  # 
-  # ```ruby
-  # "Koala".intern         #=> :Koala
-  # s = 'cat'.to_sym       #=> :cat
-  # s == :cat              #=> true
-  # s = '@cat'.to_sym      #=> :@cat
-  # s == :@cat             #=> true
-  # ```
-  # 
-  # This can also be used to create symbols that cannot be represented using
-  # the `:xxx` notation.
-  # 
-  # ```ruby
-  # 'cat and dog'.to_sym   #=> :"cat and dog"
-  # ```
-  def intern: () -> Symbol
-
-  # Returns the character length of *str* .
-  def length: () -> Integer
-
-  def lines: (?String arg0) -> ::Array[String]
-
-  def ljust: (Integer arg0, ?String arg1) -> String
-
-  # Returns a copy of the receiver with leading whitespace removed. See also
-  # [\#rstrip](String.downloaded.ruby_doc#method-i-rstrip) and
-  # [\#strip](String.downloaded.ruby_doc#method-i-strip).
-  # 
-  # Refer to [\#strip](String.downloaded.ruby_doc#method-i-strip) for the
-  # definition of whitespace.
-  # 
-  # ```ruby
-  # "  hello  ".lstrip   #=> "hello  "
-  # "hello".lstrip       #=> "hello"
-  # ```
-  def lstrip: () -> String
-
-  # Removes leading whitespace from the receiver. Returns the altered
-  # receiver, or `nil` if no change was made. See also
-  # [\#rstrip\!](String.downloaded.ruby_doc#method-i-rstrip-21) and
-  # [\#strip\!](String.downloaded.ruby_doc#method-i-strip-21).
-  # 
-  # Refer to [\#strip](String.downloaded.ruby_doc#method-i-strip) for the
-  # definition of whitespace.
-  # 
-  # ```ruby
-  # "  hello  ".lstrip!  #=> "hello  "
-  # "hello  ".lstrip!    #=> nil
-  # "hello".lstrip!      #=> nil
-  # ```
-  def lstrip!: () -> String?
-
-  def match: (Regexp | String arg0) -> MatchData?
-           | (Regexp | String arg0, ?Integer arg1) -> MatchData?
-
-  def match?: (Regexp | String arg0) -> bool
-            | (Regexp | String arg0, ?Integer arg1) -> bool
-
-  # Returns the successor to *str* . The successor is calculated by
-  # incrementing characters starting from the rightmost alphanumeric (or the
-  # rightmost character if there are no alphanumerics) in the string.
-  # Incrementing a digit always results in another digit, and incrementing a
-  # letter results in another letter of the same case. Incrementing
-  # nonalphanumerics uses the underlying character set’s collating sequence.
-  # 
-  # If the increment generates a “carry,” the character to the left of it is
-  # incremented. This process repeats until there is no carry, adding an
-  # additional character if necessary.
-  # 
-  # ```ruby
-  # "abcd".succ        #=> "abce"
-  # "THX1138".succ     #=> "THX1139"
-  # "<<koala>>".succ   #=> "<<koalb>>"
-  # "1999zzz".succ     #=> "2000aaa"
-  # "ZZZ9999".succ     #=> "AAAA0000"
-  # "***".succ         #=> "**+"
-  # ```
-  def next: () -> String
-
-  # Equivalent to `String#succ`, but modifies the receiver in place.
-  def next!: () -> String
-
-  # Treats leading characters of *str* as a string of octal digits (with an
-  # optional sign) and returns the corresponding number. Returns 0 if the
-  # conversion fails.
-  # 
-  # ```ruby
-  # "123".oct       #=> 83
-  # "-377".oct      #=> -255
-  # "bad".oct       #=> 0
-  # "0377bad".oct   #=> 255
-  # ```
-  # 
-  # If `str` starts with `0`, radix indicators are honored. See
-  # Kernel\#Integer.
-  def oct: () -> Integer
-
-  # Returns the `Integer` ordinal of a one-character string.
-  # 
-  # ```ruby
-  # "a".ord         #=> 97
-  # ```
-  def ord: () -> Integer
-
-  def partition: (Regexp | String arg0) -> [ String, String, String ]
-
-  def `prepend`: (String arg0) -> String
-
-  def replace: (String arg0) -> String
-
-  # Returns a new string with the characters from *str* in reverse order.
-  # 
-  # ```ruby
-  # "stressed".reverse   #=> "desserts"
-  # ```
-  def reverse: () -> String
-
-  def rindex: (String | Regexp arg0, ?Integer arg1) -> Integer?
-
-  def rjust: (Integer arg0, ?String arg1) -> String
-
-  def rpartition: (String | Regexp arg0) -> [ String, String, String ]
-
-  # Returns a copy of the receiver with trailing whitespace removed. See
-  # also [\#lstrip](String.downloaded.ruby_doc#method-i-lstrip) and
-  # [\#strip](String.downloaded.ruby_doc#method-i-strip).
-  # 
-  # Refer to [\#strip](String.downloaded.ruby_doc#method-i-strip) for the
-  # definition of whitespace.
-  # 
-  # ```ruby
-  # "  hello  ".rstrip   #=> "  hello"
-  # "hello".rstrip       #=> "hello"
-  # ```
-  def rstrip: () -> String
-
-  # Removes trailing whitespace from the receiver. Returns the altered
-  # receiver, or `nil` if no change was made. See also
-  # [\#lstrip\!](String.downloaded.ruby_doc#method-i-lstrip-21) and
-  # [\#strip\!](String.downloaded.ruby_doc#method-i-strip-21).
-  # 
-  # Refer to [\#strip](String.downloaded.ruby_doc#method-i-strip) for the
-  # definition of whitespace.
-  # 
-  # ```ruby
-  # "  hello  ".rstrip!  #=> "  hello"
-  # "  hello".rstrip!    #=> nil
-  # "hello".rstrip!      #=> nil
-  # ```
-  def rstrip!: () -> String
-
-  def scan: (Regexp | String arg0) -> ::Array[String | ::Array[String]]
-          | (Regexp | String arg0) { () -> untyped } -> ::Array[String | ::Array[String]]
-
-  def scrub: (?String arg0) -> String
-           | (?String arg0) { (untyped arg0) -> untyped } -> String
-
-  def scrub!: (?String arg0) -> String
-            | (?String arg0) { (untyped arg0) -> untyped } -> String
-
-  def setbyte: (Integer arg0, Integer arg1) -> Integer
-
-  # Returns the character length of *str* .
-  def size: () -> Integer
-
-  def slice!: (Integer arg0, ?Integer arg1) -> String?
-            | (::Range[Integer] | Regexp arg0) -> String?
-            | (Regexp arg0, ?Integer arg1) -> String?
-            | (Regexp arg0, ?String arg1) -> String?
-            | (String arg0) -> String?
-
-  def split: (?Regexp | String arg0, ?Integer arg1) -> ::Array[String]
-           | (?Integer arg0) -> ::Array[String]
-
-  def squeeze: (?String arg0) -> String
-
-  def squeeze!: (?String arg0) -> String
-
-  def start_with?: (*String arg0) -> bool
-
-  # Returns a copy of the receiver with leading and trailing whitespace
-  # removed.
-  # 
-  # Whitespace is defined as any of the following characters: null,
-  # horizontal tab, line feed, vertical tab, form feed, carriage return,
-  # space.
-  # 
-  # ```ruby
-  # "    hello    ".strip   #=> "hello"
-  # "\tgoodbye\r\n".strip   #=> "goodbye"
-  # "\x00\t\n\v\f\r ".strip #=> ""
-  # "hello".strip           #=> "hello"
-  # ```
-  def strip: () -> String
-
-  # Removes leading and trailing whitespace from the receiver. Returns the
-  # altered receiver, or `nil` if there was no change.
-  # 
-  # Refer to [\#strip](String.downloaded.ruby_doc#method-i-strip) for the
-  # definition of whitespace.
-  # 
-  # ```ruby
-  # "  hello  ".strip!  #=> "hello"
-  # "hello".strip!      #=> nil
-  # ```
-  def strip!: () -> String
-
-  def sub: (Regexp | String arg0, ?String | Hash[String, String] arg1) -> String
-         | (Regexp | String arg0) { (String arg0) -> untyped } -> String
-
-  def sub!: (Regexp | String arg0, ?String arg1) -> String
-          | (Regexp | String arg0) { (String arg0) -> untyped } -> String
-
-  # Returns the successor to *str* . The successor is calculated by
-  # incrementing characters starting from the rightmost alphanumeric (or the
-  # rightmost character if there are no alphanumerics) in the string.
-  # Incrementing a digit always results in another digit, and incrementing a
-  # letter results in another letter of the same case. Incrementing
-  # nonalphanumerics uses the underlying character set’s collating sequence.
-  # 
-  # If the increment generates a “carry,” the character to the left of it is
-  # incremented. This process repeats until there is no carry, adding an
-  # additional character if necessary.
-  # 
-  # ```ruby
-  # "abcd".succ        #=> "abce"
-  # "THX1138".succ     #=> "THX1139"
-  # "<<koala>>".succ   #=> "<<koalb>>"
-  # "1999zzz".succ     #=> "2000aaa"
-  # "ZZZ9999".succ     #=> "AAAA0000"
-  # "***".succ         #=> "**+"
-  # ```
-  def succ: () -> String
-
-  def succ!: () -> String
-
-  def sum: (?Integer arg0) -> Integer
-
-  # Returns a copy of *str* with uppercase alphabetic characters converted
-  # to lowercase and lowercase characters converted to uppercase.
-  # 
-  # See [\#downcase](String.downloaded.ruby_doc#method-i-downcase) for
-  # meaning of `options` and use with different encodings.
-  # 
-  # ```ruby
-  # "Hello".swapcase          #=> "hELLO"
-  # "cYbEr_PuNk11".swapcase   #=> "CyBeR_pUnK11"
-  # ```
-  def swapcase: () -> String
-
-  # Equivalent to `String#swapcase`, but modifies the receiver in place,
-  # returning *str* , or `nil` if no changes were made.
-  # 
-  # See [\#downcase](String.downloaded.ruby_doc#method-i-downcase) for
-  # meaning of `options` and use with different encodings.
-  def swapcase!: () -> String?
-
-  # Returns a complex which denotes the string form. The parser ignores
-  # leading whitespaces and trailing garbage. Any digit sequences can be
-  # separated by an underscore. Returns zero for null or garbage string.
-  # 
-  # ```ruby
-  # '9'.to_c           #=> (9+0i)
-  # '2.5'.to_c         #=> (2.5+0i)
-  # '2.5/1'.to_c       #=> ((5/2)+0i)
-  # '-3/2'.to_c        #=> ((-3/2)+0i)
-  # '-i'.to_c          #=> (0-1i)
-  # '45i'.to_c         #=> (0+45i)
-  # '3-4i'.to_c        #=> (3-4i)
-  # '-4e2-4e-2i'.to_c  #=> (-400.0-0.04i)
-  # '-0.0-0.0i'.to_c   #=> (-0.0-0.0i)
-  # '1/2+3/4i'.to_c    #=> ((1/2)+(3/4)*i)
-  # 'ruby'.to_c        #=> (0+0i)
-  # ```
-  # 
-  # See [Kernel](https://ruby-doc.org/core-2.6.3/Kernel.html).Complex.
-  def to_c: () -> Complex
-
-  # Returns the result of interpreting leading characters in *str* as a
-  # floating point number. Extraneous characters past the end of a valid
-  # number are ignored. If there is not a valid number at the start of *str*
-  # , `0.0` is returned. This method never raises an exception.
-  # 
-  # ```ruby
-  # "123.45e1".to_f        #=> 1234.5
-  # "45.67 degrees".to_f   #=> 45.67
-  # "thx1138".to_f         #=> 0.0
-  # ```
-  def to_f: () -> Float
-
-  def to_i: (?Integer arg0) -> Integer
-
-  # Returns the result of interpreting leading characters in `str` as a
-  # rational. Leading whitespace and extraneous characters past the end of a
-  # valid number are ignored. Digit sequences can be separated by an
-  # underscore. If there is not a valid number at the start of `str`, zero
-  # is returned. This method never raises an exception.
-  # 
-  # ```ruby
-  # '  2  '.to_r       #=> (2/1)
-  # '300/2'.to_r       #=> (150/1)
-  # '-9.2'.to_r        #=> (-46/5)
-  # '-9.2e2'.to_r      #=> (-920/1)
-  # '1_234_567'.to_r   #=> (1234567/1)
-  # '21 June 09'.to_r  #=> (21/1)
-  # '21/06/09'.to_r    #=> (7/2)
-  # 'BWV 1079'.to_r    #=> (0/1)
-  # ```
-  # 
-  # NOTE: “0.3”.to\_r isn’t the same as 0.3.to\_r. The former is equivalent
-  # to “3/10”.to\_r, but the latter isn’t so.
-  # 
-  #     "0.3".to_r == 3/10r  #=> true
-  #     0.3.to_r   == 3/10r  #=> false
-  # 
-  # See also Kernel\#Rational.
-  def to_r: () -> Rational
-
-  # Returns `self` .
-  # 
-  # If called on a subclass of [String](String.downloaded.ruby_doc),
-  # converts the receiver to a [String](String.downloaded.ruby_doc) object.
-  def to_s: () -> String
-
-  # Returns `self` .
-  # 
-  # If called on a subclass of [String](String.downloaded.ruby_doc),
-  # converts the receiver to a [String](String.downloaded.ruby_doc) object.
-  def to_str: () -> String
-
-  # Returns the `Symbol` corresponding to *str* , creating the symbol if it
-  # did not previously exist. See `Symbol#id2name` .
-  # 
-  # ```ruby
-  # "Koala".intern         #=> :Koala
-  # s = 'cat'.to_sym       #=> :cat
-  # s == :cat              #=> true
-  # s = '@cat'.to_sym      #=> :@cat
-  # s == :@cat             #=> true
-  # ```
-  # 
-  # This can also be used to create symbols that cannot be represented using
-  # the `:xxx` notation.
-  # 
-  # ```ruby
-  # 'cat and dog'.to_sym   #=> :"cat and dog"
-  # ```
-  def to_sym: () -> Symbol
-
-  def tr: (String arg0, String arg1) -> String
-
-  def tr!: (String arg0, String arg1) -> String?
-
-  def tr_s: (String arg0, String arg1) -> String
-
-  def tr_s!: (String arg0, String arg1) -> String?
-
-  def unpack: (String arg0) -> ::Array[(Integer | Float | String)?]
-
-  # Returns a copy of *str* with all lowercase letters replaced with their
-  # uppercase counterparts.
-  # 
-  # See [\#downcase](String.downloaded.ruby_doc#method-i-downcase) for
-  # meaning of `options` and use with different encodings.
-  # 
-  # ```ruby
-  # "hEllO".upcase   #=> "HELLO"
-  # ```
-  def upcase: () -> String
-
-  # Upcases the contents of *str* , returning `nil` if no changes were made.
-  # 
-  # See [\#downcase](String.downloaded.ruby_doc#method-i-downcase) for
-  # meaning of `options` and use with different encodings.
-  def upcase!: () -> String?
-
-  def upto: [Bool] (String arg0, ?Bool arg1) -> ::Enumerator[String, self]
-          | [Bool] (String arg0, ?Bool arg1) { (String arg0) -> untyped } -> String
-
-  # Returns true for a string which is encoded correctly.
-  # 
-  # ```ruby
-  # "\xc2\xa1".force_encoding("UTF-8").valid_encoding?  #=> true
-  # "\xc2".force_encoding("UTF-8").valid_encoding?      #=> false
-  # "\x80".force_encoding("UTF-8").valid_encoding?      #=> false
-  # ```
-  def valid_encoding?: () -> bool
-
-  def self.try_convert: (Object obj) -> String?
-
-  def slice: (Integer arg0, ?Integer arg1) -> String?
-           | (::Range[Integer] | Regexp arg0) -> String?
-           | (Regexp arg0, ?Integer arg1) -> String?
-           | (Regexp arg0, ?String arg1) -> String?
-           | (String arg0) -> String?
-
-  def encode: (
-    ?(Encoding | String) encoding,
-    ?(Encoding | String) from_encoding,
-    ?invalid: :replace ?,
-    ?undef: :replace ?,
-    ?replace: String,
-    ?fallback: Hash[String, String] | Proc | Method,
-    ?xml: :text | :attr,
-    ?universal_newline: TrueClass,
-    ?cr_newline: TrueClass,
-    ?crlf_newline: TrueClass
-  ) -> String
-
-  def encode!: (
-    ?(Encoding | String) encoding,
-    ?(Encoding | String) from_encoding,
-    ?invalid: :replace ?,
-    ?undef: :replace ?,
-    ?replace: String,
-    ?fallback: Hash[String, String] | Proc | Method,
-    ?xml: :text | :attr,
-    ?universal_newline: TrueClass,
-    ?cr_newline: TrueClass,
-    ?crlf_newline: TrueClass
-  ) -> self
-
-  def +@: () -> String
-
-  def -@: () -> String
-
-  def unicode_normalize: (?(:nfc | :nfd | :nfkc | :nfkd)) -> String
-
-  def unicode_normalize!: (?(:nfc | :nfd | :nfkc | :nfkd)) -> String
-
-  def casecmp?: (String other) -> bool
-              | (untyped other) -> nil
-
-  def []=: (Integer pos, String new_str) -> String
-         | (Integer begin_pos, Integer end_pos, String new_str) -> String
-         | (::Range[Integer] range, String new_str) -> String
-         | (Regexp regexp, String new_str) -> String
-         | (Regexp regexp, Integer capture, String new_str) -> String
-         | (Regexp regexp, String name, String new_str) -> String
-         | (String other_str, String new_str) -> String
-
-  def undump: () -> String
-
-  def grapheme_clusters: () -> ::Array[::String]
-
-  def reverse!: () -> String
-
-  def each_grapheme_cluster: () { (String grapheme) -> untyped } -> self
-                           | () -> ::Enumerator[String, self]
-
-  def unpack1: (String format) -> (Integer | Float | String | nil)
-
-  def unicode_normalized?: (?(:nfc | :nfd | :nfkc | :nfkd)) -> bool
-end