rbs 1.0.6 → 1.1.0

data/stdlib/rubygems/0/source_list.rbs

@@ -0,0 +1,2 @@
+class Gem::SourceList
+end

data/stdlib/rubygems/0/specification.rbs

@@ -0,0 +1,3 @@
+class Gem::Specification < Gem::BasicSpecification
+  # TODO: Add sinatures...
+end

data/stdlib/rubygems/0/stream_ui.rbs

@@ -0,0 +1,3 @@
+class Gem::StreamUI
+  # TODO: Add sinatures...
+end

data/stdlib/rubygems/0/uninstaller.rbs

@@ -0,0 +1,3 @@
+class Gem::Uninstaller
+  # TODO: Add sinatures...
+end

data/stdlib/rubygems/0/version.rbs

@@ -0,0 +1,228 @@
+module Gem
+  # The Version class processes string versions into comparable values. A version
+  # string should normally be a series of numbers separated by periods. Each part
+  # (digits separated by periods) is considered its own number, and these are used
+  # for sorting. So for instance, 3.10 sorts higher than 3.2 because ten is
+  # greater than two.
+  #
+  # If any part contains letters (currently only a-z are supported) then that
+  # version is considered prerelease. Versions with a prerelease part in the Nth
+  # part sort less than versions with N-1 parts. Prerelease parts are sorted
+  # alphabetically using the normal Ruby string sorting rules. If a prerelease
+  # part contains both letters and numbers, it will be broken into multiple parts
+  # to provide expected sort behavior (1.0.a10 becomes 1.0.a.10, and is greater
+  # than 1.0.a9).
+  #
+  # Prereleases sort between real releases (newest to oldest):
+  #
+  # 1.  1.0
+  # 2.  1.0.b1
+  # 3.  1.0.a.2
+  # 4.  0.9
+  #
+  #
+  # If you want to specify a version restriction that includes both prereleases
+  # and regular releases of the 1.x series this is the best way:
+  #
+  #     s.add_dependency 'example', '>= 1.0.0.a', '< 2.0.0'
+  #
+  # ## How Software Changes
+  #
+  # Users expect to be able to specify a version constraint that gives them some
+  # reasonable expectation that new versions of a library will work with their
+  # software if the version constraint is true, and not work with their software
+  # if the version constraint is false.  In other words, the perfect system will
+  # accept all compatible versions of the library and reject all incompatible
+  # versions.
+  #
+  # Libraries change in 3 ways (well, more than 3, but stay focused here!).
+  #
+  # 1.  The change may be an implementation detail only and have no effect on the
+  #     client software.
+  # 2.  The change may add new features, but do so in a way that client software
+  #     written to an earlier version is still compatible.
+  # 3.  The change may change the public interface of the library in such a way
+  #     that old software is no longer compatible.
+  #
+  #
+  # Some examples are appropriate at this point.  Suppose I have a Stack class
+  # that supports a `push` and a `pop` method.
+  #
+  # ### Examples of Category 1 changes:
+  #
+  # *   Switch from an array based implementation to a linked-list based
+  #     implementation.
+  # *   Provide an automatic (and transparent) backing store for large stacks.
+  #
+  #
+  # ### Examples of Category 2 changes might be:
+  #
+  # *   Add a `depth` method to return the current depth of the stack.
+  # *   Add a `top` method that returns the current top of stack (without changing
+  #     the stack).
+  # *   Change `push` so that it returns the item pushed (previously it had no
+  #     usable return value).
+  #
+  #
+  # ### Examples of Category 3 changes might be:
+  #
+  # *   Changes `pop` so that it no longer returns a value (you must use `top` to
+  #     get the top of the stack).
+  # *   Rename the methods to `push_item` and `pop_item`.
+  #
+  #
+  # ## RubyGems Rational Versioning
+  #
+  # *   Versions shall be represented by three non-negative integers, separated by
+  #     periods (e.g. 3.1.4).  The first integers is the "major" version number,
+  #     the second integer is the "minor" version number, and the third integer is
+  #     the "build" number.
+  #
+  # *   A category 1 change (implementation detail) will increment the build
+  #     number.
+  #
+  # *   A category 2 change (backwards compatible) will increment the minor
+  #     version number and reset the build number.
+  #
+  # *   A category 3 change (incompatible) will increment the major build number
+  #     and reset the minor and build numbers.
+  #
+  # *   Any "public" release of a gem should have a different version.  Normally
+  #     that means incrementing the build number.  This means a developer can
+  #     generate builds all day long, but as soon as they make a public release,
+  #     the version must be updated.
+  #
+  #
+  # ### Examples
+  #
+  # Let's work through a project lifecycle using our Stack example from above.
+  #
+  # Version 0.0.1
+  # :   The initial Stack class is release.
+  # Version 0.0.2
+  # :   Switched to a linked=list implementation because it is cooler.
+  # Version 0.1.0
+  # :   Added a `depth` method.
+  # Version 1.0.0
+  # :   Added `top` and made `pop` return nil (`pop` used to return the  old top
+  #     item).
+  # Version 1.1.0
+  # :   `push` now returns the value pushed (it used it return nil).
+  # Version 1.1.1
+  # :   Fixed a bug in the linked list implementation.
+  # Version 1.1.2
+  # :   Fixed a bug introduced in the last fix.
+  #
+  #
+  # Client A needs a stack with basic push/pop capability.  They write to the
+  # original interface (no `top`), so their version constraint looks like:
+  #
+  #     gem 'stack', '>= 0.0'
+  #
+  # Essentially, any version is OK with Client A.  An incompatible change to the
+  # library will cause them grief, but they are willing to take the chance (we
+  # call Client A optimistic).
+  #
+  # Client B is just like Client A except for two things: (1) They use the `depth`
+  # method and (2) they are worried about future incompatibilities, so they write
+  # their version constraint like this:
+  #
+  #     gem 'stack', '~> 0.1'
+  #
+  # The `depth` method was introduced in version 0.1.0, so that version or
+  # anything later is fine, as long as the version stays below version 1.0 where
+  # incompatibilities are introduced.  We call Client B pessimistic because they
+  # are worried about incompatible future changes (it is OK to be pessimistic!).
+  #
+  # ## Preventing Version Catastrophe:
+  #
+  # From: http://blog.zenspider.com/2008/10/rubygems-howto-preventing-cata.html
+  #
+  # Let's say you're depending on the fnord gem version 2.y.z. If you specify your
+  # dependency as ">= 2.0.0" then, you're good, right? What happens if fnord 3.0
+  # comes out and it isn't backwards compatible with 2.y.z? Your stuff will break
+  # as a result of using ">=". The better route is to specify your dependency with
+  # an "approximate" version specifier ("~>"). They're a tad confusing, so here is
+  # how the dependency specifiers work:
+  #
+  #     Specification From  ... To (exclusive)
+  #     ">= 3.0"      3.0   ... &infin;
+  #     "~> 3.0"      3.0   ... 4.0
+  #     "~> 3.0.0"    3.0.0 ... 3.1
+  #     "~> 3.5"      3.5   ... 4.0
+  #     "~> 3.5.0"    3.5.0 ... 3.6
+  #     "~> 3"        3.0   ... 4.0
+  #
+  # For the last example, single-digit versions are automatically extended with a
+  # zero to give a sensible result.
+  #
+  class Version
+    include Comparable
+
+    # True if the `version` string matches RubyGems' requirements.
+    #
+    def self.correct?: (_ToS version) -> bool
+
+    # Factory method to create a Version object. Input may be a Version or a String.
+    # Intended to simplify client code.
+    #
+    #     ver1 = Version.create('1.3.17')   # -> (Version object)
+    #     ver2 = Version.create(ver1)       # -> (ver1)
+    #     ver3 = Version.create(nil)        # -> nil
+    #
+    def self.create: (_ToS | Version | nil input) -> instance?
+
+    # Constructs a Version from the `version` string.  A version string is a series
+    # of digits or ASCII letters separated by dots.
+    #
+    def initialize: (_ToS version) -> void
+
+    # is larger, the same, or smaller than this one. Attempts to compare to
+    # something that's not a `Gem::Version` return `nil`.
+    #
+    def <=>: (untyped other) -> Integer?
+
+    # A recommended version for use with a ~> Requirement.
+    #
+    def approximate_recommendation: () -> String
+
+    # Return a new version object where the next to the last revision number is one
+    # greater (e.g., 5.3.1 => 5.4).
+    #
+    # Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
+    #
+    def bump: () -> instance
+
+    def canonical_segments: () -> Array[Integer | String]
+
+    # A Version is only eql? to another version if it's specified to the same
+    # precision. Version "1.0" is not the same as version "1".
+    #
+    def eql?: (untyped other) -> bool
+
+    # Dump only the raw version string, not the complete object. It's a string for
+    # backwards (RubyGems 1.3.5 and earlier) compatibility.
+    #
+    def marshal_dump: () -> Array[String]
+
+    # Load custom marshal format. It's a string for backwards (RubyGems 1.3.5 and
+    # earlier) compatibility.
+    #
+    def marshal_load: (Array[String] array) -> void
+
+    # A version is considered a prerelease if it contains a letter.
+    #
+    def prerelease?: () -> bool
+
+    # The release for this version (e.g. 1.2.0.a -> 1.2.0). Non-prerelease versions
+    # return themselves.
+    #
+    def release: () -> instance
+
+    # A string representation of this Version.
+    #
+    def version: () -> String
+
+    alias to_s version
+  end
+end

