steep 0.16.0 → 0.16.1

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,1901 +0,0 @@
-# A String object holds and manipulates an arbitrary sequence of bytes,
-# typically representing characters. 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
-  include Comparable
-
-  # Try to convert *obj* into a String, using to_str method. Returns converted
-  # string or nil if *obj* cannot be converted for any reason.
-  #
-  #     String.try_convert("str")     #=> "str"
-  #     String.try_convert(/re/)      #=> nil
-  #
-  def self.try_convert: (untyped obj) -> String?
-
-  public
-
-  # Format---Uses *str* as a format specification, and returns the result of
-  # applying it to *arg*. If the format specification contains more than one
-  # substitution, then *arg* must be an Array or Hash containing the values to be
-  # substituted. See Kernel#sprintf for details of the format string.
-  #
-  #     "%05d" % 123                              #=> "00123"
-  #     "%-5s: %016x" % [ "ID", self.object_id ]  #=> "ID   : 00002b054ec93168"
-  #     "foo = %{foo}" % { :foo => 'bar' }        #=> "foo = bar"
-  #
-  def %: (Hash[Symbol, untyped]) -> String
-       | (Array[untyped]) -> String
-       | (untyped arg) -> String
-
-  # Copy --- Returns a new String containing `integer` copies of the receiver.
-  # `integer` must be greater than or equal to 0.
-  #
-  #     "Ho! " * 3   #=> "Ho! Ho! Ho! "
-  #     "Ho! " * 0   #=> ""
-  #
-  def *: (int n) -> String
-
-  # Concatenation---Returns a new String containing *other_str* concatenated to
-  # *str*.
-  #
-  #     "Hello from " + self.to_s   #=> "Hello from main"
-  #
-  def +: (string other_str) -> String
-
-  # If the string is frozen, then return duplicated mutable string.
-  #
-  # If the string is not frozen, then return the string itself.
-  #
-  def +@: () -> String
-
-  # Returns a frozen, possibly pre-existing copy of the string.
-  #
-  # The string will be deduplicated as long as it does not have any instance
-  # variables set on it.
-  #
-  def -@: () -> String
-
-  # Appends the given object to *str*. If the object is an Integer, it is
-  # considered a codepoint and converted to a character before being appended.
-  #
-  #     a = "hello "
-  #     a << "world"   #=> "hello world"
-  #     a << 33        #=> "hello world!"
-  #
-  # See also String#concat, which takes multiple arguments.
-  #
-  def <<: (string | Integer str_or_codepoint) -> String
-
-  # Comparison---Returns -1, 0, +1, or `nil` depending on whether `string` is less
-  # than, equal to, or greater than `other_string`.
-  #
-  # `nil` is returned if the two values are incomparable.
-  #
-  # If the strings are of different lengths, and the strings are equal when
-  # compared up to the shortest length, then the longer string is considered
-  # greater than the shorter one.
-  #
-  # `<=>` is the basis for the methods `<`, `<=`, `>`, `>=`, and `between?`,
-  # included from module Comparable. The method String#== does not use
-  # Comparable#==.
-  #
-  #     "abcdef" <=> "abcde"     #=> 1
-  #     "abcdef" <=> "abcdef"    #=> 0
-  #     "abcdef" <=> "abcdefg"   #=> -1
-  #     "abcdef" <=> "ABCDEF"    #=> 1
-  #     "abcdef" <=> 1           #=> nil
-  #
-  def <=>: (untyped other) -> Integer?
-
-  # Equality---Returns whether `str` == `obj`, similar to Object#==.
-  #
-  # If `obj` is not an instance of String but responds to `to_str`, then the two
-  # strings are compared using `obj.==`.
-  #
-  # Otherwise, returns similarly to String#eql?, comparing length and content.
-  #
-  def ==: (untyped obj) -> bool
-
-  # Equality---Returns whether `str` == `obj`, similar to Object#==.
-  #
-  # If `obj` is not an instance of String but responds to `to_str`, then the two
-  # strings are compared using `obj.==`.
-  #
-  # Otherwise, returns similarly to String#eql?, comparing length and content.
-  #
-  def ===: (untyped obj) -> bool
-
-  # Match---If *obj* is a Regexp, uses it as a pattern to match against the
-  # receiver, and returns the position the match starts, or `nil` if there is no
-  # match. Otherwise, invokes *obj.=~*, passing the string as an argument. The
-  # default Object#=~ (deprecated) returns `nil`.
-  #
-  #     "cat o' 9 tails" =~ /\d/   #=> 7
-  #     "cat o' 9 tails" =~ 9      #=> nil
-  #
-  # Note that `string =~ regexp` is not the same as `regexp =~ string`. Strings
-  # captured from named capture groups are assigned to local variables only in the
-  # second case.
-  #
-  #     "no. 9" =~ /(?<number>\d+)/
-  #     number                        #=> nil (not assigned)
-  #     /(?<number>\d+)/ =~ "no. 9"
-  #     number                        #=> "9"
-  #
-  def =~: (untyped obj) -> Integer?
-
-  # Element Reference --- If passed a single `index`, returns a substring of one
-  # character at that index. If passed a `start` index and a `length`, returns a
-  # substring containing `length` characters starting at the `start` index. If
-  # passed a `range`, its beginning and end are interpreted as offsets delimiting
-  # the substring to be returned.
-  #
-  # In these three cases, if an index is negative, it is counted from the end of
-  # the string.  For the `start` and `range` cases the starting index is just
-  # before a character and an index matching the string's size. Additionally, an
-  # empty string is returned when the starting index for a character range is at
-  # the end of the string.
-  #
-  # Returns `nil` if the initial index falls outside the string or the length is
-  # negative.
-  #
-  # If a `Regexp` is supplied, the matching portion of the string is returned.  If
-  # a `capture` follows the regular expression, which may be a capture group index
-  # or name, follows the regular expression that component of the MatchData is
-  # returned instead.
-  #
-  # If a `match_str` is given, that string is returned if it occurs in the string.
-  #
-  # Returns `nil` if the regular expression does not match or the match string
-  # cannot be found.
-  #
-  #     a = "hello there"
-  #
-  #     a[1]                   #=> "e"
-  #     a[2, 3]                #=> "llo"
-  #     a[2..3]                #=> "ll"
-  #
-  #     a[-3, 2]               #=> "er"
-  #     a[7..-2]               #=> "her"
-  #     a[-4..-2]              #=> "her"
-  #     a[-2..-4]              #=> ""
-  #
-  #     a[11, 0]               #=> ""
-  #     a[11]                  #=> nil
-  #     a[12, 0]               #=> nil
-  #     a[12..-1]              #=> nil
-  #
-  #     a[/[aeiou](.)\1/]      #=> "ell"
-  #     a[/[aeiou](.)\1/, 0]   #=> "ell"
-  #     a[/[aeiou](.)\1/, 1]   #=> "l"
-  #     a[/[aeiou](.)\1/, 2]   #=> nil
-  #
-  #     a[/(?<vowel>[aeiou])(?<non_vowel>[^aeiou])/, "non_vowel"] #=> "l"
-  #     a[/(?<vowel>[aeiou])(?<non_vowel>[^aeiou])/, "vowel"]     #=> "e"
-  #
-  #     a["lo"]                #=> "lo"
-  #     a["bye"]               #=> nil
-  #
-  def []: (int index) -> String?
-        | (int start, int length) -> String?
-        | (Range[Integer] | Range[Integer?] range) -> String?
-        | (Regexp regexp) -> String?
-        | (Regexp regexp, int | String capture) -> String?
-        | (String match_str) -> String?
-
-  # Element Assignment---Replaces some or all of the content of *str*. The portion
-  # of the string affected is determined using the same criteria as String#[]. If
-  # the replacement string is not the same length as the text it is replacing, the
-  # string will be adjusted accordingly. If the regular expression or string is
-  # used as the index doesn't match a position in the string, IndexError is
-  # raised. If the regular expression form is used, the optional second Integer
-  # allows you to specify which portion of the match to replace (effectively using
-  # the MatchData indexing rules. The forms that take an Integer will raise an
-  # IndexError if the value is out of range; the Range form will raise a
-  # RangeError, and the Regexp and String will raise an IndexError on negative
-  # match.
-  #
-  def []=: (int pos, String new_str) -> String
-         | (int begin_pos, int end_pos, String new_str) -> String
-         | (Range[Integer] | Range[Integer?] range, String new_str) -> String
-         | (Regexp regexp, String new_str) -> String
-         | (Regexp regexp, int capture, String new_str) -> String
-         | (Regexp regexp, String name, String new_str) -> String
-         | (String other_str, String new_str) -> String
-
-  # Returns true for a string which has only ASCII characters.
-  #
-  #     "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[Integer]
-           | () { (Integer byte) -> void } -> String
-
-  # Returns the length of `str` in bytes.
-  #
-  #     "\x80\u3042".bytesize  #=> 4
-  #     "hello".bytesize       #=> 5
-  #
-  def bytesize: () -> Integer
-
-  # Byte Reference---If passed a single Integer, returns a substring of one byte
-  # at that position. If passed two Integer objects, returns a substring starting
-  # at the offset given by the first, and a length given by the second. If given a
-  # Range, a substring containing bytes at offsets given by the range is returned.
-  # In all three cases, if an offset is negative, it is counted from the end of
-  # *str*. Returns `nil` if the initial offset falls outside the string, the
-  # length is negative, or the beginning of the range is greater than the end. The
-  # encoding of the resulted string keeps original encoding.
-  #
-  #     "hello".byteslice(1)     #=> "e"
-  #     "hello".byteslice(-1)    #=> "o"
-  #     "hello".byteslice(1, 2)  #=> "el"
-  #     "\x80\u3042".byteslice(1, 3) #=> "\u3042"
-  #     "\x03\u3042\xff".byteslice(1..3) #=> "\u3042"
-  #
-  def byteslice: (int start, ?int length) -> String?
-               | (Range[Integer] | Range[Integer?] range) -> String?
-
-  # Returns a copy of *str* with the first character converted to uppercase and
-  # the remainder to lowercase.
-  #
-  # See String#downcase for meaning of `options` and use with different encodings.
-  #
-  #     "hello".capitalize    #=> "Hello"
-  #     "HELLO".capitalize    #=> "Hello"
-  #     "123ABC".capitalize   #=> "123abc"
-  #
-  def capitalize: () -> String
-                | (:ascii | :lithuanian | :turkic) -> String
-                | (:lithuanian, :turkic) -> String
-                | (:turkic, :lithuanian) -> 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 String#downcase, to avoid mixed case.
-  #
-  # See String#downcase for meaning of `options` and use with different encodings.
-  #
-  #     a = "hello"
-  #     a.capitalize!   #=> "Hello"
-  #     a               #=> "Hello"
-  #     a.capitalize!   #=> nil
-  #
-  def capitalize!: () -> String?
-                 | (:ascii | :lithuanian | :turkic) -> String?
-                 | (:lithuanian, :turkic) -> String?
-                 | (:turkic, :lithuanian) -> String?
-
-  # Case-insensitive version of String#<=>. Currently, case-insensitivity only
-  # works on characters A-Z/a-z, not all of Unicode. This is different from
-  # String#casecmp?.
-  #
-  #     "aBcDeF".casecmp("abcde")     #=> 1
-  #     "aBcDeF".casecmp("abcdef")    #=> 0
-  #     "aBcDeF".casecmp("abcdefg")   #=> -1
-  #     "abcdef".casecmp("ABCDEF")    #=> 0
-  #
-  # `nil` is returned if the two strings have incompatible encodings, or if
-  # `other_str` is not a string.
-  #
-  #     "foo".casecmp(2)   #=> nil
-  #     "\u{e4 f6 fc}".encode("ISO-8859-1").casecmp("\u{c4 d6 dc}")   #=> nil
-  #
-  def casecmp: (untyped other) -> Integer?
-
-  # Returns `true` if `str` and `other_str` 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 strings have incompatible encodings, or if
-  # `other_str` is not a string.
-  #
-  #     "foo".casecmp?(2)   #=> nil
-  #     "\u{e4 f6 fc}".encode("ISO-8859-1").casecmp?("\u{c4 d6 dc}")   #=> nil
-  #
-  def casecmp?: (untyped other) -> bool
-
-  # Centers `str` in `width`.  If `width` is greater than the length of `str`,
-  # returns a new String of length `width` with `str` centered and padded with
-  # `padstr`; otherwise, returns `str`.
-  #
-  #     "hello".center(4)         #=> "hello"
-  #     "hello".center(20)        #=> "       hello        "
-  #     "hello".center(20, '123') #=> "1231231hello12312312"
-  #
-  def center: (int width, ?string padstr) -> 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]
-           | () { (String char) -> void } -> String
-
-  # Returns a new String with the given record separator removed from the end of
-  # *str* (if present). If `$/` has not been changed from the default Ruby record
-  # separator, then `chomp` also removes carriage return characters (that is it
-  # will remove `\n`, `\r`, and `\r\n`). If `$/` is an empty string, it will
-  # remove all trailing newlines from the string.
-  #
-  #     "hello".chomp                #=> "hello"
-  #     "hello\n".chomp              #=> "hello"
-  #     "hello\r\n".chomp            #=> "hello"
-  #     "hello\n\r".chomp            #=> "hello\n"
-  #     "hello\r".chomp              #=> "hello"
-  #     "hello \n there".chomp       #=> "hello \n there"
-  #     "hello".chomp("llo")         #=> "he"
-  #     "hello\r\n\r\n".chomp('')    #=> "hello"
-  #     "hello\r\n\r\r\n".chomp('')  #=> "hello\r\n\r"
-  #
-  def chomp: (?string separator) -> String
-
-  # Modifies *str* in place as described for String#chomp, returning *str*, or
-  # `nil` if no modifications were made.
-  #
-  def chomp!: (?string separator) -> 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.
-  #
-  #     "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.
-  #
-  #     a = "abcde"
-  #     a.chr    #=> "a"
-  #
-  def chr: () -> String
-
-  # Makes string empty.
-  #
-  #     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]
-                | () { (Integer codepoint) -> void } -> String
-
-  # Concatenates the given object(s) to *str*. If an object is an Integer, it is
-  # considered a codepoint and converted to a character before concatenation.
-  #
-  # `concat` can take multiple arguments, and all the arguments are concatenated
-  # in order.
-  #
-  #     a = "hello "
-  #     a.concat("world", 33)      #=> "hello world!"
-  #     a                          #=> "hello world!"
-  #
-  #     b = "sn"
-  #     b.concat("_", b, "_", b)   #=> "sn_sn_sn"
-  #
-  # See also String#<<, which takes a single argument.
-  #
-  def concat: (*string | Integer str_or_codepoint) -> String
-
-  # Each `other_str` parameter defines a set of characters to count.  The
-  # intersection of these sets defines the characters to count in `str`.  Any
-  # `other_str` that starts with a caret `^` is negated.  The sequence `c1-c2`
-  # means all characters between c1 and c2.  The backslash character `\` can be
-  # used to escape `^` or `-` and is otherwise ignored unless it appears at the
-  # end of a sequence or the end of a `other_str`.
-  #
-  #     a = "hello world"
-  #     a.count "lo"                   #=> 5
-  #     a.count "lo", "o"              #=> 2
-  #     a.count "hello", "^l"          #=> 4
-  #     a.count "ej-m"                 #=> 4
-  #
-  #     "hello^world".count "\\^aeiou" #=> 4
-  #     "hello-world".count "a\\-eo"   #=> 4
-  #
-  #     c = "hello world\\r\\n"
-  #     c.count "\\"                   #=> 2
-  #     c.count "\\A"                  #=> 0
-  #     c.count "X-\\w"                #=> 3
-  #
-  def count: (string other_str, *string other_strs) -> Integer
-
-  # Returns the string generated by calling `crypt(3)` standard library function
-  # with `str` and `salt_str`, in this order, as its arguments.  Please do not use
-  # this method any longer.  It is legacy; provided only for backward
-  # compatibility with ruby scripts in earlier days.  It is bad to use in
-  # contemporary programs for several reasons:
-  #
-  # *   Behaviour of C's `crypt(3)` depends on the OS it is run.  The generated
-  #     string lacks data portability.
-  #
-  # *   On some OSes such as Mac OS, `crypt(3)` never fails (i.e. silently ends up
-  #     in unexpected results).
-  #
-  # *   On some OSes such as Mac OS, `crypt(3)` is not thread safe.
-  #
-  # *   So-called "traditional" usage of `crypt(3)` is very very very weak. 
-  #     According to its manpage, Linux's traditional `crypt(3)` output has only
-  #     2**56 variations; too easy to brute force today.  And this is the default
-  #     behaviour.
-  #
-  # *   In order to make things robust some OSes implement so-called "modular"
-  #     usage. To go through, you have to do a complex build-up of the `salt_str`
-  #     parameter, by hand. Failure in generation of a proper salt string tends
-  #     not to yield any errors; typos in parameters are normally not detectable.
-  #
-  #     *   For instance, in the following example, the second invocation of
-  #         String#crypt is wrong; it has a typo in "round=" (lacks "s").  However
-  #         the call does not fail and something unexpected is generated.
-  #
-  #             "foo".crypt("$5$rounds=1000$salt$") # OK, proper usage
-  #             "foo".crypt("$5$round=1000$salt$")  # Typo not detected
-  #
-  #
-  # *   Even in the "modular" mode, some hash functions are considered archaic and
-  #     no longer recommended at all; for instance module `$1$` is officially
-  #     abandoned by its author: see http://phk.freebsd.dk/sagas/md5crypt_eol.html
-  #     .  For another instance module `$3$` is considered completely broken: see
-  #     the manpage of FreeBSD.
-  #
-  # *   On some OS such as Mac OS, there is no modular mode. Yet, as written
-  #     above, `crypt(3)` on Mac OS never fails. This means even if you build up a
-  #     proper salt string it generates a traditional DES hash anyways, and there
-  #     is no way for you to be aware of.
-  #
-  #         "foo".crypt("$5$rounds=1000$salt$") # => "$5fNPQMxC5j6."
-  #
-  #
-  # If for some reason you cannot migrate to other secure contemporary password
-  # hashing algorithms, install the string-crypt gem and `require 'string/crypt'`
-  # to continue using it.
-  #
-  def crypt: (string salt_str) -> String
-
-  # Returns a copy of *str* with all characters in the intersection of its
-  # arguments deleted. Uses the same rules for building the set of characters as
-  # String#count.
-  #
-  #     "hello".delete "l","lo"        #=> "heo"
-  #     "hello".delete "lo"            #=> "he"
-  #     "hello".delete "aeiou", "^e"   #=> "hell"
-  #     "hello".delete "ej-m"          #=> "ho"
-  #
-  def delete: (string other_str, *string other_strs) -> String
-
-  # Performs a `delete` operation in place, returning *str*, or `nil` if *str* was
-  # not modified.
-  #
-  def delete!: (string other_str, *string other_strs) -> String?
-
-  # Returns a copy of *str* with leading `prefix` deleted.
-  #
-  #     "hello".delete_prefix("hel") #=> "lo"
-  #     "hello".delete_prefix("llo") #=> "hello"
-  #
-  def delete_prefix: (string prefix) -> String
-
-  # Deletes leading `prefix` from *str*, returning `nil` if no change was made.
-  #
-  #     "hello".delete_prefix!("hel") #=> "lo"
-  #     "hello".delete_prefix!("llo") #=> nil
-  #
-  def delete_prefix!: (string prefix) -> String?
-
-  # Returns a copy of *str* with trailing `suffix` deleted.
-  #
-  #     "hello".delete_suffix("llo") #=> "he"
-  #     "hello".delete_suffix("hel") #=> "hello"
-  #
-  def delete_suffix: (string suffix) -> String
-
-  # Deletes trailing `suffix` from *str*, returning `nil` if no change was made.
-  #
-  #     "hello".delete_suffix!("llo") #=> "he"
-  #     "hello".delete_suffix!("hel") #=> nil
-  #
-  def delete_suffix!: (string suffix) -> 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.
-  # String#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.
-  #
-  #     "hEllO".downcase   #=> "hello"
-  #
-  def downcase: () -> String
-              | (:ascii | :fold | :lithuanian | :turkic) -> String
-              | (:lithuanian, :turkic) -> String
-              | (:turkic, :lithuanian) -> String
-
-  # Downcases the contents of *str*, returning `nil` if no changes were made.
-  #
-  # See String#downcase for meaning of `options` and use with different encodings.
-  #
-  def downcase!: () -> String?
-               | (:ascii | :fold | :lithuanian | :turkic) -> String?
-               | (:lithuanian, :turkic) -> String?
-               | (:turkic, :lithuanian) -> String?
-
-  # Returns a quoted version of the string with all non-printing characters
-  # replaced by `\xHH` notation and all special characters escaped.
-  #
-  # This method can be used for round-trip: if the resulting `new_str` is eval'ed,
-  # it will produce the original string.
-  #
-  #     "hello \n ''".dump     #=> "\"hello \\n ''\""
-  #     "\f\x00\xff\\\"".dump  #=> "\"\\f\\x00\\xFF\\\\\\\"\""
-  #
-  # See also String#undump.
-  #
-  def dump: () -> String
-
-  # Passes each byte in *str* to the given block, or returns an enumerator if no
-  # block is given.
-  #
-  #     "hello".each_byte {|c| print c, ' ' }
-  #
-  # *produces:*
-  #
-  #     104 101 108 108 111
-  #
-  def each_byte: () { (Integer byte) -> void } -> self
-               | () -> ::Enumerator[Integer, self]
-
-  # Passes each character in *str* to the given block, or returns an enumerator if
-  # no block is given.
-  #
-  #     "hello".each_char {|c| print c, ' ' }
-  #
-  # *produces:*
-  #
-  #     h e l l o
-  #
-  def each_char: () { (String char) -> void } -> self
-               | () -> ::Enumerator[String, self]
-
-  # Passes the Integer ordinal of each character in *str*, also known as a
-  # *codepoint* when applied to Unicode strings to the given block.  For encodings
-  # other than UTF-8/UTF-16(BE|LE)/UTF-32(BE|LE), values are directly derived from
-  # the binary representation of each character.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  #     "hello\u0639".each_codepoint {|c| print c, ' ' }
-  #
-  # *produces:*
-  #
-  #     104 101 108 108 111 1593
-  #
-  def each_codepoint: () { (Integer codepoint) -> void } -> self
-                    | () -> ::Enumerator[Integer, self]
-
-  # Passes each grapheme cluster in *str* to the given block, or returns an
-  # enumerator if no block is given. Unlike String#each_char, this enumerates by
-  # grapheme clusters defined by Unicode Standard Annex #29
-  # http://unicode.org/reports/tr29/
-  #
-  #     "a\u0300".each_char.to_a.size #=> 2
-  #     "a\u0300".each_grapheme_cluster.to_a.size #=> 1
-  #
-  def each_grapheme_cluster: () { (String grapheme) -> void } -> self
-                           | () -> ::Enumerator[String, self]
-
-  # Splits *str* using the supplied parameter as the record separator (`$/` by
-  # default), passing each substring in turn to the supplied block.  If a
-  # zero-length record separator is supplied, the string is split into paragraphs
-  # delimited by multiple successive newlines.
-  #
-  # If `chomp` is `true`, `separator` will be removed from the end of each line.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  #     "hello\nworld".each_line {|s| p s}
-  #     # prints:
-  #     #   "hello\n"
-  #     #   "world"
-  #
-  #     "hello\nworld".each_line('l') {|s| p s}
-  #     # prints:
-  #     #   "hel"
-  #     #   "l"
-  #     #   "o\nworl"
-  #     #   "d"
-  #
-  #     "hello\n\n\nworld".each_line('') {|s| p s}
-  #     # prints
-  #     #   "hello\n\n"
-  #     #   "world"
-  #
-  #     "hello\nworld".each_line(chomp: true) {|s| p s}
-  #     # prints:
-  #     #   "hello"
-  #     #   "world"
-  #
-  #     "hello\nworld".each_line('l', chomp: true) {|s| p s}
-  #     # prints:
-  #     #   "he"
-  #     #   ""
-  #     #   "o\nwor"
-  #     #   "d"
-  #
-  def each_line: (?string separator, ?chomp: bool) { (String line) -> void } -> self
-               | (?string separator, ?chomp: bool) -> Enumerator[String, self]
-
-  # Returns `true` if *str* has a length of zero.
-  #
-  #     "hello".empty?   #=> false
-  #     " ".empty?       #=> false
-  #     "".empty?        #=> true
-  #
-  def empty?: () -> bool
-
-  # The first form returns a copy of `str` transcoded to encoding `encoding`. The
-  # second form returns a copy of `str` transcoded from src_encoding to
-  # dst_encoding. The last form returns a copy of `str` transcoded to
-  # `Encoding.default_internal`.
-  #
-  # By default, the first and second form raise Encoding::UndefinedConversionError
-  # for characters that are undefined in the destination encoding, and
-  # Encoding::InvalidByteSequenceError for invalid byte sequences in the source
-  # encoding. The last form by default does not raise exceptions but uses
-  # replacement strings.
-  #
-  # The `options` Hash gives details for conversion and can have the following
-  # keys:
-  #
-  # :invalid
-  # :   If the value is `:replace`, #encode replaces invalid byte sequences in
-  #     `str` with the replacement character.  The default is to raise the
-  #     Encoding::InvalidByteSequenceError exception
-  # :undef
-  # :   If the value is `:replace`, #encode replaces characters which are
-  #     undefined in the destination encoding with the replacement character. The
-  #     default is to raise the Encoding::UndefinedConversionError.
-  # :replace
-  # :   Sets the replacement string to the given value. The default replacement
-  #     string is "uFFFD" for Unicode encoding forms, and "?" otherwise.
-  # :fallback
-  # :   Sets the replacement string by the given object for undefined character. 
-  #     The object should be a Hash, a Proc, a Method, or an object which has []
-  #     method. Its key is an undefined character encoded in the source encoding
-  #     of current transcoder. Its value can be any encoding until it can be
-  #     converted into the destination encoding of the transcoder.
-  # :xml
-  # :   The value must be `:text` or `:attr`. If the value is `:text` #encode
-  #     replaces undefined characters with their (upper-case hexadecimal) numeric
-  #     character references. '&', '<', and '>' are converted to "&amp;", "&lt;",
-  #     and "&gt;", respectively. If the value is `:attr`, #encode also quotes the
-  #     replacement result (using '"'), and replaces '"' with "&quot;".
-  # :cr_newline
-  # :   Replaces LF ("n") with CR ("r") if value is true.
-  # :crlf_newline
-  # :   Replaces LF ("n") with CRLF ("r\n") if value is true.
-  # :universal_newline
-  # :   Replaces CRLF ("r\n") and CR ("r") with LF ("n") if value is true.
-  #
-  #
-  def encode: (?Encoding | string encoding, ?Encoding | string from_encoding, ?invalid: :replace ?, ?undef: :replace ?, ?replace: String, ?fallback: String::encode_fallback, ?xml: :text | :attr, ?universal_newline: true, ?cr_newline: true, ?crlf_newline: true) -> String
-
-  # The first form transcodes the contents of *str* from str.encoding to
-  # `encoding`. The second form transcodes the contents of *str* from src_encoding
-  # to dst_encoding. The options Hash gives details for conversion. See
-  # String#encode for details. Returns the string even if no changes were made.
-  #
-  def encode!: (?Encoding | string encoding, ?Encoding | string from_encoding, ?invalid: :replace ?, ?undef: :replace ?, ?replace: String, ?fallback: String::encode_fallback, ?xml: :text | :attr, ?universal_newline: true, ?cr_newline: true, ?crlf_newline: true) -> self
-
-  # Returns the Encoding object that represents the encoding of obj.
-  #
-  def encoding: () -> Encoding
-
-  # Returns true if `str` 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 suffixes) -> bool
-
-  # Two strings are equal if they have the same length and content.
-  #
-  def eql?: (untyped other) -> bool
-
-  # Changes the encoding to `encoding` and returns self.
-  #
-  def force_encoding: (string | Encoding encoding) -> self
-
-  def freeze: () -> self
-
-  # returns the *index*th byte as an integer.
-  #
-  def getbyte: (int index) -> Integer?
-
-  # Returns an array of grapheme clusters in *str*.  This is a shorthand for
-  # `str.each_grapheme_cluster.to_a`.
-  #
-  # If a block is given, which is a deprecated form, works the same as
-  # `each_grapheme_cluster`.
-  #
-  def grapheme_clusters: () -> ::Array[::String]
-
-  # Returns a copy of *str* with *all* occurrences of *pattern* substituted for
-  # the second argument. The *pattern* is typically a Regexp; if given as a
-  # String, any regular expression metacharacters it contains will be interpreted
-  # literally, e.g. `\d` will match a backslash followed by 'd', instead of a
-  # digit.
-  #
-  # If `replacement` is a String it will be substituted for the matched text. It
-  # may contain back-references to the pattern's capture groups of the form `\d`,
-  # where *d* is a group number, or `\k<n>`, where *n* is a group name. Similarly,
-  # `\&`, `\'`, `\``, and `+` correspond to special variables, `$&`, `$'`, `$``,
-  # and `$+`, respectively. (See regexp.rdoc for details.) `\0` is the same as
-  # `\&`. `\\\` is interpreted as an escape, i.e., a single backslash. Note that,
-  # within `replacement` the special match variables, such as `$&`, will not refer
-  # to the current match.
-  #
-  # If the second argument is a Hash, and the matched text is one of its keys, the
-  # corresponding value is the replacement string.
-  #
-  # In the block form, the current match string is passed in as a parameter, and
-  # variables such as `$1`, `$2`, `$``, `$&`, and `$'` will be set appropriately.
-  # (See regexp.rdoc for details.) The value returned by the block will be
-  # substituted for the match on each call.
-  #
-  # When neither a block nor a second argument is supplied, an Enumerator is
-  # returned.
-  #
-  #     "hello".gsub(/[aeiou]/, '*')                  #=> "h*ll*"
-  #     "hello".gsub(/([aeiou])/, '<\1>')             #=> "h<e>ll<o>"
-  #     "hello".gsub(/./) {|s| s.ord.to_s + ' '}      #=> "104 101 108 108 111 "
-  #     "hello".gsub(/(?<foo>[aeiou])/, '{\k<foo>}')  #=> "h{e}ll{o}"
-  #     'hello'.gsub(/[eo]/, 'e' => 3, 'o' => '*')    #=> "h3ll*"
-  #
-  # Note that a string literal consumes backslashes. (See syntax/literals.rdoc for
-  # details on string literals.) Back-references are typically preceded by an
-  # additional backslash. For example, if you want to write a back-reference `\&`
-  # in `replacement` with a double-quoted string literal, you need to write:
-  # `"..\\\\&.."`. If you want to write a non-back-reference string `\&` in
-  # `replacement`, you need first to escape the backslash to prevent this method
-  # from interpreting it as a back-reference, and then you need to escape the
-  # backslashes again to prevent a string literal from consuming them:
-  # `"..\\\\\\\\&.."`. You may want to use the block form to avoid a lot of
-  # backslashes.
-  #
-  def gsub: (Regexp | string pattern, string replacement) -> String
-          | (Regexp | string pattern, Hash[String, String] hash) -> String
-          | (Regexp | string pattern) { (String match) -> _ToS } -> String
-          | (Regexp | string pattern) -> ::Enumerator[String, self]
-
-  # Performs the substitutions of String#gsub in place, returning *str*, or `nil`
-  # if no substitutions were performed.  If no block and no *replacement* is
-  # given, an enumerator is returned instead.
-  #
-  def gsub!: (Regexp | string pattern, string replacement) -> String?
-           | (Regexp | string pattern, Hash[String, String] hash) -> String?
-           | (Regexp | string pattern) { (String match) -> _ToS } -> String?
-           | (Regexp | string pattern) -> ::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.
-  #
-  #     "0x0a".hex     #=> 10
-  #     "-1234".hex    #=> -4660
-  #     "0".hex        #=> 0
-  #     "wombat".hex   #=> 0
-  #
-  def hex: () -> Integer
-
-  # Returns `true` if *str* contains the given string or character.
-  #
-  #     "hello".include? "lo"   #=> true
-  #     "hello".include? "ol"   #=> false
-  #     "hello".include? ?h     #=> true
-  #
-  def include?: (string other_str) -> bool
-
-  # Returns the index of the first occurrence of the given *substring* or pattern
-  # (*regexp*) in *str*. Returns `nil` if not found. If the second parameter is
-  # present, it specifies the position in the string to begin the search.
-  #
-  #     "hello".index('e')             #=> 1
-  #     "hello".index('lo')            #=> 3
-  #     "hello".index('a')             #=> nil
-  #     "hello".index(?e)              #=> 1
-  #     "hello".index(/[aeiou]/, -3)   #=> 4
-  #
-  def index: (Regexp | string substr_or_regexp, ?int offset) -> Integer?
-
-  # Inserts *other_str* before the character at the given *index*, modifying
-  # *str*. Negative indices count from the end of the string, and insert *after*
-  # the given character. The intent is insert *aString* so that it starts at the
-  # given *index*.
-  #
-  #     "abcd".insert(0, 'X')    #=> "Xabcd"
-  #     "abcd".insert(3, 'X')    #=> "abcXd"
-  #     "abcd".insert(4, 'X')    #=> "abcdX"
-  #     "abcd".insert(-3, 'X')   #=> "abXcd"
-  #     "abcd".insert(-1, 'X')   #=> "abcdX"
-  #
-  def insert: (int index, string other_str) -> String
-
-  # Returns a printable version of *str*, surrounded by quote marks, with special
-  # characters escaped.
-  #
-  #     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.
-  #
-  #     "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.
-  #
-  #     'cat and dog'.to_sym   #=> :"cat and dog"
-  #
-  def intern: () -> Symbol
-
-  # Returns the character length of *str*.
-  #
-  def length: () -> Integer
-
-  # Returns an array of lines in *str* split using the supplied record separator
-  # (`$/` by default).  This is a shorthand for `str.each_line(separator,
-  # getline_args).to_a`.
-  #
-  # If `chomp` is `true`, `separator` will be removed from the end of each line.
-  #
-  #     "hello\nworld\n".lines              #=> ["hello\n", "world\n"]
-  #     "hello  world".lines(' ')           #=> ["hello ", " ", "world"]
-  #     "hello\nworld\n".lines(chomp: true) #=> ["hello", "world"]
-  #
-  # If a block is given, which is a deprecated form, works the same as
-  # `each_line`.
-  #
-  def lines: (?string separator, ?chomp: bool) -> Array[String]
-
-  # If *integer* is greater than the length of *str*, returns a new String of
-  # length *integer* with *str* left justified and padded with *padstr*;
-  # otherwise, returns *str*.
-  #
-  #     "hello".ljust(4)            #=> "hello"
-  #     "hello".ljust(20)           #=> "hello               "
-  #     "hello".ljust(20, '1234')   #=> "hello123412341234123"
-  #
-  def ljust: (int integer, ?string padstr) -> String
-
-  # Returns a copy of the receiver with leading whitespace removed. See also
-  # String#rstrip and String#strip.
-  #
-  # Refer to String#strip for the definition of whitespace.
-  #
-  #     "  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 String#rstrip! and String#strip!.
-  #
-  # Refer to String#strip for the definition of whitespace.
-  #
-  #     "  hello  ".lstrip!  #=> "hello  "
-  #     "hello  ".lstrip!    #=> nil
-  #     "hello".lstrip!      #=> nil
-  #
-  def lstrip!: () -> self?
-
-  # Converts *pattern* to a Regexp (if it isn't already one), then invokes its
-  # `match` method on the receiver. If the second parameter is present, it
-  # specifies the position in the string to begin the search.
-  #
-  #     'hello'.match('(.)\1')      #=> #<MatchData "ll" 1:"l">
-  #     'hello'.match('(.)\1')[0]   #=> "ll"
-  #     'hello'.match(/(.)\1/)[0]   #=> "ll"
-  #     'hello'.match(/(.)\1/, 3)   #=> nil
-  #     'hello'.match('xx')         #=> nil
-  #
-  # If a block is given, invokes the block with MatchData if match succeeds, so
-  # that you can write
-  #
-  #     str.match(pat) {|m| block }
-  #
-  # instead of
-  #
-  #     if m = str.match(pat)
-  #       # ...
-  #     end
-  #
-  # The return value in this case is the value from block execution.
-  #
-  def match: (Regexp | string pattern, ?int pos) -> MatchData?
-           | [A] (Regexp | string pattern, ?int pos) { (MatchData) -> A } -> A
-
-  # Converts *pattern* to a `Regexp` (if it isn't already one), then returns a
-  # `true` or `false` indicates whether the regexp is matched *str* or not without
-  # updating `$~` and other related variables.  If the second parameter is
-  # present, it specifies the position in the string to begin the search.
-  #
-  #     "Ruby".match?(/R.../)    #=> true
-  #     "Ruby".match?(/R.../, 1) #=> false
-  #     "Ruby".match?(/P.../)    #=> false
-  #     $&                       #=> nil
-  #
-  def match?: (Regexp | string pattern, ?int pos) -> 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.
-  #
-  #     "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!: () -> self
-
-  # 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.
-  #
-  #     "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.
-  #
-  #     "a".ord         #=> 97
-  #
-  def ord: () -> Integer
-
-  # Searches *sep* or pattern (*regexp*) in the string and returns the part before
-  # it, the match, and the part after it. If it is not found, returns two empty
-  # strings and *str*.
-  #
-  #     "hello".partition("l")         #=> ["he", "l", "lo"]
-  #     "hello".partition("x")         #=> ["hello", "", ""]
-  #     "hello".partition(/.l/)        #=> ["h", "el", "lo"]
-  #
-  def partition: (Regexp | string sep_or_regexp) -> [ String, String, String ]
-
-  # Prepend---Prepend the given strings to *str*.
-  #
-  #     a = "!"
-  #     a.prepend("hello ", "world") #=> "hello world!"
-  #     a                            #=> "hello world!"
-  #
-  # See also String#concat.
-  #
-  def prepend: (*string other_strs) -> String
-
-  # Replaces the contents of *str* with the corresponding values in *other_str*.
-  #
-  #     s = "hello"         #=> "hello"
-  #     s.replace "world"   #=> "world"
-  #
-  def replace: (string other_str) -> String
-
-  # Returns a new string with the characters from *str* in reverse order.
-  #
-  #     "stressed".reverse   #=> "desserts"
-  #
-  def reverse: () -> String
-
-  # Reverses *str* in place.
-  #
-  def reverse!: () -> self
-
-  # Returns the index of the last occurrence of the given *substring* or pattern
-  # (*regexp*) in *str*. Returns `nil` if not found. If the second parameter is
-  # present, it specifies the position in the string to end the
-  # search---characters beyond this point will not be considered.
-  #
-  #     "hello".rindex('e')             #=> 1
-  #     "hello".rindex('l')             #=> 3
-  #     "hello".rindex('a')             #=> nil
-  #     "hello".rindex(?e)              #=> 1
-  #     "hello".rindex(/[aeiou]/, -2)   #=> 1
-  #
-  def rindex: (string | Regexp substr_or_regexp, ?int pos) -> Integer?
-
-  # If *integer* is greater than the length of *str*, returns a new String of
-  # length *integer* with *str* right justified and padded with *padstr*;
-  # otherwise, returns *str*.
-  #
-  #     "hello".rjust(4)            #=> "hello"
-  #     "hello".rjust(20)           #=> "               hello"
-  #     "hello".rjust(20, '1234')   #=> "123412341234123hello"
-  #
-  def rjust: (int integer, ?string padstr) -> String
-
-  # Searches *sep* or pattern (*regexp*) in the string from the end of the string,
-  # and returns the part before it, the match, and the part after it. If it is not
-  # found, returns two empty strings and *str*.
-  #
-  #     "hello".rpartition("l")         #=> ["hel", "l", "o"]
-  #     "hello".rpartition("x")         #=> ["", "", "hello"]
-  #     "hello".rpartition(/.l/)        #=> ["he", "ll", "o"]
-  #
-  def rpartition: (string | Regexp sep_or_regexp) -> [ String, String, String ]
-
-  # Returns a copy of the receiver with trailing whitespace removed. See also
-  # String#lstrip and String#strip.
-  #
-  # Refer to String#strip for the definition of whitespace.
-  #
-  #     "  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 String#lstrip! and String#strip!.
-  #
-  # Refer to String#strip for the definition of whitespace.
-  #
-  #     "  hello  ".rstrip!  #=> "  hello"
-  #     "  hello".rstrip!    #=> nil
-  #     "hello".rstrip!      #=> nil
-  #
-  def rstrip!: () -> self?
-
-  # Both forms iterate through *str*, matching the pattern (which may be a Regexp
-  # or a String). For each match, a result is generated and either added to the
-  # result array or passed to the block. If the pattern contains no groups, each
-  # individual result consists of the matched string, `$&`.  If the pattern
-  # contains groups, each individual result is itself an array containing one
-  # entry per group.
-  #
-  #     a = "cruel world"
-  #     a.scan(/\w+/)        #=> ["cruel", "world"]
-  #     a.scan(/.../)        #=> ["cru", "el ", "wor"]
-  #     a.scan(/(...)/)      #=> [["cru"], ["el "], ["wor"]]
-  #     a.scan(/(..)(..)/)   #=> [["cr", "ue"], ["l ", "wo"]]
-  #
-  # And the block form:
-  #
-  #     a.scan(/\w+/) {|w| print "<<#{w}>> " }
-  #     print "\n"
-  #     a.scan(/(.)(.)/) {|x,y| print y, x }
-  #     print "\n"
-  #
-  # *produces:*
-  #
-  #     <<cruel>> <<world>>
-  #     rceu lowlr
-  #
-  def scan: (Regexp | string pattern) -> Array[String | Array[String]]
-          | (Regexp | string pattern) { (String | Array[String]) -> void } -> self
-
-  # If the string is invalid byte sequence then replace invalid bytes with given
-  # replacement character, else returns self. If block is given, replace invalid
-  # bytes with returned value of the block.
-  #
-  #     "abc\u3042\x81".scrub #=> "abc\u3042\uFFFD"
-  #     "abc\u3042\x81".scrub("*") #=> "abc\u3042*"
-  #     "abc\u3042\xE3\x80".scrub{|bytes| '<'+bytes.unpack('H*')[0]+'>' } #=> "abc\u3042<e380>"
-  #
-  def scrub: (?string repl) -> String
-           | () { (String bytes) -> string } -> String
-
-  # If the string is invalid byte sequence then replace invalid bytes with given
-  # replacement character, else returns self. If block is given, replace invalid
-  # bytes with returned value of the block.
-  #
-  #     "abc\u3042\x81".scrub! #=> "abc\u3042\uFFFD"
-  #     "abc\u3042\x81".scrub!("*") #=> "abc\u3042*"
-  #     "abc\u3042\xE3\x80".scrub!{|bytes| '<'+bytes.unpack('H*')[0]+'>' } #=> "abc\u3042<e380>"
-  #
-  def scrub!: (?string repl) -> self
-            | () { (String bytes) -> string } -> self
-
-  # modifies the *index*th byte as *integer*.
-  #
-  def setbyte: (int index, int integer) -> int
-
-  # Returns the character length of *str*.
-  #
-  alias size length
-
-  # Element Reference --- If passed a single `index`, returns a substring of one
-  # character at that index. If passed a `start` index and a `length`, returns a
-  # substring containing `length` characters starting at the `start` index. If
-  # passed a `range`, its beginning and end are interpreted as offsets delimiting
-  # the substring to be returned.
-  #
-  # In these three cases, if an index is negative, it is counted from the end of
-  # the string.  For the `start` and `range` cases the starting index is just
-  # before a character and an index matching the string's size. Additionally, an
-  # empty string is returned when the starting index for a character range is at
-  # the end of the string.
-  #
-  # Returns `nil` if the initial index falls outside the string or the length is
-  # negative.
-  #
-  # If a `Regexp` is supplied, the matching portion of the string is returned.  If
-  # a `capture` follows the regular expression, which may be a capture group index
-  # or name, follows the regular expression that component of the MatchData is
-  # returned instead.
-  #
-  # If a `match_str` is given, that string is returned if it occurs in the string.
-  #
-  # Returns `nil` if the regular expression does not match or the match string
-  # cannot be found.
-  #
-  #     a = "hello there"
-  #
-  #     a[1]                   #=> "e"
-  #     a[2, 3]                #=> "llo"
-  #     a[2..3]                #=> "ll"
-  #
-  #     a[-3, 2]               #=> "er"
-  #     a[7..-2]               #=> "her"
-  #     a[-4..-2]              #=> "her"
-  #     a[-2..-4]              #=> ""
-  #
-  #     a[11, 0]               #=> ""
-  #     a[11]                  #=> nil
-  #     a[12, 0]               #=> nil
-  #     a[12..-1]              #=> nil
-  #
-  #     a[/[aeiou](.)\1/]      #=> "ell"
-  #     a[/[aeiou](.)\1/, 0]   #=> "ell"
-  #     a[/[aeiou](.)\1/, 1]   #=> "l"
-  #     a[/[aeiou](.)\1/, 2]   #=> nil
-  #
-  #     a[/(?<vowel>[aeiou])(?<non_vowel>[^aeiou])/, "non_vowel"] #=> "l"
-  #     a[/(?<vowel>[aeiou])(?<non_vowel>[^aeiou])/, "vowel"]     #=> "e"
-  #
-  #     a["lo"]                #=> "lo"
-  #     a["bye"]               #=> nil
-  #
-  alias slice []
-
-  # Deletes the specified portion from *str*, and returns the portion deleted.
-  #
-  #     string = "this is a string"
-  #     string.slice!(2)        #=> "i"
-  #     string.slice!(3..6)     #=> " is "
-  #     string.slice!(/s.*t/)   #=> "sa st"
-  #     string.slice!("r")      #=> "r"
-  #     string                  #=> "thing"
-  #
-  def slice!: (int integer, ?int integer) -> String?
-            | (Range[Integer] | Range[Integer?] range) -> String?
-            | (Regexp regexp, ?int | String capture) -> String?
-            | (String other_str) -> String?
-
-  # Divides *str* into substrings based on a delimiter, returning an array of
-  # these substrings.
-  #
-  # If *pattern* is a String, then its contents are used as the delimiter when
-  # splitting *str*. If *pattern* is a single space, *str* is split on whitespace,
-  # with leading and trailing whitespace and runs of contiguous whitespace
-  # characters ignored.
-  #
-  # If *pattern* is a Regexp, *str* is divided where the pattern matches. Whenever
-  # the pattern matches a zero-length string, *str* is split into individual
-  # characters. If *pattern* contains groups, the respective matches will be
-  # returned in the array as well.
-  #
-  # If *pattern* is `nil`, the value of `$;` is used. If `$;` is `nil` (which is
-  # the default), *str* is split on whitespace as if ' ' were specified.
-  #
-  # If the *limit* parameter is omitted, trailing null fields are suppressed. If
-  # *limit* is a positive number, at most that number of split substrings will be
-  # returned (captured groups will be returned as well, but are not counted
-  # towards the limit). If *limit* is `1`, the entire string is returned as the
-  # only entry in an array. If negative, there is no limit to the number of fields
-  # returned, and trailing null fields are not suppressed.
-  #
-  # When the input `str` is empty an empty Array is returned as the string is
-  # considered to have no fields to split.
-  #
-  #     " now's  the time ".split       #=> ["now's", "the", "time"]
-  #     " now's  the time ".split(' ')  #=> ["now's", "the", "time"]
-  #     " now's  the time".split(/ /)   #=> ["", "now's", "", "the", "time"]
-  #     "1, 2.34,56, 7".split(%r{,\s*}) #=> ["1", "2.34", "56", "7"]
-  #     "hello".split(//)               #=> ["h", "e", "l", "l", "o"]
-  #     "hello".split(//, 3)            #=> ["h", "e", "llo"]
-  #     "hi mom".split(%r{\s*})         #=> ["h", "i", "m", "o", "m"]
-  #
-  #     "mellow yellow".split("ello")   #=> ["m", "w y", "w"]
-  #     "1,2,,3,4,,".split(',')         #=> ["1", "2", "", "3", "4"]
-  #     "1,2,,3,4,,".split(',', 4)      #=> ["1", "2", "", "3,4,,"]
-  #     "1,2,,3,4,,".split(',', -4)     #=> ["1", "2", "", "3", "4", "", ""]
-  #
-  #     "1:2:3".split(/(:)()()/, 2)     #=> ["1", ":", "", "", "2:3"]
-  #
-  #     "".split(',', -1)               #=> []
-  #
-  # If a block is given, invoke the block with each split substring.
-  #
-  def split: (?Regexp | string pattern, ?int limit) -> Array[String]
-           | (?Regexp | string pattern, ?int limit) { (String) -> void } -> self
-
-  # Builds a set of characters from the *other_str* parameter(s) using the
-  # procedure described for String#count. Returns a new string where runs of the
-  # same character that occur in this set are replaced by a single character. If
-  # no arguments are given, all runs of identical characters are replaced by a
-  # single character.
-  #
-  #     "yellow moon".squeeze                  #=> "yelow mon"
-  #     "  now   is  the".squeeze(" ")         #=> " now is the"
-  #     "putters shoot balls".squeeze("m-z")   #=> "puters shot balls"
-  #
-  def squeeze: (*string other_str) -> String
-
-  # Squeezes *str* in place, returning either *str*, or `nil` if no changes were
-  # made.
-  #
-  def squeeze!: (*string other_str) -> self?
-
-  # Returns true if `str` 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 prefixes) -> 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.
-  #
-  #     "    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 String#strip for the definition of whitespace.
-  #
-  #     "  hello  ".strip!  #=> "hello"
-  #     "hello".strip!      #=> nil
-  #
-  def strip!: () -> self?
-
-  # Returns a copy of `str` with the *first* occurrence of `pattern` replaced by
-  # the second argument. The `pattern` is typically a Regexp; if given as a
-  # String, any regular expression metacharacters it contains will be interpreted
-  # literally, e.g. `\d` will match a backslash followed by 'd', instead of a
-  # digit.
-  #
-  # If `replacement` is a String it will be substituted for the matched text. It
-  # may contain back-references to the pattern's capture groups of the form `\d`,
-  # where *d* is a group number, or `\k<n>`, where *n* is a group name. Similarly,
-  # `\&`, `\'`, `\``, and `+` correspond to special variables, `$&`, `$'`, `$``,
-  # and `$+`, respectively. (See regexp.rdoc for details.) `\0` is the same as
-  # `\&`. `\\\` is interpreted as an escape, i.e., a single backslash. Note that,
-  # within `replacement` the special match variables, such as `$&`, will not refer
-  # to the current match.
-  #
-  # If the second argument is a Hash, and the matched text is one of its keys, the
-  # corresponding value is the replacement string.
-  #
-  # In the block form, the current match string is passed in as a parameter, and
-  # variables such as `$1`, `$2`, `$``, `$&`, and `$'` will be set appropriately.
-  # (See regexp.rdoc for details.) The value returned by the block will be
-  # substituted for the match on each call.
-  #
-  #     "hello".sub(/[aeiou]/, '*')                  #=> "h*llo"
-  #     "hello".sub(/([aeiou])/, '<\1>')             #=> "h<e>llo"
-  #     "hello".sub(/./) {|s| s.ord.to_s + ' ' }     #=> "104 ello"
-  #     "hello".sub(/(?<foo>[aeiou])/, '*\k<foo>*')  #=> "h*e*llo"
-  #     'Is SHELL your preferred shell?'.sub(/[[:upper:]]{2,}/, ENV)
-  #      #=> "Is /bin/bash your preferred shell?"
-  #
-  # Note that a string literal consumes backslashes. (See syntax/literals.rdoc for
-  # details about string literals.) Back-references are typically preceded by an
-  # additional backslash. For example, if you want to write a back-reference `\&`
-  # in `replacement` with a double-quoted string literal, you need to write:
-  # `"..\\\\&.."`. If you want to write a non-back-reference string `\&` in
-  # `replacement`, you need first to escape the backslash to prevent this method
-  # from interpreting it as a back-reference, and then you need to escape the
-  # backslashes again to prevent a string literal from consuming them:
-  # `"..\\\\\\\\&.."`. You may want to use the block form to avoid a lot of
-  # backslashes.
-  #
-  def sub: (Regexp | string pattern, string | Hash[String, String] replacement) -> String
-         | (Regexp | string pattern) { (String match) -> _ToS } -> String
-
-  # Performs the same substitution as String#sub in-place.
-  #
-  # Returns `str` if a substitution was performed or `nil` if no substitution was
-  # performed.
-  #
-  def sub!: (Regexp | string pattern, string | Hash[String, String] replacement) -> self?
-          | (Regexp | string pattern) { (String match) -> _ToS } -> 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.
-  #
-  #     "abcd".succ        #=> "abce"
-  #     "THX1138".succ     #=> "THX1139"
-  #     "<<koala>>".succ   #=> "<<koalb>>"
-  #     "1999zzz".succ     #=> "2000aaa"
-  #     "ZZZ9999".succ     #=> "AAAA0000"
-  #     "***".succ         #=> "**+"
-  #
-  def succ: () -> String
-
-  # Equivalent to String#succ, but modifies the receiver in place.
-  #
-  def succ!: () -> String
-
-  # Returns a basic *n*-bit checksum of the characters in *str*, where *n* is the
-  # optional Integer parameter, defaulting to 16. The result is simply the sum of
-  # the binary value of each byte in *str* modulo `2**n - 1`. This is not a
-  # particularly good checksum.
-  #
-  def sum: (?int n) -> Integer
-
-  # Returns a copy of *str* with uppercase alphabetic characters converted to
-  # lowercase and lowercase characters converted to uppercase.
-  #
-  # See String#downcase for meaning of `options` and use with different encodings.
-  #
-  #     "Hello".swapcase          #=> "hELLO"
-  #     "cYbEr_PuNk11".swapcase   #=> "CyBeR_pUnK11"
-  #
-  def swapcase: () -> String
-              | (:ascii | :lithuanian | :turkic) -> String
-              | (:lithuanian, :turkic) -> String
-              | (:turkic, :lithuanian) -> String
-
-  # Equivalent to String#swapcase, but modifies the receiver in place, returning
-  # *str*, or `nil` if no changes were made.
-  #
-  # See String#downcase for meaning of `options` and use with different encodings.
-  #
-  def swapcase!: () -> self?
-               | (:ascii | :lithuanian | :turkic) -> self?
-               | (:lithuanian, :turkic) -> self?
-               | (:turkic, :lithuanian) -> self?
-
-  # 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.
-  #
-  #     '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.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.
-  #
-  #     "123.45e1".to_f        #=> 1234.5
-  #     "45.67 degrees".to_f   #=> 45.67
-  #     "thx1138".to_f         #=> 0.0
-  #
-  def to_f: () -> Float
-
-  # Returns the result of interpreting leading characters in *str* as an integer
-  # base *base* (between 2 and 36). Extraneous characters past the end of a valid
-  # number are ignored. If there is not a valid number at the start of *str*, `0`
-  # is returned. This method never raises an exception when *base* is valid.
-  #
-  #     "12345".to_i             #=> 12345
-  #     "99 red balloons".to_i   #=> 99
-  #     "0a".to_i                #=> 0
-  #     "0a".to_i(16)            #=> 10
-  #     "hello".to_i             #=> 0
-  #     "1100101".to_i(2)        #=> 101
-  #     "1100101".to_i(8)        #=> 294977
-  #     "1100101".to_i(10)       #=> 1100101
-  #     "1100101".to_i(16)       #=> 17826049
-  #
-  def to_i: (?int base) -> 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.
-  #
-  #     '  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, converts the receiver to a String object.
-  #
-  def to_s: () -> String
-
-  # Returns `self`.
-  #
-  # If called on a subclass of String, converts the receiver to a String object.
-  #
-  def to_str: () -> String
-
-  # Returns the Symbol corresponding to *str*, creating the symbol if it did not
-  # previously exist. See Symbol#id2name.
-  #
-  #     "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.
-  #
-  #     'cat and dog'.to_sym   #=> :"cat and dog"
-  #
-  def to_sym: () -> Symbol
-
-  # Returns a copy of `str` with the characters in `from_str` replaced by the
-  # corresponding characters in `to_str`.  If `to_str` is shorter than `from_str`,
-  # it is padded with its last character in order to maintain the correspondence.
-  #
-  #     "hello".tr('el', 'ip')      #=> "hippo"
-  #     "hello".tr('aeiou', '*')    #=> "h*ll*"
-  #     "hello".tr('aeiou', 'AA*')  #=> "hAll*"
-  #
-  # Both strings may use the `c1-c2` notation to denote ranges of characters, and
-  # `from_str` may start with a `^`, which denotes all characters except those
-  # listed.
-  #
-  #     "hello".tr('a-y', 'b-z')    #=> "ifmmp"
-  #     "hello".tr('^aeiou', '*')   #=> "*e**o"
-  #
-  # The backslash character `\` can be used to escape `^` or `-` and is otherwise
-  # ignored unless it appears at the end of a range or the end of the `from_str`
-  # or `to_str`:
-  #
-  #     "hello^world".tr("\\^aeiou", "*") #=> "h*ll**w*rld"
-  #     "hello-world".tr("a\\-eo", "*")   #=> "h*ll**w*rld"
-  #
-  #     "hello\r\nworld".tr("\r", "")   #=> "hello\nworld"
-  #     "hello\r\nworld".tr("\\r", "")  #=> "hello\r\nwold"
-  #     "hello\r\nworld".tr("\\\r", "") #=> "hello\nworld"
-  #
-  #     "X['\\b']".tr("X\\", "")   #=> "['b']"
-  #     "X['\\b']".tr("X-\\]", "") #=> "'b'"
-  #
-  def tr: (string from_str, string to_str) -> String
-
-  # Translates *str* in place, using the same rules as String#tr. Returns *str*,
-  # or `nil` if no changes were made.
-  #
-  def tr!: (string from_str, string to_str) -> String?
-
-  # Processes a copy of *str* as described under String#tr, then removes duplicate
-  # characters in regions that were affected by the translation.
-  #
-  #     "hello".tr_s('l', 'r')     #=> "hero"
-  #     "hello".tr_s('el', '*')    #=> "h*o"
-  #     "hello".tr_s('el', 'hx')   #=> "hhxo"
-  #
-  def tr_s: (string from_str, string to_str) -> String
-
-  # Performs String#tr_s processing on *str* in place, returning *str*, or `nil`
-  # if no changes were made.
-  #
-  def tr_s!: (string from_str, string to_str) -> String?
-
-  # Returns an unescaped version of the string. This does the inverse of
-  # String#dump.
-  #
-  #     "\"hello \\n ''\"".undump #=> "hello \n ''"
-  #
-  def undump: () -> String
-
-  # Unicode Normalization---Returns a normalized form of `str`, using Unicode
-  # normalizations NFC, NFD, NFKC, or NFKD. The normalization form used is
-  # determined by `form`, which can be any of the four values `:nfc`, `:nfd`,
-  # `:nfkc`, or `:nfkd`. The default is `:nfc`.
-  #
-  # If the string is not in a Unicode Encoding, then an Exception is raised. In
-  # this context, 'Unicode Encoding' means any of UTF-8, UTF-16BE/LE, and
-  # UTF-32BE/LE, as well as GB18030, UCS_2BE, and UCS_4BE. Anything other than
-  # UTF-8 is implemented by converting to UTF-8, which makes it slower than UTF-8.
-  #
-  #     "a\u0300".unicode_normalize        #=> "\u00E0"
-  #     "a\u0300".unicode_normalize(:nfc)  #=> "\u00E0"
-  #     "\u00E0".unicode_normalize(:nfd)   #=> "a\u0300"
-  #     "\xE0".force_encoding('ISO-8859-1').unicode_normalize(:nfd)
-  #                                        #=> Encoding::CompatibilityError raised
-  #
-  def unicode_normalize: (?:nfc | :nfd | :nfkc | :nfkd) -> String
-
-  # Destructive version of String#unicode_normalize, doing Unicode normalization
-  # in place.
-  #
-  def unicode_normalize!: (?:nfc | :nfd | :nfkc | :nfkd) -> String
-
-  # Checks whether `str` is in Unicode normalization form `form`, which can be any
-  # of the four values `:nfc`, `:nfd`, `:nfkc`, or `:nfkd`. The default is `:nfc`.
-  #
-  # If the string is not in a Unicode Encoding, then an Exception is raised. For
-  # details, see String#unicode_normalize.
-  #
-  #     "a\u0300".unicode_normalized?        #=> false
-  #     "a\u0300".unicode_normalized?(:nfd)  #=> true
-  #     "\u00E0".unicode_normalized?         #=> true
-  #     "\u00E0".unicode_normalized?(:nfd)   #=> false
-  #     "\xE0".force_encoding('ISO-8859-1').unicode_normalized?
-  #                                          #=> Encoding::CompatibilityError raised
-  #
-  def unicode_normalized?: (?:nfc | :nfd | :nfkc | :nfkd) -> bool
-
-  # Decodes *str* (which may contain binary data) according to the format string,
-  # returning an array of each value extracted. The format string consists of a
-  # sequence of single-character directives, summarized in the table at the end of
-  # this entry. Each directive may be followed by a number, indicating the number
-  # of times to repeat with this directive. An asterisk (```*`'') will use up all
-  # remaining elements. The directives `sSiIlL` may each be followed by an
-  # underscore (```_`'') or exclamation mark (```!`'') to use the underlying
-  # platform's native size for the specified type; otherwise, it uses a
-  # platform-independent consistent size. Spaces are ignored in the format string.
-  # See also String#unpack1,  Array#pack.
-  #
-  #     "abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
-  #     "abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
-  #     "abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
-  #     "aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
-  #     "aaa".unpack('h2H2c')               #=> ["16", "61", 97]
-  #     "\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
-  #     "now=20is".unpack('M*')             #=> ["now is"]
-  #     "whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]
-  #
-  # This table summarizes the various formats and the Ruby classes returned by
-  # each.
-  #
-  #     Integer       |         |
-  #     Directive     | Returns | Meaning
-  #     ------------------------------------------------------------------
-  #     C             | Integer | 8-bit unsigned (unsigned char)
-  #     S             | Integer | 16-bit unsigned, native endian (uint16_t)
-  #     L             | Integer | 32-bit unsigned, native endian (uint32_t)
-  #     Q             | Integer | 64-bit unsigned, native endian (uint64_t)
-  #     J             | Integer | pointer width unsigned, native endian (uintptr_t)
-  #                   |         |
-  #     c             | Integer | 8-bit signed (signed char)
-  #     s             | Integer | 16-bit signed, native endian (int16_t)
-  #     l             | Integer | 32-bit signed, native endian (int32_t)
-  #     q             | Integer | 64-bit signed, native endian (int64_t)
-  #     j             | Integer | pointer width signed, native endian (intptr_t)
-  #                   |         |
-  #     S_ S!         | Integer | unsigned short, native endian
-  #     I I_ I!       | Integer | unsigned int, native endian
-  #     L_ L!         | Integer | unsigned long, native endian
-  #     Q_ Q!         | Integer | unsigned long long, native endian (ArgumentError
-  #                   |         | if the platform has no long long type.)
-  #     J!            | Integer | uintptr_t, native endian (same with J)
-  #                   |         |
-  #     s_ s!         | Integer | signed short, native endian
-  #     i i_ i!       | Integer | signed int, native endian
-  #     l_ l!         | Integer | signed long, native endian
-  #     q_ q!         | Integer | signed long long, native endian (ArgumentError
-  #                   |         | if the platform has no long long type.)
-  #     j!            | Integer | intptr_t, native endian (same with j)
-  #                   |         |
-  #     S> s> S!> s!> | Integer | same as the directives without ">" except
-  #     L> l> L!> l!> |         | big endian
-  #     I!> i!>       |         |
-  #     Q> q> Q!> q!> |         | "S>" is same as "n"
-  #     J> j> J!> j!> |         | "L>" is same as "N"
-  #                   |         |
-  #     S< s< S!< s!< | Integer | same as the directives without "<" except
-  #     L< l< L!< l!< |         | little endian
-  #     I!< i!<       |         |
-  #     Q< q< Q!< q!< |         | "S<" is same as "v"
-  #     J< j< J!< j!< |         | "L<" is same as "V"
-  #                   |         |
-  #     n             | Integer | 16-bit unsigned, network (big-endian) byte order
-  #     N             | Integer | 32-bit unsigned, network (big-endian) byte order
-  #     v             | Integer | 16-bit unsigned, VAX (little-endian) byte order
-  #     V             | Integer | 32-bit unsigned, VAX (little-endian) byte order
-  #                   |         |
-  #     U             | Integer | UTF-8 character
-  #     w             | Integer | BER-compressed integer (see Array.pack)
-  #
-  #     Float        |         |
-  #     Directive    | Returns | Meaning
-  #     -----------------------------------------------------------------
-  #     D d          | Float   | double-precision, native format
-  #     F f          | Float   | single-precision, native format
-  #     E            | Float   | double-precision, little-endian byte order
-  #     e            | Float   | single-precision, little-endian byte order
-  #     G            | Float   | double-precision, network (big-endian) byte order
-  #     g            | Float   | single-precision, network (big-endian) byte order
-  #
-  #     String       |         |
-  #     Directive    | Returns | Meaning
-  #     -----------------------------------------------------------------
-  #     A            | String  | arbitrary binary string (remove trailing nulls and ASCII spaces)
-  #     a            | String  | arbitrary binary string
-  #     Z            | String  | null-terminated string
-  #     B            | String  | bit string (MSB first)
-  #     b            | String  | bit string (LSB first)
-  #     H            | String  | hex string (high nibble first)
-  #     h            | String  | hex string (low nibble first)
-  #     u            | String  | UU-encoded string
-  #     M            | String  | quoted-printable, MIME encoding (see RFC2045)
-  #     m            | String  | base64 encoded string (RFC 2045) (default)
-  #                  |         | base64 encoded string (RFC 4648) if followed by 0
-  #     P            | String  | pointer to a structure (fixed-length string)
-  #     p            | String  | pointer to a null-terminated string
-  #
-  #     Misc.        |         |
-  #     Directive    | Returns | Meaning
-  #     -----------------------------------------------------------------
-  #     @            | ---     | skip to the offset given by the length argument
-  #     X            | ---     | skip backward one byte
-  #     x            | ---     | skip forward one byte
-  #
-  # HISTORY
-  #
-  # *   J, J! j, and j! are available since Ruby 2.3.
-  # *   Q_, Q!, q_, and q! are available since Ruby 2.1.
-  # *   I!<, i!<, I!>, and i!> are available since Ruby 1.9.3.
-  #
-  #
-  def unpack: (String format) -> Array[Integer | Float | String | nil]
-
-  # Decodes *str* (which may contain binary data) according to the format string,
-  # returning the first value extracted. See also String#unpack, Array#pack.
-  #
-  # Contrast with String#unpack:
-  #
-  #     "abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
-  #     "abc \0\0abc \0\0".unpack1('A6Z6')  #=> "abc"
-  #
-  # In that case data would be lost but often it's the case that the array only
-  # holds one value, especially when unpacking binary data. For instance:
-  #
-  # "xffx00x00x00".unpack("l")         #=>  [255] "xffx00x00x00".unpack1("l")     
-  #   #=>  255
-  #
-  # Thus unpack1 is convenient, makes clear the intention and signals the expected
-  # return value to those reading the code.
-  #
-  def unpack1: (String format) -> (Integer | Float | String | nil)
-
-  # Returns a copy of *str* with all lowercase letters replaced with their
-  # uppercase counterparts.
-  #
-  # See String#downcase for meaning of `options` and use with different encodings.
-  #
-  #     "hEllO".upcase   #=> "HELLO"
-  #
-  def upcase: () -> String
-            | (:ascii | :lithuanian | :turkic) -> String
-            | (:lithuanian, :turkic) -> String
-            | (:turkic, :lithuanian) -> String
-
-  # Upcases the contents of *str*, returning `nil` if no changes were made.
-  #
-  # See String#downcase for meaning of `options` and use with different encodings.
-  #
-  def upcase!: () -> self?
-             | (:ascii | :lithuanian | :turkic) -> self?
-             | (:lithuanian, :turkic) -> self?
-             | (:turkic, :lithuanian) -> self?
-
-  # Iterates through successive values, starting at *str* and ending at
-  # *other_str* inclusive, passing each value in turn to the block. The
-  # String#succ method is used to generate each value.  If optional second
-  # argument exclusive is omitted or is false, the last value will be included;
-  # otherwise it will be excluded.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  #     "a8".upto("b6") {|s| print s, ' ' }
-  #     for s in "a8".."b6"
-  #       print s, ' '
-  #     end
-  #
-  # *produces:*
-  #
-  #     a8 a9 b0 b1 b2 b3 b4 b5 b6
-  #     a8 a9 b0 b1 b2 b3 b4 b5 b6
-  #
-  # If *str* and *other_str* contains only ascii numeric characters, both are
-  # recognized as decimal numbers. In addition, the width of string (e.g. leading
-  # zeros) is handled appropriately.
-  #
-  #     "9".upto("11").to_a   #=> ["9", "10", "11"]
-  #     "25".upto("5").to_a   #=> []
-  #     "07".upto("11").to_a  #=> ["07", "08", "09", "10", "11"]
-  #
-  def upto: (string other_str, ?bool exclusive) -> Enumerator[String, self]
-          | (string other_str, ?bool exclusive) { (String s) -> void } -> self
-
-  # Returns true for a string which is encoded correctly.
-  #
-  #     "\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
-
-  private
-
-  # Returns a new string object containing a copy of *str*.
-  #
-  # The optional *encoding* keyword argument specifies the encoding of the new
-  # string. If not specified, the encoding of *str* is used (or ASCII-8BIT, if
-  # *str* is not specified).
-  #
-  # The optional *capacity* keyword argument specifies the size of the internal
-  # buffer. This may improve performance, when the string will be concatenated
-  # many times (causing many realloc calls).
-  #
-  def initialize: (?string str, ?encoding: Encoding | string, ?capacity: int) -> void
-
-  # Replaces the contents of *str* with the corresponding values in *other_str*.
-  #
-  #     s = "hello"         #=> "hello"
-  #     s.replace "world"   #=> "world"
-  #
-  alias initialize_copy replace
-end
-
-interface _ArefFromStringToString
-  def []: (String) -> String
-end
-
-type String::encode_fallback = Hash[String, String] | Proc | Method | _ArefFromStringToString