steep 0.11.1 → 0.12.0

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,55 @@
+# 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

@@ -0,0 +1,770 @@
+# 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