data/stdlib/strscan/0/string_scanner.rbs

@@ -0,0 +1,582 @@
+# StringScanner provides for lexical scanning operations on a String.  Here is
+# an example of its usage:
+#
+#     s = StringScanner.new('This is an example string')
+#     s.eos?               # -> false
+#
+#     p s.scan(/\w+/)      # -> "This"
+#     p s.scan(/\w+/)      # -> nil
+#     p s.scan(/\s+/)      # -> " "
+#     p s.scan(/\s+/)      # -> nil
+#     p s.scan(/\w+/)      # -> "is"
+#     s.eos?               # -> false
+#
+#     p s.scan(/\s+/)      # -> " "
+#     p s.scan(/\w+/)      # -> "an"
+#     p s.scan(/\s+/)      # -> " "
+#     p s.scan(/\w+/)      # -> "example"
+#     p s.scan(/\s+/)      # -> " "
+#     p s.scan(/\w+/)      # -> "string"
+#     s.eos?               # -> true
+#
+#     p s.scan(/\s+/)      # -> nil
+#     p s.scan(/\w+/)      # -> nil
+#
+# Scanning a string means remembering the position of a *scan pointer*, which is
+# just an index.  The point of scanning is to move forward a bit at a time, so
+# matches are sought after the scan pointer; usually immediately after it.
+#
+# Given the string "test string", here are the pertinent scan pointer positions:
+#
+#       t e s t   s t r i n g
+#     0 1 2 ...             1
+#                           0
+#
+# When you #scan for a pattern (a regular expression), the match must occur at
+# the character after the scan pointer.  If you use #scan_until, then the match
+# can occur anywhere after the scan pointer.  In both cases, the scan pointer
+# moves *just beyond* the last character of the match, ready to scan again from
+# the next character onwards.  This is demonstrated by the example above.
+#
+# ## Method Categories
+#
+# There are other methods besides the plain scanners.  You can look ahead in the
+# string without actually scanning.  You can access the most recent match. You
+# can modify the string being scanned, reset or terminate the scanner, find out
+# or change the position of the scan pointer, skip ahead, and so on.
+#
+# ### Advancing the Scan Pointer
+#
+# *   #getch
+# *   #get_byte
+# *   #scan
+# *   #scan_until
+# *   #skip
+# *   #skip_until
+#
+#
+# ### Looking Ahead
+#
+# *   #check
+# *   #check_until
+# *   #exist?
+# *   #match?
+# *   #peek
+#
+#
+# ### Finding Where we Are
+#
+# *   #beginning_of_line? (#bol?)
+# *   #eos?
+# *   #rest?
+# *   #rest_size
+# *   #pos
+#
+#
+# ### Setting Where we Are
+#
+# *   #reset
+# *   #terminate
+# *   #pos=
+#
+#
+# ### Match Data
+#
+# *   #matched
+# *   #matched?
+# *   #matched_size
+#
+#
+# :
+# *   #pre_match
+# *   #post_match
+#
+#
+# ### Miscellaneous
+#
+# *   <<
+# *   #concat
+# *   #string
+# *   #string=
+# *   #unscan
+#
+#
+# There are aliases to several of the methods.
+class StringScanner
+  # This method is defined for backward compatibility.
+  #
+  def self.must_C_version: () -> self
+
+  public
+
+  # Appends `str` to the string being scanned. This method does not affect scan
+  # pointer.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.scan(/Fri /)
+  #     s << " +1000 GMT"
+  #     s.string            # -> "Fri Dec 12 1975 14:39 +1000 GMT"
+  #     s.scan(/Dec/)       # -> "Dec"
+  #
+  def <<: (String) -> self
+
+  # Returns the n-th subgroup in the most recent match.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.scan(/(\w+) (\w+) (\d+) /)       # -> "Fri Dec 12 "
+  #     s[0]                               # -> "Fri Dec 12 "
+  #     s[1]                               # -> "Fri"
+  #     s[2]                               # -> "Dec"
+  #     s[3]                               # -> "12"
+  #     s.post_match                       # -> "1975 14:39"
+  #     s.pre_match                        # -> ""
+  #
+  #     s.reset
+  #     s.scan(/(?<wday>\w+) (?<month>\w+) (?<day>\d+) /)       # -> "Fri Dec 12 "
+  #     s[0]                               # -> "Fri Dec 12 "
+  #     s[1]                               # -> "Fri"
+  #     s[2]                               # -> "Dec"
+  #     s[3]                               # -> "12"
+  #     s[:wday]                           # -> "Fri"
+  #     s[:month]                          # -> "Dec"
+  #     s[:day]                            # -> "12"
+  #     s.post_match                       # -> "1975 14:39"
+  #     s.pre_match                        # -> ""
+  #
+  def []: (Integer) -> String?
+
+  # Returns `true` iff the scan pointer is at the beginning of the line.
+  #
+  #     s = StringScanner.new("test\ntest\n")
+  #     s.bol?           # => true
+  #     s.scan(/te/)
+  #     s.bol?           # => false
+  #     s.scan(/st\n/)
+  #     s.bol?           # => true
+  #     s.terminate
+  #     s.bol?           # => true
+  #
+  def beginning_of_line?: () -> bool
+
+  alias bol? beginning_of_line?
+
+  # Returns the subgroups in the most recent match (not including the full match).
+  # If nothing was priorly matched, it returns nil.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.scan(/(\w+) (\w+) (\d+) /)       # -> "Fri Dec 12 "
+  #     s.captures                         # -> ["Fri", "Dec", "12"]
+  #     s.scan(/(\w+) (\w+) (\d+) /)       # -> nil
+  #     s.captures                         # -> nil
+  #
+  def captures: () -> Array[String]?
+
+  # Returns the character position of the scan pointer.  In the 'reset' position,
+  # this value is zero.  In the 'terminated' position (i.e. the string is
+  # exhausted), this value is the size of the string.
+  #
+  # In short, it's a 0-based index into the string.
+  #
+  #     s = StringScanner.new("abcädeföghi")
+  #     s.charpos           # -> 0
+  #     s.scan_until(/ä/)   # -> "abcä"
+  #     s.pos               # -> 5
+  #     s.charpos           # -> 4
+  #
+  def charpos: () -> Integer
+
+  # This returns the value that #scan would return, without advancing the scan
+  # pointer.  The match register is affected, though.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.check /Fri/               # -> "Fri"
+  #     s.pos                       # -> 0
+  #     s.matched                   # -> "Fri"
+  #     s.check /12/                # -> nil
+  #     s.matched                   # -> nil
+  #
+  # Mnemonic: it "checks" to see whether a #scan will return a value.
+  #
+  def check: (Regexp) -> String?
+
+  # This returns the value that #scan_until would return, without advancing the
+  # scan pointer.  The match register is affected, though.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.check_until /12/          # -> "Fri Dec 12"
+  #     s.pos                       # -> 0
+  #     s.matched                   # -> 12
+  #
+  # Mnemonic: it "checks" to see whether a #scan_until will return a value.
+  #
+  def check_until: (Regexp) -> String
+
+  # Equivalent to #terminate. This method is obsolete; use #terminate instead.
+  #
+  def clear: () -> void
+
+  alias concat <<
+
+  # Equivalent to #eos?. This method is obsolete, use #eos? instead.
+  #
+  def empty?: () -> bool
+
+  # Returns `true` if the scan pointer is at the end of the string.
+  #
+  #     s = StringScanner.new('test string')
+  #     p s.eos?          # => false
+  #     s.scan(/test/)
+  #     p s.eos?          # => false
+  #     s.terminate
+  #     p s.eos?          # => true
+  #
+  def eos?: () -> bool
+
+  # Looks *ahead* to see if the `pattern` exists *anywhere* in the string, without
+  # advancing the scan pointer.  This predicates whether a #scan_until will return
+  # a value.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.exist? /s/            # -> 3
+  #     s.scan /test/           # -> "test"
+  #     s.exist? /s/            # -> 2
+  #     s.exist? /e/            # -> nil
+  #
+  def exist?: (Regexp) -> Integer?
+
+  # Whether `scanner` uses fixed anchor mode or not.
+  #
+  # If fixed anchor mode is used, `\A` always matches the beginning of the string.
+  # Otherwise, `\A` always matches the current position.
+  #
+  def fixed_anchor?: () -> bool
+
+  # Scans one byte and returns it. This method is not multibyte character
+  # sensitive. See also: #getch.
+  #
+  #     s = StringScanner.new('ab')
+  #     s.get_byte         # => "a"
+  #     s.get_byte         # => "b"
+  #     s.get_byte         # => nil
+  #
+  #     s = StringScanner.new("\244\242".force_encoding("euc-jp"))
+  #     s.get_byte         # => "\xA4"
+  #     s.get_byte         # => "\xA2"
+  #     s.get_byte         # => nil
+  #
+  def get_byte: () -> String?
+
+  # Equivalent to #get_byte. This method is obsolete; use #get_byte instead.
+  #
+  def getbyte: () -> String?
+
+  # Scans one character and returns it. This method is multibyte character
+  # sensitive.
+  #
+  #     s = StringScanner.new("ab")
+  #     s.getch           # => "a"
+  #     s.getch           # => "b"
+  #     s.getch           # => nil
+  #
+  #     s = StringScanner.new("\244\242".force_encoding("euc-jp"))
+  #     s.getch           # => "\x{A4A2}"   # Japanese hira-kana "A" in EUC-JP
+  #     s.getch           # => nil
+  #
+  def getch: () -> String?
+
+  # Returns a string that represents the StringScanner object, showing:
+  # *   the current position
+  # *   the size of the string
+  # *   the characters surrounding the scan pointer
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39") s.inspect            # ->
+  #     '#<StringScanner 0/21 @ "Fri D...">' s.scan_until /12/    # -> "Fri Dec
+  #     12" s.inspect            # -> '#<StringScanner 10/21 "...ec 12" @ "
+  #     1975...">'
+  #
+  def inspect: () -> String
+
+  # Tests whether the given `pattern` is matched from the current scan pointer.
+  # Returns the length of the match, or `nil`.  The scan pointer is not advanced.
+  #
+  #     s = StringScanner.new('test string')
+  #     p s.match?(/\w+/)   # -> 4
+  #     p s.match?(/\w+/)   # -> 4
+  #     p s.match?("test")  # -> 4
+  #     p s.match?(/\s+/)   # -> nil
+  #
+  def match?: (Regexp) -> Integer?
+
+  # Returns the last matched string.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.match?(/\w+/)     # -> 4
+  #     s.matched           # -> "test"
+  #
+  def matched: () -> String?
+
+  # Returns `true` iff the last match was successful.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.match?(/\w+/)     # => 4
+  #     s.matched?          # => true
+  #     s.match?(/\d+/)     # => nil
+  #     s.matched?          # => false
+  #
+  def matched?: () -> bool
+
+  # Returns the size of the most recent match in bytes, or `nil` if there was no
+  # recent match.  This is different than `matched.size`, which will return the
+  # size in characters.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.check /\w+/           # -> "test"
+  #     s.matched_size          # -> 4
+  #     s.check /\d+/           # -> nil
+  #     s.matched_size          # -> nil
+  #
+  def matched_size: () -> Integer?
+
+  # Extracts a string corresponding to `string[pos,len]`, without advancing the
+  # scan pointer.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.peek(7)          # => "test st"
+  #     s.peek(7)          # => "test st"
+  #
+  def peek: (Integer) -> String
+
+  # Equivalent to #peek. This method is obsolete; use #peek instead.
+  #
+  def peep: (Integer) -> String
+
+  # Returns the byte position of the scan pointer.  In the 'reset' position, this
+  # value is zero.  In the 'terminated' position (i.e. the string is exhausted),
+  # this value is the bytesize of the string.
+  #
+  # In short, it's a 0-based index into bytes of the string.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.pos               # -> 0
+  #     s.scan_until /str/  # -> "test str"
+  #     s.pos               # -> 8
+  #     s.terminate         # -> #<StringScanner fin>
+  #     s.pos               # -> 11
+  #
+  def pointer: () -> Integer
+
+  # Sets the byte position of the scan pointer.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.pos = 7            # -> 7
+  #     s.rest               # -> "ring"
+  #
+  def pointer=: (Integer) -> Integer
+
+  # Returns the byte position of the scan pointer.  In the 'reset' position, this
+  # value is zero.  In the 'terminated' position (i.e. the string is exhausted),
+  # this value is the bytesize of the string.
+  #
+  # In short, it's a 0-based index into bytes of the string.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.pos               # -> 0
+  #     s.scan_until /str/  # -> "test str"
+  #     s.pos               # -> 8
+  #     s.terminate         # -> #<StringScanner fin>
+  #     s.pos               # -> 11
+  #
+  def pos: () -> Integer
+
+  # Sets the byte position of the scan pointer.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.pos = 7            # -> 7
+  #     s.rest               # -> "ring"
+  #
+  def pos=: (Integer) -> Integer
+
+  # Returns the ***post**-match* (in the regular expression sense) of the last
+  # scan.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.scan(/\w+/)           # -> "test"
+  #     s.scan(/\s+/)           # -> " "
+  #     s.pre_match             # -> "test"
+  #     s.post_match            # -> "string"
+  #
+  def post_match: () -> String
+
+  # Returns the ***pre**-match* (in the regular expression sense) of the last
+  # scan.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.scan(/\w+/)           # -> "test"
+  #     s.scan(/\s+/)           # -> " "
+  #     s.pre_match             # -> "test"
+  #     s.post_match            # -> "string"
+  #
+  def pre_match: () -> String
+
+  # Reset the scan pointer (index 0) and clear matching data.
+  #
+  def reset: () -> void
+
+  # Returns the "rest" of the string (i.e. everything after the scan pointer). If
+  # there is no more data (eos? = true), it returns `""`.
+  #
+  def rest: () -> String
+
+  # Returns true iff there is more data in the string.  See #eos?. This method is
+  # obsolete; use #eos? instead.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.eos?              # These two
+  #     s.rest?             # are opposites.
+  #
+  def rest?: () -> bool
+
+  # `s.rest_size` is equivalent to `s.rest.size`.
+  #
+  def rest_size: () -> Integer
+
+  # `s.restsize` is equivalent to `s.rest_size`. This method is obsolete; use
+  # #rest_size instead.
+  #
+  def restsize: () -> Integer
+
+  # Tries to match with `pattern` at the current position. If there's a match, the
+  # scanner advances the "scan pointer" and returns the matched string. Otherwise,
+  # the scanner returns `nil`.
+  #
+  #     s = StringScanner.new('test string')
+  #     p s.scan(/\w+/)   # -> "test"
+  #     p s.scan(/\w+/)   # -> nil
+  #     p s.scan(/\s+/)   # -> " "
+  #     p s.scan("str")   # -> "str"
+  #     p s.scan(/\w+/)   # -> "ing"
+  #     p s.scan(/./)     # -> nil
+  #
+  def scan: (Regexp) -> String?
+
+  # Tests whether the given `pattern` is matched from the current scan pointer.
+  # Advances the scan pointer if `advance_pointer_p` is true. Returns the matched
+  # string if `return_string_p` is true. The match register is affected.
+  #
+  # "full" means "#scan with full parameters".
+  #
+  def scan_full: (Regexp pattern, bool advance_pointer_p, bool return_string_p) -> untyped
+
+  # Scans the string *until* the `pattern` is matched.  Returns the substring up
+  # to and including the end of the match, advancing the scan pointer to that
+  # location. If there is no match, `nil` is returned.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.scan_until(/1/)        # -> "Fri Dec 1"
+  #     s.pre_match              # -> "Fri Dec "
+  #     s.scan_until(/XYZ/)      # -> nil
+  #
+  def scan_until: (Regexp) -> String?
+
+  # Scans the string *until* the `pattern` is matched. Advances the scan pointer
+  # if `advance_pointer_p`, otherwise not. Returns the matched string if
+  # `return_string_p` is true, otherwise returns the number of bytes advanced.
+  # This method does affect the match register.
+  #
+  def search_full: (Regexp pattern, bool advance_pointer_p, bool return_string_p) -> untyped
+
+  # Returns the amount of subgroups in the most recent match. The full match
+  # counts as a subgroup.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.scan(/(\w+) (\w+) (\d+) /)       # -> "Fri Dec 12 "
+  #     s.size                             # -> 4
+  #
+  def size: () -> Integer
+
+  # Attempts to skip over the given `pattern` beginning with the scan pointer. If
+  # it matches, the scan pointer is advanced to the end of the match, and the
+  # length of the match is returned.  Otherwise, `nil` is returned.
+  #
+  # It's similar to #scan, but without returning the matched string.
+  #
+  #     s = StringScanner.new('test string')
+  #     p s.skip(/\w+/)   # -> 4
+  #     p s.skip(/\w+/)   # -> nil
+  #     p s.skip(/\s+/)   # -> 1
+  #     p s.skip("st")    # -> 2
+  #     p s.skip(/\w+/)   # -> 4
+  #     p s.skip(/./)     # -> nil
+  #
+  def skip: (Regexp) -> Integer?
+
+  # Advances the scan pointer until `pattern` is matched and consumed.  Returns
+  # the number of bytes advanced, or `nil` if no match was found.
+  #
+  # Look ahead to match `pattern`, and advance the scan pointer to the *end* of
+  # the match.  Return the number of characters advanced, or `nil` if the match
+  # was unsuccessful.
+  #
+  # It's similar to #scan_until, but without returning the intervening string.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.skip_until /12/           # -> 10
+  #     s                           #
+  #
+  def skip_until: (Regexp) -> Integer?
+
+  # Returns the string being scanned.
+  #
+  def string: () -> String
+
+  # Changes the string being scanned to `str` and resets the scanner. Returns
+  # `str`.
+  #
+  def string=: (String) -> String
+
+  # Sets the scan pointer to the end of the string and clear matching data.
+  #
+  def terminate: () -> void
+
+  # Sets the scan pointer to the previous position.  Only one previous position is
+  # remembered, and it changes with each scanning operation.
+  #
+  #     s = StringScanner.new('test string')
+  #     s.scan(/\w+/)        # => "test"
+  #     s.unscan
+  #     s.scan(/../)         # => "te"
+  #     s.scan(/\d/)         # => nil
+  #     s.unscan             # ScanError: unscan failed: previous match record not exist
+  #
+  def unscan: () -> void
+
+  # Returns the subgroups in the most recent match at the given indices. If
+  # nothing was priorly matched, it returns nil.
+  #
+  #     s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #     s.scan(/(\w+) (\w+) (\d+) /)       # -> "Fri Dec 12 "
+  #     s.values_at 0, -1, 5, 2            # -> ["Fri Dec 12 ", "12", nil, "Dec"]
+  #     s.scan(/(\w+) (\w+) (\d+) /)       # -> nil
+  #     s.values_at 0, -1, 5, 2            # -> nil
+  #
+  def values_at: (*Integer) -> Array[String]?
+
+  private
+
+  # Creates a new StringScanner object to scan over the given `string`.
+  #
+  # If `fixed_anchor` is `true`, `\A` always matches the beginning of the string.
+  # Otherwise, `\A` always matches the current position.
+  #
+  # `dup` argument is obsolete and not used now.
+  #
+  def initialize: (String, ?bool dup, ?fixed_anchor: bool) -> untyped
+
+  # Duplicates a StringScanner object.
+  #
+  def initialize_copy: (StringScanner) -> void
+end
+
+StringScanner::Id: String
+
+StringScanner::Version: String