getargv 0.3.3-universal-darwin → 0.3.5-universal-darwin

data/vendor/bundle/ruby/3.3.0/gems/rbs-2.8.4/core/io.rbs

@@ -1,3039 +0,0 @@
-# <!-- rdoc-file=io.c -->
-# The IO class is the basis for all input and output in Ruby. An I/O stream may
-# be *duplexed* (that is, bidirectional), and so may use more than one native
-# operating system stream.
-#
-# Many of the examples in this section use the File class, the only standard
-# subclass of IO. The two classes are closely associated.  Like the File class,
-# the Socket library subclasses from IO (such as TCPSocket or UDPSocket).
-#
-# The Kernel#open method can create an IO (or File) object for these types of
-# arguments:
-#
-# *   A plain string represents a filename suitable for the underlying operating
-#     system.
-#
-# *   A string starting with `"|"` indicates a subprocess. The remainder of the
-#     string following the `"|"` is invoked as a process with appropriate
-#     input/output channels connected to it.
-#
-# *   A string equal to `"|-"` will create another Ruby instance as a
-#     subprocess.
-#
-#
-# The IO may be opened with different file modes (read-only, write-only) and
-# encodings for proper conversion.  See IO.new for these options.  See
-# Kernel#open for details of the various command formats described above.
-#
-# IO.popen, the Open3 library, or  Process#spawn may also be used to communicate
-# with subprocesses through an IO.
-#
-# Ruby will convert pathnames between different operating system conventions if
-# possible.  For instance, on a Windows system the filename
-# `"/gumby/ruby/test.rb"` will be opened as `"\gumby\ruby\test.rb"`.  When
-# specifying a Windows-style filename in a Ruby string, remember to escape the
-# backslashes:
-#
-#     "C:\\gumby\\ruby\\test.rb"
-#
-# Our examples here will use the Unix-style forward slashes; File::ALT_SEPARATOR
-# can be used to get the platform-specific separator character.
-#
-# The global constant ARGF (also accessible as `$<`) provides an IO-like stream
-# which allows access to all files mentioned on the command line (or STDIN if no
-# files are mentioned). ARGF#path and its alias ARGF#filename are provided to
-# access the name of the file currently being read.
-#
-# ## io/console
-#
-# The io/console extension provides methods for interacting with the console.
-# The console can be accessed from IO.console or the standard input/output/error
-# IO objects.
-#
-# Requiring io/console adds the following methods:
-#
-# *   IO::console
-# *   IO#raw
-# *   IO#raw!
-# *   IO#cooked
-# *   IO#cooked!
-# *   IO#getch
-# *   IO#echo=
-# *   IO#echo?
-# *   IO#noecho
-# *   IO#winsize
-# *   IO#winsize=
-# *   IO#iflush
-# *   IO#ioflush
-# *   IO#oflush
-#
-#
-# Example:
-#
-#     require 'io/console'
-#     rows, columns = $stdout.winsize
-#     puts "Your screen is #{columns} wide and #{rows} tall"
-#
-# ## Example Files
-#
-# Many examples here use these filenames and their corresponding files:
-#
-# *   `t.txt`: A text-only file that is assumed to exist via:
-#
-#         text = <<~EOT
-#           This is line one.
-#           This is the second line.
-#           This is the third line.
-#         EOT
-#         File.write('t.txt', text)
-#
-# *   `t.dat`: A data file that is assumed to exist via:
-#
-#         data = "\u9990\u9991\u9992\u9993\u9994"
-#         f = File.open('t.dat', 'wb:UTF-16')
-#         f.write(data)
-#         f.close
-#
-# *   `t.rus`: A Russian-language text file that is assumed to exist via:
-#
-#         File.write('t.rus', "\u{442 435 441 442}")
-#
-# *   `t.tmp`: A file that is assumed *not* to exist.
-#
-#
-# ## Modes
-#
-# A number of IO method calls must or may specify a *mode* for the stream; the
-# mode determines how stream is to be accessible, including:
-#
-# *   Whether the stream is to be read-only, write-only, or read-write.
-# *   Whether the stream is positioned at its beginning or its end.
-# *   Whether the stream treats data as text-only or binary.
-# *   The external and internal encodings.
-#
-#
-# ### Mode Specified as an Integer
-#
-# When `mode` is an integer it must be one or more (combined by bitwise OR (`|`)
-# of the modes defined in File::Constants:
-#
-# *   `File::RDONLY`: Open for reading only.
-# *   `File::WRONLY`: Open for writing only.
-# *   `File::RDWR`: Open for reading and writing.
-# *   `File::APPEND`: Open for appending only.
-# *   `File::CREAT`: Create file if it does not exist.
-# *   `File::EXCL`: Raise an exception if `File::CREAT` is given and the file
-#     exists.
-#
-#
-# Examples:
-#
-#     File.new('t.txt', File::RDONLY)
-#     File.new('t.tmp', File::RDWR | File::CREAT | File::EXCL)
-#
-# Note: Method IO#set_encoding does not allow the mode to be specified as an
-# integer.
-#
-# ### Mode Specified As a String
-#
-# When `mode` is a string it must begin with one of the following:
-#
-# *   `'r'`: Read-only stream, positioned at the beginning; the stream cannot be
-#     changed to writable.
-# *   `'w'`: Write-only stream, positioned at the beginning; the stream cannot
-#     be changed to readable.
-# *   `'a'`: Write-only stream, positioned at the end; every write appends to
-#     the end; the stream cannot be changed to readable.
-# *   `'r+'`: Read-write stream, positioned at the beginning.
-# *   `'w+'`: Read-write stream, positioned at the end.
-# *   `'a+'`: Read-write stream, positioned at the end.
-#
-#
-# For a writable file stream (that is, any except read-only), the file is
-# truncated to zero if it exists, and is created if it does not exist.
-#
-# Examples:
-#
-#     File.open('t.txt', 'r')
-#     File.open('t.tmp', 'w')
-#
-# Either of the following may be suffixed to any of the above:
-#
-# *   `'t'`: Text data; sets the default external encoding to `Encoding::UTF_8`;
-#     on Windows, enables conversion between EOL and CRLF.
-# *   `'b'`: Binary data; sets the default external encoding to
-#     `Encoding::ASCII_8BIT`; on Windows, suppresses conversion between EOL and
-#     CRLF.
-#
-#
-# If neither is given, the stream defaults to text data.
-#
-# Examples:
-#
-#     File.open('t.txt', 'rt')
-#     File.open('t.dat', 'rb')
-#
-# The following may be suffixed to any writable mode above:
-#
-# *   `'x'`: Creates the file if it does not exist; raises an exception if the
-#     file exists.
-#
-#
-# Example:
-#
-#     File.open('t.tmp', 'wx')
-#
-# Finally, the mode string may specify encodings -- either external encoding
-# only or both external and internal encodings -- by appending one or both
-# encoding names, separated by colons:
-#
-#     f = File.new('t.dat', 'rb')
-#     f.external_encoding # => #<Encoding:ASCII-8BIT>
-#     f.internal_encoding # => nil
-#     f = File.new('t.dat', 'rb:UTF-16')
-#     f.external_encoding # => #<Encoding:UTF-16 (dummy)>
-#     f.internal_encoding # => nil
-#     f = File.new('t.dat', 'rb:UTF-16:UTF-16')
-#     f.external_encoding # => #<Encoding:UTF-16 (dummy)>
-#     f.internal_encoding # => #<Encoding:UTF-16>
-#
-# The numerous encoding names are available in array Encoding.name_list:
-#
-#     Encoding.name_list.size    # => 175
-#     Encoding.name_list.take(3) # => ["ASCII-8BIT", "UTF-8", "US-ASCII"]
-#
-# ## Encodings
-#
-# When the external encoding is set, strings read are tagged by that encoding
-# when reading, and strings written are converted to that encoding when writing.
-#
-# When both external and internal encodings are set, strings read are converted
-# from external to internal encoding, and strings written are converted from
-# internal to external encoding. For further details about transcoding input and
-# output, see Encoding.
-#
-# If the external encoding is `'BOM|UTF-8'`, `'BOM|UTF-16LE'` or
-# `'BOM|UTF16-BE'`, Ruby checks for a Unicode BOM in the input document to help
-# determine the encoding.  For UTF-16 encodings the file open mode must be
-# binary. If the BOM is found, it is stripped and the external encoding from the
-# BOM is used.
-#
-# Note that the BOM-style encoding option is case insensitive, so 'bom|utf-8' is
-# also valid.)
-#
-# ## Open Options
-#
-# A number of IO methods accept an optional parameter `opts`, which determines
-# how a new stream is to be opened:
-#
-# *   `:mode`: Stream mode.
-# *   `:flags`: Integer file open flags; If `mode` is also given, the two are
-#     bitwise-ORed.
-# *   `:external_encoding`: External encoding for the stream.
-# *   `:internal_encoding`: Internal encoding for the stream. `'-'` is a synonym
-#     for the default internal encoding. If the value is `nil` no conversion
-#     occurs.
-# *   `:encoding`: Specifies external and internal encodings as
-#     `'extern:intern'`.
-# *   `:textmode`: If a truthy value, specifies the mode as text-only, binary
-#     otherwise.
-# *   `:binmode`: If a truthy value, specifies the mode as binary, text-only
-#     otherwise.
-# *   `:autoclose`: If a truthy value, specifies that the `fd` will close when
-#     the stream closes; otherwise it remains open.
-#
-#
-# Also available are the options offered in String#encode, which may control
-# conversion between external internal encoding.
-#
-# ## Getline Options
-#
-# A number of IO methods accept optional keyword arguments that determine how a
-# stream is to be treated:
-#
-# *   `:chomp`: If `true`, line separators are omitted; default is  `false`.
-#
-#
-# ## Position
-#
-# An IO stream has a *position*, which is the non-negative integer offset (in
-# bytes) in the stream where the next read or write will occur.
-#
-# Note that a text stream may have multi-byte characters, so a text stream whose
-# position is `n` (*bytes*) may not have `n` *characters* preceding the current
-# position -- there may be fewer.
-#
-# A new stream is initially positioned:
-#
-# *   At the beginning (position `0`) if its mode is `'r'`, `'w'`, or `'r+'`.
-# *   At the end (position `self.size`) if its mode is `'a'`, `'w+'`, or `'a+'`.
-#
-#
-# Methods to query the position:
-#
-# *   IO#tell and its alias IO#pos return the position for an open stream.
-# *   IO#eof? and its alias IO#eof return whether the position is at the end of
-#     a readable stream.
-#
-#
-# Reading from a stream usually changes its position:
-#
-#     f = File.open('t.txt')
-#     f.tell     # => 0
-#     f.readline # => "This is line one.\n"
-#     f.tell     # => 19
-#     f.readline # => "This is the second line.\n"
-#     f.tell     # => 45
-#     f.eof?     # => false
-#     f.readline # => "Here's the third line.\n"
-#     f.eof?     # => true
-#
-# Writing to a stream usually changes its position:
-#
-#     f = File.open('t.tmp', 'w')
-#     f.tell         # => 0
-#     f.write('foo') # => 3
-#     f.tell         # => 3
-#     f.write('bar') # => 3
-#     f.tell         # => 6
-#
-# Iterating over a stream usually changes its position:
-#
-#     f = File.open('t.txt')
-#     f.each do |line|
-#       p "position=#{f.pos} eof?=#{f.eof?} line=#{line}"
-#     end
-#
-# Output:
-#
-#     "position=19 eof?=false line=This is line one.\n"
-#     "position=45 eof?=false line=This is the second line.\n"
-#     "position=70 eof?=true line=This is the third line.\n"
-#
-# The position may also be changed by certain other methods:
-#
-# *   IO#pos= and IO#seek change the position to a specified offset.
-# *   IO#rewind changes the position to the beginning.
-#
-#
-# ## Line Number
-#
-# A readable IO stream has a *line* *number*, which is the non-negative integer
-# line number in the stream where the next read will occur.
-#
-# A new stream is initially has line number `0`.
-#
-# Method IO#lineno returns the line number.
-#
-# Reading lines from a stream usually changes its line number:
-#
-#     f = File.open('t.txt', 'r')
-#     f.lineno   # => 0
-#     f.readline # => "This is line one.\n"
-#     f.lineno   # => 1
-#     f.readline # => "This is the second line.\n"
-#     f.lineno   # => 2
-#     f.readline # => "Here's the third line.\n"
-#     f.lineno   # => 3
-#     f.eof?     # => true
-#
-# Iterating over lines in a stream usually changes its line number:
-#
-#     f = File.open('t.txt')
-#     f.each_line do |line|
-#       p "position=#{f.pos} eof?=#{f.eof?} line=#{line}"
-#     end
-#
-# Output:
-#
-#     "position=19 eof?=false line=This is line one.\n"
-#     "position=45 eof?=false line=This is the second line.\n"
-#     "position=70 eof?=true line=This is the third line.\n"
-#
-# ## What's Here
-#
-# First, what's elsewhere. Class IO:
-#
-# *   Inherits from [class
-#     Object](Object.html#class-Object-label-What-27s+Here).
-# *   Includes [module
-#     Enumerable](Enumerable.html#module-Enumerable-label-What-27s+Here), which
-#     provides dozens of additional methods.
-#
-#
-# Here, class IO provides methods that are useful for:
-#
-# *   [Creating](#class-IO-label-Creating)
-# *   [Reading](#class-IO-label-Reading)
-# *   [Writing](#class-IO-label-Writing)
-# *   [Positioning](#class-IO-label-Positioning)
-# *   [Iterating](#class-IO-label-Iterating)
-# *   [Settings](#class-IO-label-Settings)
-# *   [Querying](#class-IO-label-Querying)
-# *   [Buffering](#class-IO-label-Buffering)
-# *   [Low-Level Access](#class-IO-label-Low-Level+Access)
-# *   [Other](#class-IO-label-Other)
-#
-#
-# ### Creating
-#
-#     ::new (aliased as ::for_fd)
-# :       Creates and returns a new IO object for the given integer file
-#         descriptor.
-#
-#     ::open
-# :       Creates a new IO object.
-#
-#     ::pipe
-# :       Creates a connected pair of reader and writer IO objects.
-#
-#     ::popen
-# :       Creates an IO object to interact with a subprocess.
-#
-#     ::select
-# :       Selects which given IO instances are ready for reading,
-#
-#     writing, or have pending exceptions.
-#
-#
-# ### Reading
-#
-#     ::binread
-# :       Returns a binary string with all or a subset of bytes from the given
-#         file.
-#
-#     ::read
-# :       Returns a string with all or a subset of bytes from the given file.
-#
-#     ::readlines
-# :       Returns an array of strings, which are the lines from the given file.
-#
-#     #getbyte
-# :       Returns the next 8-bit byte read from `self` as an integer.
-#
-#     #getc
-# :       Returns the next character read from `self` as a string.
-#
-#     #gets
-# :       Returns the line read from `self`.
-#
-#     #pread
-# :       Returns all or the next *n* bytes read from `self`, not updating the
-#         receiver's offset.
-#
-#     #read
-# :       Returns all remaining or the next *n* bytes read from `self` for a
-#         given *n*.
-#
-#     #read_nonblock
-# :       the next *n* bytes read from `self` for a given *n*, in non-block
-#         mode.
-#
-#     #readbyte
-# :       Returns the next byte read from `self`; same as #getbyte, but raises
-#         an exception on end-of-file.
-#
-#     #readchar
-# :       Returns the next character read from `self`; same as #getc, but raises
-#         an exception on end-of-file.
-#
-#     #readline
-# :       Returns the next line read from `self`; same as #getline, but raises
-#         an exception of end-of-file.
-#
-#     #readlines
-# :       Returns an array of all lines read read from `self`.
-#
-#     #readpartial
-# :       Returns up to the given number of bytes from `self`.
-#
-#
-#
-# ### Writing
-#
-#     ::binwrite
-# :       Writes the given string to the file at the given filepath, in binary
-#         mode.
-#
-#     ::write
-# :       Writes the given string to `self`.
-#
-#     [:<<](#method-i-3C-3C)
-# :       Appends the given string to `self`.
-#
-#     #print
-# :       Prints last read line or given objects to `self`.
-#
-#     #printf
-# :       Writes to `self` based on the given format string and objects.
-#
-#     #putc
-# :       Writes a character to `self`.
-#
-#     #puts
-# :       Writes lines to `self`, making sure line ends with a newline.
-#
-#     #pwrite
-# :       Writes the given string at the given offset, not updating the
-#         receiver's offset.
-#
-#     #write
-# :       Writes one or more given strings to `self`.
-#
-#     #write_nonblock
-# :       Writes one or more given strings to `self` in non-blocking mode.
-#
-#
-#
-# ### Positioning
-#
-#     #lineno
-# :       Returns the current line number in `self`.
-#
-#     #lineno=
-# :       Sets the line number is `self`.
-#
-#     #pos (aliased as #tell)
-# :       Returns the current byte offset in `self`.
-#
-#     #pos=
-# :       Sets the byte offset in `self`.
-#
-#     #reopen
-# :       Reassociates `self` with a new or existing IO stream.
-#
-#     #rewind
-# :       Positions `self` to the beginning of input.
-#
-#     #seek
-# :       Sets the offset for `self` relative to given position.
-#
-#
-#
-# ### Iterating
-#
-#     ::foreach
-# :       Yields each line of given file to the block.
-#
-#     #each (aliased as #each_line)
-# :       Calls the given block with each successive line in `self`.
-#
-#     #each_byte
-# :       Calls the given block with each successive byte in `self` as an
-#         integer.
-#
-#     #each_char
-# :       Calls the given block with each successive character in `self` as a
-#         string.
-#
-#     #each_codepoint
-# :       Calls the given block with each successive codepoint in `self` as an
-#         integer.
-#
-#
-#
-# ### Settings
-#
-#     #autoclose=
-# :       Sets whether `self` auto-closes.
-#
-#     #binmode
-# :       Sets `self` to binary mode.
-#
-#     #close
-# :       Closes `self`.
-#
-#     #close_on_exec=
-# :       Sets the close-on-exec flag.
-#
-#     #close_read
-# :       Closes `self` for reading.
-#
-#     #close_write
-# :       Closes `self` for writing.
-#
-#     #set_encoding
-# :       Sets the encoding for `self`.
-#
-#     #set_encoding_by_bom
-# :       Sets the encoding for `self`, based on its Unicode byte-order-mark.
-#
-#     #sync=
-# :       Sets the sync-mode to the given value.
-#
-#
-#
-# ### Querying
-#
-#     #autoclose?
-# :       Returns whether `self` auto-closes.
-#
-#     #binmode?
-# :       Returns whether `self` is in binary mode.
-#
-#     #close_on_exec?
-# :       Returns the close-on-exec flag for `self`.
-#
-#     #closed?
-# :       Returns whether `self` is closed.
-#
-#     #eof? (aliased as #eof)
-# :       Returns whether `self` is at end-of-file.
-#
-#     #external_encoding
-# :       Returns the external encoding object for `self`.
-#
-#     #fileno (aliased as #to_i)
-# :       Returns the integer file descriptor for `self`
-#
-#     #internal_encoding
-# :       Returns the internal encoding object for `self`.
-#
-#     #pid
-# :       Returns the process ID of a child process associated with `self`, if
-#         `self` was created by ::popen.
-#
-#     #stat
-# :       Returns the File::Stat object containing status information for
-#         `self`.
-#
-#     #sync
-# :       Returns whether `self` is in sync-mode.
-#
-#     #tty (aliased as #isatty)
-# :       Returns whether `self` is a terminal.
-#
-#
-#
-# ### Buffering
-#
-#     #fdatasync
-# :       Immediately writes all buffered data in `self` to disk.
-#
-#     #flush
-# :       Flushes any buffered data within `self` to the underlying operating
-#         system.
-#
-#     #fsync
-# :       Immediately writes all buffered data and attributes in `self` to disk.
-#
-#     #ungetbyte
-# :       Prepends buffer for `self` with given integer byte or string.
-#
-#     #ungetc
-# :       Prepends buffer for `self` with given string.
-#
-#
-#
-# ### Low-Level Access
-#
-#     ::sysopen
-# :       Opens the file given by its path, returning the integer file
-#         descriptor.
-#
-#     #advise
-# :       Announces the intention to access data from `self` in a specific way.
-#
-#     #fcntl
-# :       Passes a low-level command to the file specified by the given file
-#         descriptor.
-#
-#     #ioctl
-# :       Passes a low-level command to the device specified by the given file
-#         descriptor.
-#
-#     #sysread
-# :       Returns up to the next *n* bytes read from self using a low-level
-#         read.
-#
-#     #sysseek
-# :       Sets the offset for `self`.
-#
-#     #syswrite
-# :       Writes the given string to `self` using a low-level write.
-#
-#
-#
-# ### Other
-#
-#     ::copy_stream
-# :       Copies data from a source to a destination, each of which is a
-#         filepath or an IO-like object.
-#
-#     ::try_convert
-# :       Returns a new IO object resulting from converting the given object.
-#
-#     #inspect
-# :       Returns the string representation of `self`.
-#
-%a{annotate:rdoc:source:from=io.c}
-class IO < Object
-  include File::Constants
-
-  include Enumerable[String]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - self << object -> self
-  # -->
-  # Writes the given `object` to `self`, which must be opened for writing (see
-  # [Modes](#class-IO-label-Modes)); returns `self`; if `object` is not a string,
-  # it is converted via method `to_s`:
-  #
-  #     $stdout << 'Hello' << ', ' << 'World!' << "\n"
-  #     $stdout << 'foo' << :bar << 2 << "\n"
-  #
-  # Output:
-  #
-  #     Hello, World!
-  #     foobar2
-  #
-  def <<: (_ToS obj) -> self
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.advise(advice, offset=0, len=0) -> nil
-  # -->
-  # Announce an intention to access data from the current file in a specific
-  # pattern. On platforms that do not support the *posix_fadvise(2)* system call,
-  # this method is a no-op.
-  #
-  # *advice* is one of the following symbols:
-  #
-  # :normal
-  # :   No advice to give; the default assumption for an open file.
-  # :sequential
-  # :   The data will be accessed sequentially with lower offsets read before
-  #     higher ones.
-  # :random
-  # :   The data will be accessed in random order.
-  # :willneed
-  # :   The data will be accessed in the near future.
-  # :dontneed
-  # :   The data will not be accessed in the near future.
-  # :noreuse
-  # :   The data will only be accessed once.
-  #
-  #
-  # The semantics of a piece of advice are platform-dependent. See *man 2
-  # posix_fadvise* for details.
-  #
-  # "data" means the region of the current file that begins at *offset* and
-  # extends for *len* bytes. If *len* is 0, the region ends at the last byte of
-  # the file. By default, both *offset* and *len* are 0, meaning that the advice
-  # applies to the entire file.
-  #
-  # If an error occurs, one of the following exceptions will be raised:
-  #
-  # IOError
-  # :   The IO stream is closed.
-  # Errno::EBADF
-  # :   The file descriptor of the current file is invalid.
-  # Errno::EINVAL
-  # :   An invalid value for *advice* was given.
-  # Errno::ESPIPE
-  # :   The file descriptor of the current file refers to a FIFO or pipe. (Linux
-  #     raises Errno::EINVAL in this case).
-  # TypeError
-  # :   Either *advice* was not a Symbol, or one of the other arguments was not an
-  #     Integer.
-  # RangeError
-  # :   One of the arguments given was too big/small.
-  #
-  # This list is not exhaustive; other Errno
-  # :   exceptions are also possible.
-  #
-  def advise: (:normal | :sequential | :random | :willneed | :dontneed | :noreuse advise, ?Integer offset, ?Integer len) -> nil
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - io.autoclose = bool    -> true or false
-  # -->
-  # Sets auto-close flag.
-  #
-  #     f = open("/dev/null")
-  #     IO.for_fd(f.fileno)
-  #     # ...
-  #     f.gets # may cause Errno::EBADF
-  #
-  #     f = open("/dev/null")
-  #     IO.for_fd(f.fileno).autoclose = false
-  #     # ...
-  #     f.gets # won't cause Errno::EBADF
-  #
-  def autoclose=: (boolish) -> untyped
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.autoclose?   -> true or false
-  # -->
-  # Returns `true` if the underlying file descriptor of *ios* will be closed
-  # automatically at its finalization, otherwise `false`.
-  #
-  def autoclose?: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.binmode    -> ios
-  # -->
-  # Puts *ios* into binary mode. Once a stream is in binary mode, it cannot be
-  # reset to nonbinary mode.
-  #
-  # *   newline conversion disabled
-  # *   encoding conversion disabled
-  # *   content is treated as ASCII-8BIT
-  #
-  def binmode: () -> self
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.binmode?    -> true or false
-  # -->
-  # Returns `true` if *ios* is binmode.
-  #
-  def binmode?: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.close   -> nil
-  # -->
-  # Closes *ios* and flushes any pending writes to the operating system. The
-  # stream is unavailable for any further data operations; an IOError is raised if
-  # such an attempt is made. I/O streams are automatically closed when they are
-  # claimed by the garbage collector.
-  #
-  # If *ios* is opened by IO.popen, #close sets `$?`.
-  #
-  # Calling this method on closed IO object is just ignored since Ruby 2.3.
-  #
-  def close: () -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.close_on_exec = bool    -> true or false
-  # -->
-  # Sets a close-on-exec flag.
-  #
-  #     f = open("/dev/null")
-  #     f.close_on_exec = true
-  #     system("cat", "/proc/self/fd/#{f.fileno}") # cat: /proc/self/fd/3: No such file or directory
-  #     f.closed?                #=> false
-  #
-  # Ruby sets close-on-exec flags of all file descriptors by default since Ruby
-  # 2.0.0. So you don't need to set by yourself. Also, unsetting a close-on-exec
-  # flag can cause file descriptor leak if another thread use fork() and exec()
-  # (via system() method for example). If you really needs file descriptor
-  # inheritance to child process, use spawn()'s argument such as fd=>fd.
-  #
-  def close_on_exec=: (boolish) -> untyped
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.close_on_exec?   -> true or false
-  # -->
-  # Returns `true` if *ios* will be closed on exec.
-  #
-  #     f = open("/dev/null")
-  #     f.close_on_exec?                 #=> false
-  #     f.close_on_exec = true
-  #     f.close_on_exec?                 #=> true
-  #     f.close_on_exec = false
-  #     f.close_on_exec?                 #=> false
-  #
-  def close_on_exec?: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.close_read    -> nil
-  # -->
-  # Closes the read end of a duplex I/O stream (i.e., one that contains both a
-  # read and a write stream, such as a pipe). Will raise an IOError if the stream
-  # is not duplexed.
-  #
-  #     f = IO.popen("/bin/sh","r+")
-  #     f.close_read
-  #     f.readlines
-  #
-  # *produces:*
-  #
-  #     prog.rb:3:in `readlines': not opened for reading (IOError)
-  #      from prog.rb:3
-  #
-  # Calling this method on closed IO object is just ignored since Ruby 2.3.
-  #
-  def close_read: () -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.close_write   -> nil
-  # -->
-  # Closes the write end of a duplex I/O stream (i.e., one that contains both a
-  # read and a write stream, such as a pipe). Will raise an IOError if the stream
-  # is not duplexed.
-  #
-  #     f = IO.popen("/bin/sh","r+")
-  #     f.close_write
-  #     f.print "nowhere"
-  #
-  # *produces:*
-  #
-  #     prog.rb:3:in `write': not opened for writing (IOError)
-  #      from prog.rb:3:in `print'
-  #      from prog.rb:3
-  #
-  # Calling this method on closed IO object is just ignored since Ruby 2.3.
-  #
-  def close_write: () -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.closed?    -> true or false
-  # -->
-  # Returns `true` if *ios* is completely closed (for duplex streams, both reader
-  # and writer), `false` otherwise.
-  #
-  #     f = File.new("testfile")
-  #     f.close         #=> nil
-  #     f.closed?       #=> true
-  #     f = IO.popen("/bin/sh","r+")
-  #     f.close_write   #=> nil
-  #     f.closed?       #=> false
-  #     f.close_read    #=> nil
-  #     f.closed?       #=> true
-  #
-  def closed?: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.each(sep=$/ [, getline_args])          {|line| block } -> ios
-  #   - ios.each(limit [, getline_args])           {|line| block } -> ios
-  #   - ios.each(sep, limit [, getline_args])      {|line| block } -> ios
-  #   - ios.each(...)                             -> an_enumerator
-  #   - ios.each_line(sep=$/ [, getline_args])     {|line| block } -> ios
-  #   - ios.each_line(limit [, getline_args])      {|line| block } -> ios
-  #   - ios.each_line(sep, limit [, getline_args]) {|line| block } -> ios
-  #   - ios.each_line(...)                        -> an_enumerator
-  # -->
-  # Executes the block for every line in *ios*, where lines are separated by
-  # *sep*. *ios* must be opened for reading or an IOError will be raised.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  #     f = File.new("testfile")
-  #     f.each {|line| puts "#{f.lineno}: #{line}" }
-  #
-  # *produces:*
-  #
-  #     1: This is line one
-  #     2: This is line two
-  #     3: This is line three
-  #     4: And so on...
-  #
-  # See IO.readlines for details about getline_args.
-  #
-  def each: (?String sep, ?Integer limit) { (String arg0) -> untyped } -> self
-          | (?String sep, ?Integer limit) -> ::Enumerator[String, self]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.each_byte {|byte| block }  -> ios
-  #   - ios.each_byte                  -> an_enumerator
-  # -->
-  # Calls the given block once for each byte (0..255) in *ios*, passing the byte
-  # as an argument. The stream must be opened for reading or an IOError will be
-  # raised.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  #     f = File.new("testfile")
-  #     checksum = 0
-  #     f.each_byte {|x| checksum ^= x }   #=> #<File:testfile>
-  #     checksum                           #=> 12
-  #
-  def each_byte: () { (Integer arg0) -> untyped } -> self
-               | () -> ::Enumerator[Integer, self]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.each_char {|c| block }  -> ios
-  #   - ios.each_char               -> an_enumerator
-  # -->
-  # Calls the given block once for each character in *ios*, passing the character
-  # as an argument. The stream must be opened for reading or an IOError will be
-  # raised.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  #     f = File.new("testfile")
-  #     f.each_char {|c| print c, ' ' }   #=> #<File:testfile>
-  #
-  def each_char: () { (String arg0) -> untyped } -> self
-               | () -> ::Enumerator[String, self]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.each_codepoint {|c| block }  -> ios
-  #   - ios.each_codepoint               -> an_enumerator
-  # -->
-  # Passes the Integer ordinal of each character in *ios*, passing the codepoint
-  # as an argument. The stream must be opened for reading or an IOError will be
-  # raised.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  def each_codepoint: () { (Integer arg0) -> untyped } -> self
-                    | () -> ::Enumerator[Integer, self]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - eof -> true or false
-  # -->
-  # Returns `true` if the stream is positioned at its end, `false` otherwise; see
-  # [Position](#class-IO-label-Position):
-  #
-  #     f = File.open('t.txt')
-  #     f.eof           # => false
-  #     f.seek(0, :END) # => 0
-  #     f.eof           # => true
-  #
-  # Raises an exception unless the stream is opened for reading; see
-  # [Mode](#class-IO-label-Mode).
-  #
-  # If `self` is a stream such as pipe or socket, this method blocks until the
-  # other end sends some data or closes it:
-  #
-  #     r, w = IO.pipe
-  #     Thread.new { sleep 1; w.close }
-  #     r.eof? # => true # After 1-second wait.
-  #
-  #     r, w = IO.pipe
-  #     Thread.new { sleep 1; w.puts "a" }
-  #     r.eof?  # => false # After 1-second wait.
-  #
-  #     r, w = IO.pipe
-  #     r.eof?  # blocks forever
-  #
-  # Note that this method reads data to the input byte buffer.  So IO#sysread may
-  # not behave as you intend with IO#eof?, unless you call IO#rewind first (which
-  # is not available for some streams).
-  #
-  # I#eof? is an alias for IO#eof.
-  #
-  def eof: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.fcntl(integer_cmd, arg)    -> integer
-  # -->
-  # Provides a mechanism for issuing low-level commands to control or query
-  # file-oriented I/O streams. Arguments and results are platform dependent. If
-  # *arg* is a number, its value is passed directly. If it is a string, it is
-  # interpreted as a binary sequence of bytes (Array#pack might be a useful way to
-  # build this string). On Unix platforms, see `fcntl(2)` for details.  Not
-  # implemented on all platforms.
-  #
-  def fcntl: (Integer integer_cmd, String | Integer arg) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - fdatasync -> 0
-  # -->
-  # Immediately writes to disk all data buffered in the stream, via the operating
-  # system's: `fdatasync(2)`, if supported, otherwise via `fsync(2)`, if
-  # supported; otherwise raises an exception.
-  #
-  def fdatasync: () -> Integer?
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - fileno -> integer
-  # -->
-  # Returns the integer file descriptor for the stream:
-  #
-  #     $stdin.fileno             # => 0
-  #     $stdout.fileno            # => 1
-  #     $stderr.fileno            # => 2
-  #     File.open('t.txt').fileno # => 10
-  #
-  # IO#to_i is an alias for IO#fileno.
-  #
-  def fileno: () -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - flush -> self
-  # -->
-  # Flushes data buffered in `self` to the operating system (but does not
-  # necessarily flush data buffered in the operating system):
-  #
-  #     $stdout.print 'no newline' # Not necessarily flushed.
-  #     $stdout.flush              # Flushed.
-  #
-  def flush: () -> self
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - fsync -> 0
-  # -->
-  # Immediately writes to disk all data buffered in the stream, via the operating
-  # system's `fsync(2)`.
-  #
-  # Note this difference:
-  #
-  # *   IO#sync=: Ensures that data is flushed from the stream's internal buffers,
-  #     but does not guarantee that the operating system actually writes the data
-  #     to disk.
-  # *   IO#fsync: Ensures both that data is flushed from internal buffers, and
-  #     that data is written to disk.
-  #
-  #
-  # Raises an exception if the operating system does not support `fsync(2)`.
-  #
-  def fsync: () -> Integer?
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.getbyte   -> integer or nil
-  # -->
-  # Gets the next 8-bit byte (0..255) from *ios*. Returns `nil` if called at end
-  # of file.
-  #
-  #     f = File.new("testfile")
-  #     f.getbyte   #=> 84
-  #     f.getbyte   #=> 104
-  #
-  def getbyte: () -> Integer?
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.getc   -> string or nil
-  # -->
-  # Reads a one-character string from *ios*. Returns `nil` if called at end of
-  # file.
-  #
-  #     f = File.new("testfile")
-  #     f.getc   #=> "h"
-  #     f.getc   #=> "e"
-  #
-  def getc: () -> String?
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - gets(sep = $/, **getline_opts)   -> string or nil
-  #   - gets(limit, **getline_opts)      -> string or nil
-  #   - gets(sep, limit, **getline_opts) -> string or nil
-  # -->
-  # Reads and returns data from the stream; assigns the return value to `$_`.
-  #
-  # With no arguments given, returns the next line as determined by line separator
-  # `$/`, or `nil` if none:
-  #
-  #     f = File.open('t.txt')
-  #     f.gets # => "This is line one.\n"
-  #     $_     # => "This is line one.\n"
-  #     f.gets # => "This is the second line.\n"
-  #     f.gets # => "This is the third line.\n"
-  #     f.gets # => nil
-  #
-  # With string argument `sep` given, but not argument `limit`, returns the next
-  # line as determined by line separator `sep`, or `nil` if none:
-  #
-  #     f = File.open('t.txt')
-  #     f.gets(' is') # => "This is"
-  #     f.gets(' is') # => " line one.\nThis is"
-  #     f.gets(' is') # => " the second line.\nThis is"
-  #     f.gets(' is') # => " the third line.\n"
-  #     f.gets(' is') # => nil
-  #
-  # Note two special values for `sep`:
-  #
-  # *   `nil`: The entire stream is read and returned.
-  # *   `''` (empty string): The next "paragraph" is read and returned, the
-  #     paragraph separator being two successive line separators.
-  #
-  #
-  # With integer argument `limit` given, returns up to `limit+1` bytes:
-  #
-  #     # Text with 1-byte characters.
-  #     File.open('t.txt') {|f| f.gets(1) } # => "T"
-  #     File.open('t.txt') {|f| f.gets(2) } # => "Th"
-  #     File.open('t.txt') {|f| f.gets(3) } # => "Thi"
-  #     File.open('t.txt') {|f| f.gets(4) } # => "This"
-  #     # No more than one line.
-  #     File.open('t.txt') {|f| f.gets(17) } # => "This is line one."
-  #     File.open('t.txt') {|f| f.gets(18) } # => "This is line one.\n"
-  #     File.open('t.txt') {|f| f.gets(19) } # => "This is line one.\n"
-  #
-  #     # Text with 2-byte characters, which will not be split.
-  #     File.open('t.rus') {|f| f.gets(1).size } # => 1
-  #     File.open('t.rus') {|f| f.gets(2).size } # => 1
-  #     File.open('t.rus') {|f| f.gets(3).size } # => 2
-  #     File.open('t.rus') {|f| f.gets(4).size } # => 2
-  #
-  # With arguments `sep` and `limit`, combines the two behaviors above:
-  #
-  # *   Returns the next line as determined by line separator `sep`, or `nil` if
-  #     none.
-  # *   But returns no more than `limit+1` bytes.
-  #
-  #
-  # For all forms above, trailing optional keyword arguments may be given; see
-  # [Getline Options](#class-IO-label-Getline+Options):
-  #
-  #     f = File.open('t.txt')
-  #     # Chomp the lines.
-  #     f.gets(chomp: true) # => "This is line one."
-  #     f.gets(chomp: true) # => "This is the second line."
-  #     f.gets(chomp: true) # => "This is the third line."
-  #     f.gets(chomp: true) # => nil
-  #
-  def gets: (?String sep, ?Integer limit) -> String?
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.new(fd [, mode] [, opt])   -> io
-  # -->
-  # Returns a new IO object (a stream) for the given integer file descriptor `fd`
-  # and `mode` string.  `opt` may be used to specify parts of `mode` in a more
-  # readable fashion.  See also IO.sysopen and IO.for_fd.
-  #
-  # IO.new is called by various File and IO opening methods such as IO::open,
-  # Kernel#open, and File::open.
-  #
-  # ### Open Mode
-  #
-  # When `mode` is an integer it must be combination of the modes defined in
-  # File::Constants (`File::RDONLY`, `File::WRONLY|File::CREAT`). See the open(2)
-  # man page for more information.
-  #
-  # When `mode` is a string it must be in one of the following forms:
-  #
-  #     fmode
-  #     fmode ":" ext_enc
-  #     fmode ":" ext_enc ":" int_enc
-  #     fmode ":" "BOM|UTF-*"
-  #
-  # `fmode` is an IO open mode string, `ext_enc` is the external encoding for the
-  # IO and `int_enc` is the internal encoding.
-  #
-  # #### IO Open Mode
-  #
-  # Ruby allows the following open modes:
-  #
-  #     "r"  Read-only, starts at beginning of file  (default mode).
-  #
-  #     "r+" Read-write, starts at beginning of file.
-  #
-  #     "w"  Write-only, truncates existing file
-  #          to zero length or creates a new file for writing.
-  #
-  #     "w+" Read-write, truncates existing file to zero length
-  #          or creates a new file for reading and writing.
-  #
-  #     "a"  Write-only, each write call appends data at end of file.
-  #          Creates a new file for writing if file does not exist.
-  #
-  #     "a+" Read-write, each write call appends data at end of file.
-  #          Creates a new file for reading and writing if file does
-  #          not exist.
-  #
-  # The following modes must be used separately, and along with one or more of the
-  # modes seen above.
-  #
-  #     "b"  Binary file mode
-  #          Suppresses EOL <-> CRLF conversion on Windows. And
-  #          sets external encoding to ASCII-8BIT unless explicitly
-  #          specified.
-  #
-  #     "t"  Text file mode
-  #
-  # The exclusive access mode ("x") can be used together with "w" to ensure the
-  # file is created. Errno::EEXIST is raised when it already exists. It may not be
-  # supported with all kinds of streams (e.g. pipes).
-  #
-  # When the open mode of original IO is read only, the mode cannot be changed to
-  # be writable.  Similarly, the open mode cannot be changed from write only to
-  # readable.
-  #
-  # When such a change is attempted the error is raised in different locations
-  # according to the platform.
-  #
-  # ### IO Encoding
-  #
-  # When `ext_enc` is specified, strings read will be tagged by the encoding when
-  # reading, and strings output will be converted to the specified encoding when
-  # writing.
-  #
-  # When `ext_enc` and `int_enc` are specified read strings will be converted from
-  # `ext_enc` to `int_enc` upon input, and written strings will be converted from
-  # `int_enc` to `ext_enc` upon output.  See Encoding for further details of
-  # transcoding on input and output.
-  #
-  # If "BOM|UTF-8", "BOM|UTF-16LE" or "BOM|UTF16-BE" are used, Ruby checks for a
-  # Unicode BOM in the input document to help determine the encoding.  For UTF-16
-  # encodings the file open mode must be binary.  When present, the BOM is
-  # stripped and the external encoding from the BOM is used.  When the BOM is
-  # missing the given Unicode encoding is used as `ext_enc`.  (The BOM-set
-  # encoding option is case insensitive, so "bom|utf-8" is also valid.)
-  #
-  # ### Options
-  #
-  # `opt` can be used instead of `mode` for improved readability.  The following
-  # keys are supported:
-  #
-  # :mode
-  # :   Same as `mode` parameter
-  #
-  # :flags
-  # :   Specifies file open flags as integer. If `mode` parameter is given, this
-  #     parameter will be bitwise-ORed.
-  #
-  # :external_encoding
-  # :   External encoding for the IO.
-  #
-  # :internal_encoding
-  # :   Internal encoding for the IO.  "-" is a synonym for the default internal
-  #     encoding.
-  #
-  #     If the value is `nil` no conversion occurs.
-  #
-  # :encoding
-  # :   Specifies external and internal encodings as "extern:intern".
-  #
-  # :textmode
-  # :   If the value is truth value, same as "t" in argument `mode`.
-  #
-  # :binmode
-  # :   If the value is truth value, same as "b" in argument `mode`.
-  #
-  # :autoclose
-  # :   If the value is `false`, the `fd` will be kept open after this IO instance
-  #     gets finalized.
-  #
-  #
-  # Also, `opt` can have same keys in String#encode for controlling conversion
-  # between the external encoding and the internal encoding.
-  #
-  # ### Example 1
-  #
-  #     fd = IO.sysopen("/dev/tty", "w")
-  #     a = IO.new(fd,"w")
-  #     $stderr.puts "Hello"
-  #     a.puts "World"
-  #
-  # Produces:
-  #
-  #     Hello
-  #     World
-  #
-  # ### Example 2
-  #
-  #     require 'fcntl'
-  #
-  #     fd = STDERR.fcntl(Fcntl::F_DUPFD)
-  #     io = IO.new(fd, mode: 'w:UTF-16LE', cr_newline: true)
-  #     io.puts "Hello, World!"
-  #
-  #     fd = STDERR.fcntl(Fcntl::F_DUPFD)
-  #     io = IO.new(fd, mode: 'w', cr_newline: true,
-  #                 external_encoding: Encoding::UTF_16LE)
-  #     io.puts "Hello, World!"
-  #
-  # Both of above print "Hello, World!" in UTF-16LE to standard error output with
-  # converting EOL generated by #puts to CR.
-  #
-  def initialize: (Integer fd, ?Integer mode, ?Integer opt) -> void
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - inspect -> string
-  # -->
-  # Returns a string representation of `self`:
-  #
-  #     f = File.open('t.txt')
-  #     f.inspect # => "#<File:t.txt>"
-  #
-  def inspect: () -> String
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - io.internal_encoding   -> encoding
-  # -->
-  # Returns the Encoding of the internal string if conversion is specified.
-  # Otherwise returns `nil`.
-  #
-  def internal_encoding: () -> Encoding
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.ioctl(integer_cmd, arg)    -> integer
-  # -->
-  # Provides a mechanism for issuing low-level commands to control or query I/O
-  # devices. Arguments and results are platform dependent. If *arg* is a number,
-  # its value is passed directly. If it is a string, it is interpreted as a binary
-  # sequence of bytes. On Unix platforms, see `ioctl(2)` for details. Not
-  # implemented on all platforms.
-  #
-  def ioctl: (Integer integer_cmd, String | Integer arg) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.isatty   -> true or false
-  #   - ios.tty?     -> true or false
-  # -->
-  # Returns `true` if *ios* is associated with a terminal device (tty), `false`
-  # otherwise.
-  #
-  #     File.new("testfile").isatty   #=> false
-  #     File.new("/dev/tty").isatty   #=> true
-  #
-  def isatty: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.lineno    -> integer
-  # -->
-  # Returns the current line number in *ios*.  The stream must be opened for
-  # reading. #lineno counts the number of times #gets is called rather than the
-  # number of newlines encountered.  The two values will differ if #gets is called
-  # with a separator other than newline.
-  #
-  # Methods that use `$/` like #each, #lines and #readline will also increment
-  # #lineno.
-  #
-  # See also the `$.` variable.
-  #
-  #     f = File.new("testfile")
-  #     f.lineno   #=> 0
-  #     f.gets     #=> "This is line one\n"
-  #     f.lineno   #=> 1
-  #     f.gets     #=> "This is line two\n"
-  #     f.lineno   #=> 2
-  #
-  def lineno: () -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.lineno = integer    -> integer
-  # -->
-  # Manually sets the current line number to the given value. `$.` is updated only
-  # on the next read.
-  #
-  #     f = File.new("testfile")
-  #     f.gets                     #=> "This is line one\n"
-  #     $.                         #=> 1
-  #     f.lineno = 1000
-  #     f.lineno                   #=> 1000
-  #     $.                         #=> 1         # lineno of last read
-  #     f.gets                     #=> "This is line two\n"
-  #     $.                         #=> 1001      # lineno of last read
-  #
-  def lineno=: (Integer arg0) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - pid -> integer or nil
-  # -->
-  # Returns the process ID of a child process associated with the stream, which
-  # will have been set by IO#popen, or `nil` if the stream was not created by
-  # IO#popen:
-  #
-  #     pipe = IO.popen("-")
-  #     if pipe
-  #       $stderr.puts "In parent, child pid is #{pipe.pid}"
-  #     else
-  #       $stderr.puts "In child, pid is #{$$}"
-  #     end
-  #
-  # Output:
-  #
-  #     In child, pid is 26209
-  #     In parent, child pid is 26209
-  #
-  def pid: () -> Integer
-
-  # <!-- rdoc-file=io.c -->
-  # Returns the current position (in bytes) in `self` (see
-  # [Position](#class-IO-label-Position)):
-  #
-  #     f = File.new('t.txt')
-  #     f.tell     # => 0
-  #     f.readline # => "This is line one.\n"
-  #     f.tell     # => 19
-  #
-  # Related: IO#pos=, IO#seek.
-  #
-  # IO#pos is an alias for IO#tell.
-  #
-  def pos: () -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - pos = new_position -> new_position
-  # -->
-  # Seeks to the given `new_position` (in bytes); see
-  # [Position](#class-IO-label-Position):
-  #
-  #     f = File.open('t.txt')
-  #     f.tell     # => 0
-  #     f.pos = 20 # => 20
-  #     f.tell     # => 20
-  #
-  # Related: IO#seek, IO#tell.
-  #
-  def pos=: (Integer arg0) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.print               -> nil
-  #   - ios.print(obj, ...)     -> nil
-  # -->
-  # Writes the given object(s) to *ios*. Returns `nil`.
-  #
-  # The stream must be opened for writing. Each given object that isn't a string
-  # will be converted by calling its `to_s` method. When called without arguments,
-  # prints the contents of `$_`.
-  #
-  # If the output field separator (`$,`) is not `nil`, it is inserted between
-  # objects. If the output record separator (`$\`) is not `nil`, it is appended to
-  # the output.
-  #
-  #     $stdout.print("This is ", 100, " percent.\n")
-  #
-  # *produces:*
-  #
-  #     This is 100 percent.
-  #
-  def print: (*untyped arg0) -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.printf(format_string [, obj, ...])   -> nil
-  # -->
-  # Formats and writes to *ios*, converting parameters under control of the format
-  # string. See Kernel#sprintf for details.
-  #
-  def printf: (String format_string, *untyped arg0) -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.putc(obj)    -> obj
-  # -->
-  # If *obj* is Numeric, write the character whose code is the least-significant
-  # byte of *obj*.  If *obj* is String, write the first character of *obj* to
-  # *ios*.  Otherwise, raise TypeError.
-  #
-  #     $stdout.putc "A"
-  #     $stdout.putc 65
-  #
-  # *produces:*
-  #
-  #     AA
-  #
-  def putc: (Numeric | String arg0) -> untyped
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.puts(obj, ...)    -> nil
-  # -->
-  # Writes the given object(s) to *ios*. Writes a newline after any that do not
-  # already end with a newline sequence. Returns `nil`.
-  #
-  # The stream must be opened for writing. If called with an array argument,
-  # writes each element on a new line. Each given object that isn't a string or
-  # array will be converted by calling its `to_s` method. If called without
-  # arguments, outputs a single newline.
-  #
-  #     $stdout.puts("this", "is", ["a", "test"])
-  #
-  # *produces:*
-  #
-  #     this
-  #     is
-  #     a
-  #     test
-  #
-  # Note that `puts` always uses newlines and is not affected by the output record
-  # separator (`$\`).
-  #
-  def puts: (*untyped arg0) -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - read(maxlen = nil)             -> string or nil
-  #   - read(maxlen = nil, out_string) -> out_string or nil
-  # -->
-  # Reads bytes from the stream (in binary mode):
-  #
-  # *   If `maxlen` is `nil`, reads all bytes.
-  # *   Otherwise reads `maxlen` bytes, if available.
-  # *   Otherwise reads all bytes.
-  #
-  #
-  # Returns a string (either a new string or the given `out_string`) containing
-  # the bytes read. The encoding of the string depends on both `maxLen` and
-  # `out_string`:
-  #
-  # *   `maxlen` is `nil`: uses internal encoding of `self` (regardless of whether
-  #     `out_string` was given).
-  # *   `maxlen` not `nil`:
-  #
-  #     *   `out_string` given: encoding of `out_string` not modified.
-  #     *   `out_string` not given: ASCII-8BIT is used.
-  #
-  #
-  #
-  # **Without Argument `out_string`**
-  #
-  # When argument `out_string` is omitted, the returned value is a new string:
-  #
-  #     f = File.new('t.txt')
-  #     f.read
-  #     # => "This is line one.\nThis is the second line.\nThis is the third line.\n"
-  #     f.rewind
-  #     f.read(40)      # => "This is line one.\r\nThis is the second li"
-  #     f.read(40)      # => "ne.\r\nThis is the third line.\r\n"
-  #     f.read(40)      # => nil
-  #
-  # If `maxlen` is zero, returns an empty string.
-  #
-  # ** With Argument `out_string`**
-  #
-  # When argument `out_string` is given, the returned value is `out_string`, whose
-  # content is replaced:
-  #
-  #     f = File.new('t.txt')
-  #     s = 'foo'      # => "foo"
-  #     f.read(nil, s) # => "This is line one.\nThis is the second line.\nThis is the third line.\n"
-  #     s              # => "This is line one.\nThis is the second line.\nThis is the third line.\n"
-  #     f.rewind
-  #     s = 'bar'
-  #     f.read(40, s)  # => "This is line one.\r\nThis is the second li"
-  #     s              # => "This is line one.\r\nThis is the second li"
-  #     s = 'baz'
-  #     f.read(40, s)  # => "ne.\r\nThis is the third line.\r\n"
-  #     s              # => "ne.\r\nThis is the third line.\r\n"
-  #     s = 'bat'
-  #     f.read(40, s)  # => nil
-  #     s              # => ""
-  #
-  # Note that this method behaves like the fread() function in C. This means it
-  # retries to invoke read(2) system calls to read data with the specified maxlen
-  # (or until EOF).
-  #
-  # This behavior is preserved even if the stream is in non-blocking mode. (This
-  # method is non-blocking-flag insensitive as other methods.)
-  #
-  # If you need the behavior like a single read(2) system call, consider
-  # #readpartial, #read_nonblock, and #sysread.
-  #
-  def read: (?int? length, ?string outbuf) -> String?
-
-  # <!--
-  #   rdoc-file=io.rb
-  #   - ios.read_nonblock(maxlen [, options])              -> string
-  #   - ios.read_nonblock(maxlen, outbuf [, options])      -> outbuf
-  # -->
-  # Reads at most *maxlen* bytes from *ios* using the read(2) system call after
-  # O_NONBLOCK is set for the underlying file descriptor.
-  #
-  # If the optional *outbuf* argument is present, it must reference a String,
-  # which will receive the data. The *outbuf* will contain only the received data
-  # after the method call even if it is not empty at the beginning.
-  #
-  # read_nonblock just calls the read(2) system call. It causes all errors the
-  # read(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc. The caller
-  # should care such errors.
-  #
-  # If the exception is Errno::EWOULDBLOCK or Errno::EAGAIN, it is extended by
-  # IO::WaitReadable. So IO::WaitReadable can be used to rescue the exceptions for
-  # retrying read_nonblock.
-  #
-  # read_nonblock causes EOFError on EOF.
-  #
-  # On some platforms, such as Windows, non-blocking mode is not supported on IO
-  # objects other than sockets. In such cases, Errno::EBADF will be raised.
-  #
-  # If the read byte buffer is not empty, read_nonblock reads from the buffer like
-  # readpartial. In this case, the read(2) system call is not called.
-  #
-  # When read_nonblock raises an exception kind of IO::WaitReadable, read_nonblock
-  # should not be called until io is readable for avoiding busy loop. This can be
-  # done as follows.
-  #
-  #     # emulates blocking read (readpartial).
-  #     begin
-  #       result = io.read_nonblock(maxlen)
-  #     rescue IO::WaitReadable
-  #       IO.select([io])
-  #       retry
-  #     end
-  #
-  # Although IO#read_nonblock doesn't raise IO::WaitWritable.
-  # OpenSSL::Buffering#read_nonblock can raise IO::WaitWritable. If IO and SSL
-  # should be used polymorphically, IO::WaitWritable should be rescued too. See
-  # the document of OpenSSL::Buffering#read_nonblock for sample code.
-  #
-  # Note that this method is identical to readpartial except the non-blocking flag
-  # is set.
-  #
-  # By specifying a keyword argument *exception* to `false`, you can indicate that
-  # read_nonblock should not raise an IO::WaitReadable exception, but return the
-  # symbol `:wait_readable` instead. At EOF, it will return nil instead of raising
-  # EOFError.
-  #
-  def read_nonblock: (int len, ?string buf, ?exception: true) -> String
-                   | (int len, ?string buf, exception: false) -> (String | :wait_readable | nil)
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.readbyte   -> integer
-  # -->
-  # Reads a byte as with IO#getbyte, but raises an EOFError on end of file.
-  #
-  def readbyte: () -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.readchar   -> string
-  # -->
-  # Reads a one-character string from *ios*. Raises an EOFError on end of file.
-  #
-  #     f = File.new("testfile")
-  #     f.readchar   #=> "h"
-  #     f.readchar   #=> "e"
-  #
-  def readchar: () -> String
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.readline(sep=$/ [, getline_args])     -> string
-  #   - ios.readline(limit [, getline_args])      -> string
-  #   - ios.readline(sep, limit [, getline_args]) -> string
-  # -->
-  # Reads a line as with IO#gets, but raises an EOFError on end of file.
-  #
-  def readline: (?String sep, ?Integer limit) -> String
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.readlines(sep=$/ [, getline_args])     -> array
-  #   - ios.readlines(limit [, getline_args])      -> array
-  #   - ios.readlines(sep, limit [, getline_args]) -> array
-  # -->
-  # Reads all of the lines in *ios*, and returns them in an array. Lines are
-  # separated by the optional *sep*. If *sep* is `nil`, the rest of the stream is
-  # returned as a single record. If the first argument is an integer, or an
-  # optional second argument is given, the returning string would not be longer
-  # than the given value in bytes. The stream must be opened for reading or an
-  # IOError will be raised.
-  #
-  #     f = File.new("testfile")
-  #     f.readlines[0]   #=> "This is line one\n"
-  #
-  #     f = File.new("testfile", chomp: true)
-  #     f.readlines[0]   #=> "This is line one"
-  #
-  # See IO.readlines for details about getline_args.
-  #
-  def readlines: (?String sep, ?Integer limit) -> ::Array[String]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - readpartial(maxlen)             -> string
-  #   - readpartial(maxlen, out_string) -> out_string
-  # -->
-  # Reads up to `maxlen` bytes from the stream; returns a string (either a new
-  # string or the given `out_string`). Its encoding is:
-  #
-  # *   The unchanged encoding of `out_string`, if `out_string` is given.
-  # *   ASCII-8BIT, otherwise.
-  #
-  # *   Contains `maxlen` bytes from the stream, if available.
-  # *   Otherwise contains all available bytes, if any available.
-  # *   Otherwise is an empty string.
-  #
-  #
-  # With the single non-negative integer argument `maxlen` given, returns a new
-  # string:
-  #
-  #     f = File.new('t.txt')
-  #     f.readpartial(30) # => "This is line one.\nThis is the"
-  #     f.readpartial(30) # => " second line.\nThis is the thi"
-  #     f.readpartial(30) # => "rd line.\n"
-  #     f.eof             # => true
-  #     f.readpartial(30) # Raises EOFError.
-  #
-  # With both argument `maxlen` and string argument `out_string` given, returns
-  # modified `out_string`:
-  #
-  #     f = File.new('t.txt')
-  #     s = 'foo'
-  #     f.readpartial(30, s) # => "This is line one.\nThis is the"
-  #     s = 'bar'
-  #     f.readpartial(0, s)  # => ""
-  #
-  # This method is useful for a stream such as a pipe, a socket, or a tty. It
-  # blocks only when no data is immediately available. This means that it blocks
-  # only when *all* of the following are true:
-  #
-  # *   The byte buffer in the stream is empty.
-  # *   The content of the stream is empty.
-  # *   The stream is not at EOF.
-  #
-  #
-  # When blocked, the method waits for either more data or EOF on the stream:
-  #
-  # *   If more data is read, the method returns the data.
-  # *   If EOF is reached, the method raises EOFError.
-  #
-  #
-  # When not blocked, the method responds immediately:
-  #
-  # *   Returns data from the buffer if there is any.
-  # *   Otherwise returns data from the stream if there is any.
-  # *   Otherwise raises EOFError if the stream has reached EOF.
-  #
-  #
-  # Note that this method is similar to sysread. The differences are:
-  #
-  # *   If the byte buffer is not empty, read from the byte buffer instead of
-  #     "sysread for buffered IO (IOError)".
-  # *   It doesn't cause Errno::EWOULDBLOCK and Errno::EINTR.  When readpartial
-  #     meets EWOULDBLOCK and EINTR by read system call, readpartial retries the
-  #     system call.
-  #
-  #
-  # The latter means that readpartial is non-blocking-flag insensitive. It blocks
-  # on the situation IO#sysread causes Errno::EWOULDBLOCK as if the fd is blocking
-  # mode.
-  #
-  # Examples:
-  #
-  #     #                        # Returned      Buffer Content    Pipe Content
-  #     r, w = IO.pipe           #
-  #     w << 'abc'               #               ""                "abc".
-  #     r.readpartial(4096)      # => "abc"      ""                ""
-  #     r.readpartial(4096)      # (Blocks because buffer and pipe are empty.)
-  #
-  #     #                        # Returned      Buffer Content    Pipe Content
-  #     r, w = IO.pipe           #
-  #     w << 'abc'               #               ""                "abc"
-  #     w.close                  #               ""                "abc" EOF
-  #     r.readpartial(4096)      # => "abc"      ""                 EOF
-  #     r.readpartial(4096)      # raises EOFError
-  #
-  #     #                        # Returned      Buffer Content    Pipe Content
-  #     r, w = IO.pipe           #
-  #     w << "abc\ndef\n"        #               ""                "abc\ndef\n"
-  #     r.gets                   # => "abc\n"    "def\n"           ""
-  #     w << "ghi\n"             #               "def\n"           "ghi\n"
-  #     r.readpartial(4096)      # => "def\n"    ""                "ghi\n"
-  #     r.readpartial(4096)      # => "ghi\n"    ""                ""
-  #
-  def readpartial: (int maxlen, ?string outbuf) -> String
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.reopen(other_IO)             -> ios
-  #   - ios.reopen(path, mode [, opt])   -> ios
-  # -->
-  # Reassociates *ios* with the I/O stream given in *other_IO* or to a new stream
-  # opened on *path*. This may dynamically change the actual class of this stream.
-  # The `mode` and `opt` parameters accept the same values as IO.open.
-  #
-  #     f1 = File.new("testfile")
-  #     f2 = File.new("testfile")
-  #     f2.readlines[0]   #=> "This is line one\n"
-  #     f2.reopen(f1)     #=> #<File:testfile>
-  #     f2.readlines[0]   #=> "This is line one\n"
-  #
-  def reopen: (IO other_IO_or_path) -> IO
-            | (String other_IO_or_path, ?String mode_str) -> IO
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - rewind -> 0
-  # -->
-  # Repositions the stream to its beginning, setting both the position and the
-  # line number to zero; see [Position](#class-IO-label-Position) and [Line
-  # Number](#class-IO-label-Line+Number):
-  #
-  #     f = File.open('t.txt')
-  #     f.tell     # => 0
-  #     f.lineno   # => 0
-  #     f.readline # => "This is line one.\n"
-  #     f.tell     # => 19
-  #     f.lineno   # => 1
-  #     f.rewind   # => 0
-  #     f.tell     # => 0
-  #     f.lineno   # => 0
-  #
-  # Note that this method cannot be used with streams such as pipes, ttys, and
-  # sockets.
-  #
-  def rewind: () -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - seek(offset, whence = IO::SEEK_SET) -> 0
-  # -->
-  # Seeks to the position given by integer `offset` (see
-  # [Position](#class-IO-label-Position)) and constant `whence`, which is one of:
-  #
-  # *   `:CUR` or `IO::SEEK_CUR`: Repositions the stream to its current position
-  #     plus the given `offset`:
-  #
-  #         f = File.open('t.txt')
-  #         f.tell            # => 0
-  #         f.seek(20, :CUR)  # => 0
-  #         f.tell            # => 20
-  #         f.seek(-10, :CUR) # => 0
-  #         f.tell            # => 10
-  #
-  # *   `:END` or `IO::SEEK_END`: Repositions the stream to its end plus the given
-  #     `offset`:
-  #
-  #         f = File.open('t.txt')
-  #         f.tell            # => 0
-  #         f.seek(0, :END)   # => 0  # Repositions to stream end.
-  #         f.tell            # => 70
-  #         f.seek(-20, :END) # => 0
-  #         f.tell            # => 50
-  #         f.seek(-40, :END) # => 0
-  #         f.tell            # => 30
-  #
-  # *   `:SET` or `IO:SEEK_SET`: Repositions the stream to the given `offset`:
-  #
-  #         f = File.open('t.txt')
-  #         f.tell            # => 0
-  #         f.seek(20, :SET) # => 0
-  #         f.tell           # => 20
-  #         f.seek(40, :SET) # => 0
-  #         f.tell           # => 40
-  #
-  #
-  # Related: IO#pos=, IO#tell.
-  #
-  def seek: (Integer amount, ?Integer whence) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - io.set_encoding(ext_enc)                -> io
-  #   - io.set_encoding("ext_enc:int_enc")      -> io
-  #   - io.set_encoding(ext_enc, int_enc)       -> io
-  #   - io.set_encoding("ext_enc:int_enc", opt) -> io
-  #   - io.set_encoding(ext_enc, int_enc, opt)  -> io
-  # -->
-  # If single argument is specified, read string from io is tagged with the
-  # encoding specified.  If encoding is a colon separated two encoding names
-  # "A:B", the read string is converted from encoding A (external encoding) to
-  # encoding B (internal encoding), then tagged with B.  If two arguments are
-  # specified, those must be encoding objects or encoding names, and the first one
-  # is the external encoding, and the second one is the internal encoding. If the
-  # external encoding and the internal encoding is specified, optional hash
-  # argument specify the conversion option.
-  #
-  def set_encoding: (?String | Encoding ext_or_ext_int_enc) -> self
-                  | (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc) -> self
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.set_encoding_by_bom   -> encoding or nil
-  # -->
-  # Checks if `ios` starts with a BOM, and then consumes it and sets the external
-  # encoding.  Returns the result encoding if found, or nil.  If `ios` is not
-  # binmode or its encoding has been set already, an exception will be raised.
-  #
-  #     File.write("bom.txt", "\u{FEFF}abc")
-  #     ios = File.open("bom.txt", "rb")
-  #     ios.set_encoding_by_bom    #=>  #<Encoding:UTF-8>
-  #
-  #     File.write("nobom.txt", "abc")
-  #     ios = File.open("nobom.txt", "rb")
-  #     ios.set_encoding_by_bom    #=>  nil
-  #
-  def set_encoding_by_bom: () -> Encoding?
-
-  # <!--
-  #   rdoc-file=file.c
-  #   - ios.stat    -> stat
-  # -->
-  # Returns status information for *ios* as an object of type File::Stat.
-  #
-  #     f = File.new("testfile")
-  #     s = f.stat
-  #     "%o" % s.mode   #=> "100644"
-  #     s.blksize       #=> 4096
-  #     s.atime         #=> Wed Apr 09 08:53:54 CDT 2003
-  #
-  def stat: () -> File::Stat
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - sync -> true or false
-  # -->
-  # Returns the current sync mode of the stream. When sync mode is true, all
-  # output is immediately flushed to the underlying operating system and is not
-  # buffered by Ruby internally. See also #fsync.
-  #
-  #     f = File.open('t.tmp', 'w')
-  #     f.sync # => false
-  #     f.sync = true
-  #     f.sync # => true
-  #
-  def sync: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - sync = boolean -> boolean
-  # -->
-  # Sets the *sync* *mode* for the stream to the given value; returns the given
-  # value.
-  #
-  # Values for the sync mode:
-  #
-  # *   `true`: All output is immediately flushed to the underlying operating
-  #     system and is not buffered internally.
-  # *   `false`: Output may be buffered internally.
-  #
-  #
-  # Example;
-  #
-  #     f = File.open('t.tmp', 'w')
-  #     f.sync # => false
-  #     f.sync = true
-  #     f.sync # => true
-  #
-  # Related: IO#fsync.
-  #
-  def sync=: (boolish) -> untyped
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.sysread(maxlen[, outbuf])    -> string
-  # -->
-  # Reads *maxlen* bytes from *ios* using a low-level read and returns them as a
-  # string.  Do not mix with other methods that read from *ios* or you may get
-  # unpredictable results.
-  #
-  # If the optional *outbuf* argument is present, it must reference a String,
-  # which will receive the data. The *outbuf* will contain only the received data
-  # after the method call even if it is not empty at the beginning.
-  #
-  # Raises SystemCallError on error and EOFError at end of file.
-  #
-  #     f = File.new("testfile")
-  #     f.sysread(16)   #=> "This is line one"
-  #
-  def sysread: (Integer maxlen, String outbuf) -> String
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.sysseek(offset, whence=IO::SEEK_SET)   -> integer
-  # -->
-  # Seeks to a given *offset* in the stream according to the value of *whence*
-  # (see IO#seek for values of *whence*). Returns the new offset into the file.
-  #
-  #     f = File.new("testfile")
-  #     f.sysseek(-13, IO::SEEK_END)   #=> 53
-  #     f.sysread(10)                  #=> "And so on."
-  #
-  def sysseek: (Integer amount, ?Integer whence) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.syswrite(string)   -> integer
-  # -->
-  # Writes the given string to *ios* using a low-level write. Returns the number
-  # of bytes written. Do not mix with other methods that write to *ios* or you may
-  # get unpredictable results. Raises SystemCallError on error.
-  #
-  #     f = File.new("out", "w")
-  #     f.syswrite("ABCDEF")   #=> 6
-  #
-  def syswrite: (_ToS arg0) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - tell -> integer
-  # -->
-  # Returns the current position (in bytes) in `self` (see
-  # [Position](#class-IO-label-Position)):
-  #
-  #     f = File.new('t.txt')
-  #     f.tell     # => 0
-  #     f.readline # => "This is line one.\n"
-  #     f.tell     # => 19
-  #
-  # Related: IO#pos=, IO#seek.
-  #
-  # IO#pos is an alias for IO#tell.
-  #
-  def tell: () -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - to_io -> self
-  # -->
-  # Returns `self`.
-  #
-  def to_io: () -> self
-
-  # <!-- rdoc-file=io.c -->
-  # Returns `true` if *ios* is associated with a terminal device (tty), `false`
-  # otherwise.
-  #
-  #     File.new("testfile").isatty   #=> false
-  #     File.new("/dev/tty").isatty   #=> true
-  #
-  def tty?: () -> bool
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.ungetbyte(string)   -> nil
-  #   - ios.ungetbyte(integer)  -> nil
-  # -->
-  # Pushes back bytes (passed as a parameter) onto *ios*, such that a subsequent
-  # buffered read will return it. It is only guaranteed to support a single byte,
-  # and only if ungetbyte or ungetc has not already been called on *ios* since the
-  # previous read of at least a single byte from *ios*. However, it can support
-  # additional bytes if there is space in the internal buffer to allow for it.
-  #
-  #     f = File.new("testfile")   #=> #<File:testfile>
-  #     b = f.getbyte              #=> 0x38
-  #     f.ungetbyte(b)             #=> nil
-  #     f.getbyte                  #=> 0x38
-  #
-  # If given an integer, only uses the lower 8 bits of the integer as the byte to
-  # push.
-  #
-  #     f = File.new("testfile")   #=> #<File:testfile>
-  #     f.ungetbyte(0x102)         #=> nil
-  #     f.getbyte                  #=> 0x2
-  #
-  # Calling this method prepends to the existing buffer, even if the method has
-  # already been called previously:
-  #
-  #     f = File.new("testfile")   #=> #<File:testfile>
-  #     f.ungetbyte("ab")          #=> nil
-  #     f.ungetbyte("cd")          #=> nil
-  #     f.read(5)                  #=> "cdab8"
-  #
-  # Has no effect with unbuffered reads (such as IO#sysread).
-  #
-  def ungetbyte: (String | Integer arg0) -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - ios.ungetc(integer)  -> nil
-  #   - ios.ungetc(string)   -> nil
-  # -->
-  # Pushes back characters (passed as a parameter) onto *ios*, such that a
-  # subsequent buffered read will return it. It is only guaranteed to support a
-  # single byte, and only if ungetbyte or ungetc has not already been called on
-  # *ios* since the previous read of at least a single byte from *ios*. However,
-  # it can support additional bytes if there is space in the internal buffer to
-  # allow for it.
-  #
-  #     f = File.new("testfile")   #=> #<File:testfile>
-  #     c = f.getc                 #=> "8"
-  #     f.ungetc(c)                #=> nil
-  #     f.getc                     #=> "8"
-  #
-  # If given an integer, the integer must represent a valid codepoint in the
-  # external encoding of *ios*.
-  #
-  # Calling this method prepends to the existing buffer, even if the method has
-  # already been called previously:
-  #
-  #     f = File.new("testfile")   #=> #<File:testfile>
-  #     f.ungetc("ab")             #=> nil
-  #     f.ungetc("cd")             #=> nil
-  #     f.read(5)                  #=> "cdab8"
-  #
-  # Has no effect with unbuffered reads (such as IO#sysread).
-  #
-  def ungetc: (String arg0) -> NilClass
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - write(*objects) -> integer
-  # -->
-  # Writes each of the given `objects` to `self`, which must be opened for writing
-  # (see [Modes](#class-IO-label-Modes)); returns the total number bytes written;
-  # each of `objects` that is not a string is converted via method `to_s`:
-  #
-  #     $stdout.write('Hello', ', ', 'World!', "\n") # => 14
-  #     $stdout.write('foo', :bar, 2, "\n")          # => 8
-  #
-  # Output:
-  #
-  #     Hello, World!
-  #     foobar2
-  #
-  def write: (*_ToS string) -> Integer
-
-  # <!--
-  #   rdoc-file=io.rb
-  #   - ios.write_nonblock(string)   -> integer
-  #   - ios.write_nonblock(string [, options])   -> integer
-  # -->
-  # Writes the given string to *ios* using the write(2) system call after
-  # O_NONBLOCK is set for the underlying file descriptor.
-  #
-  # It returns the number of bytes written.
-  #
-  # write_nonblock just calls the write(2) system call. It causes all errors the
-  # write(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc. The result
-  # may also be smaller than string.length (partial write). The caller should care
-  # such errors and partial write.
-  #
-  # If the exception is Errno::EWOULDBLOCK or Errno::EAGAIN, it is extended by
-  # IO::WaitWritable. So IO::WaitWritable can be used to rescue the exceptions for
-  # retrying write_nonblock.
-  #
-  #     # Creates a pipe.
-  #     r, w = IO.pipe
-  #
-  #     # write_nonblock writes only 65536 bytes and return 65536.
-  #     # (The pipe size is 65536 bytes on this environment.)
-  #     s = "a" * 100000
-  #     p w.write_nonblock(s)     #=> 65536
-  #
-  #     # write_nonblock cannot write a byte and raise EWOULDBLOCK (EAGAIN).
-  #     p w.write_nonblock("b")   # Resource temporarily unavailable (Errno::EAGAIN)
-  #
-  # If the write buffer is not empty, it is flushed at first.
-  #
-  # When write_nonblock raises an exception kind of IO::WaitWritable,
-  # write_nonblock should not be called until io is writable for avoiding busy
-  # loop. This can be done as follows.
-  #
-  #     begin
-  #       result = io.write_nonblock(string)
-  #     rescue IO::WaitWritable, Errno::EINTR
-  #       IO.select(nil, [io])
-  #       retry
-  #     end
-  #
-  # Note that this doesn't guarantee to write all data in string. The length
-  # written is reported as result and it should be checked later.
-  #
-  # On some platforms such as Windows, write_nonblock is not supported according
-  # to the kind of the IO object. In such cases, write_nonblock raises
-  # `Errno::EBADF`.
-  #
-  # By specifying a keyword argument *exception* to `false`, you can indicate that
-  # write_nonblock should not raise an IO::WaitWritable exception, but return the
-  # symbol `:wait_writable` instead.
-  #
-  def write_nonblock: (_ToS s, ?exception: true) -> Integer
-                    | (_ToS s, exception: false) -> (Integer | :wait_writable | nil)
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.binread(name, [length [, offset]])   -> string
-  #   - File.binread(name, [length [, offset]]) -> string
-  # -->
-  # Opens the file, optionally seeks to the given *offset*, then returns *length*
-  # bytes (defaulting to the rest of the file). #binread ensures the file is
-  # closed before returning.  The open mode would be `"rb:ASCII-8BIT"`.
-  #
-  # If `name` starts with a pipe character (`"|"`) and the receiver is the IO
-  # class, a subprocess is created in the same way as Kernel#open, and its output
-  # is returned. Consider to use File.binread to disable the behavior of
-  # subprocess invocation.
-  #
-  #     File.binread("testfile")           #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
-  #     File.binread("testfile", 20)       #=> "This is line one\nThi"
-  #     File.binread("testfile", 20, 10)   #=> "ne one\nThis is line "
-  #     IO.binread("| cat testfile")       #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
-  #
-  # See also IO.read for details about `name` and open_args.
-  #
-  def self.binread: (String name, ?Integer length, ?Integer offset) -> String
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.binwrite(name, string, [offset])               -> integer
-  #   - IO.binwrite(name, string, [offset], open_args)    -> integer
-  #   - File.binwrite(name, string, [offset])             -> integer
-  #   - File.binwrite(name, string, [offset], open_args)  -> integer
-  # -->
-  # Same as IO.write except opening the file in binary mode and ASCII-8BIT
-  # encoding (`"wb:ASCII-8BIT"`).
-  #
-  # If `name` starts with a pipe character (`"|"`) and the receiver is the IO
-  # class, a subprocess is created in the same way as Kernel#open, and its output
-  # is returned. Consider to use File.binwrite to disable the behavior of
-  # subprocess invocation.
-  #
-  # See also IO.read for details about `name` and open_args.
-  #
-  def self.binwrite: (String name, _ToS string, ?Integer offset, ?mode: String mode) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.copy_stream(src, dst)
-  #   - IO.copy_stream(src, dst, copy_length)
-  #   - IO.copy_stream(src, dst, copy_length, src_offset)
-  # -->
-  # IO.copy_stream copies *src* to *dst*. *src* and *dst* is either a filename or
-  # an IO-like object. IO-like object for *src* should have #readpartial or #read
-  # method.  IO-like object for *dst* should have #write method. (Specialized
-  # mechanisms, such as sendfile system call, may be used on appropriate
-  # situation.)
-  #
-  # This method returns the number of bytes copied.
-  #
-  # If optional arguments are not given, the start position of the copy is the
-  # beginning of the filename or the current file offset of the IO. The end
-  # position of the copy is the end of file.
-  #
-  # If *copy_length* is given, No more than *copy_length* bytes are copied.
-  #
-  # If *src_offset* is given, it specifies the start position of the copy.
-  #
-  # When *src_offset* is specified and *src* is an IO, IO.copy_stream doesn't move
-  # the current file offset.
-  #
-  def self.copy_stream: (String | _Reader | _ReaderPartial src, String | _Writer dst, ?Integer copy_length, ?Integer src_offset) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.popen([env,] cmd, mode="r" [, opt])               -> io
-  #   - IO.popen([env,] cmd, mode="r" [, opt]) {|io| block } -> obj
-  # -->
-  # Runs the specified command as a subprocess; the subprocess's standard input
-  # and output will be connected to the returned IO object.
-  #
-  # The PID of the started process can be obtained by IO#pid method.
-  #
-  # *cmd* is a string or an array as follows.
-  #
-  #     cmd:
-  #       "-"                                      : fork
-  #       commandline                              : command line string which is passed to a shell
-  #       [env, cmdname, arg1, ..., opts]          : command name and zero or more arguments (no shell)
-  #       [env, [cmdname, argv0], arg1, ..., opts] : command name, argv[0] and zero or more arguments (no shell)
-  #     (env and opts are optional.)
-  #
-  # If *cmd* is a `String` ```-`'', then a new instance of Ruby is started as the
-  # subprocess.
-  #
-  # If *cmd* is an `Array` of `String`, then it will be used as the subprocess's
-  # `argv` bypassing a shell. The array can contain a hash at first for
-  # environments and a hash at last for options similar to #spawn.
-  #
-  # The default mode for the new file object is ``r'', but *mode* may be set to
-  # any of the modes listed in the description for class IO. The last argument
-  # *opt* qualifies *mode*.
-  #
-  #     # set IO encoding
-  #     IO.popen("nkf -e filename", :external_encoding=>"EUC-JP") {|nkf_io|
-  #       euc_jp_string = nkf_io.read
-  #     }
-  #
-  #     # merge standard output and standard error using
-  #     # spawn option.  See the document of Kernel.spawn.
-  #     IO.popen(["ls", "/", :err=>[:child, :out]]) {|ls_io|
-  #       ls_result_with_error = ls_io.read
-  #     }
-  #
-  #     # spawn options can be mixed with IO options
-  #     IO.popen(["ls", "/"], :err=>[:child, :out]) {|ls_io|
-  #       ls_result_with_error = ls_io.read
-  #     }
-  #
-  # Raises exceptions which IO.pipe and Kernel.spawn raise.
-  #
-  # If a block is given, Ruby will run the command as a child connected to Ruby
-  # with a pipe. Ruby's end of the pipe will be passed as a parameter to the
-  # block. At the end of block, Ruby closes the pipe and sets `$?`. In this case
-  # IO.popen returns the value of the block.
-  #
-  # If a block is given with a *cmd* of ```-`'', the block will be run in two
-  # separate processes: once in the parent, and once in a child. The parent
-  # process will be passed the pipe object as a parameter to the block, the child
-  # version of the block will be passed `nil`, and the child's standard in and
-  # standard out will be connected to the parent through the pipe. Not available
-  # on all platforms.
-  #
-  #     f = IO.popen("uname")
-  #     p f.readlines
-  #     f.close
-  #     puts "Parent is #{Process.pid}"
-  #     IO.popen("date") {|f| puts f.gets }
-  #     IO.popen("-") {|f| $stderr.puts "#{Process.pid} is here, f is #{f.inspect}"}
-  #     p $?
-  #     IO.popen(%w"sed -e s|^|<foo>| -e s&$&;zot;&", "r+") {|f|
-  #       f.puts "bar"; f.close_write; puts f.gets
-  #     }
-  #
-  # *produces:*
-  #
-  #     ["Linux\n"]
-  #     Parent is 21346
-  #     Thu Jan 15 22:41:19 JST 2009
-  #     21346 is here, f is #<IO:fd 3>
-  #     21352 is here, f is nil
-  #     #<Process::Status: pid 21352 exit 0>
-  #     <foo>bar;zot;
-  #
-  def self.popen: (*untyped args) -> untyped
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.foreach(name, sep=$/ [, getline_args, open_args]) {|line| block }     -> nil
-  #   - IO.foreach(name, limit [, getline_args, open_args]) {|line| block }      -> nil
-  #   - IO.foreach(name, sep, limit [, getline_args, open_args]) {|line| block } -> nil
-  #   - IO.foreach(...)                                            -> an_enumerator
-  #   - File.foreach(name, sep=$/ [, getline_args, open_args]) {|line| block }     -> nil
-  #   - File.foreach(name, limit [, getline_args, open_args]) {|line| block }      -> nil
-  #   - File.foreach(name, sep, limit [, getline_args, open_args]) {|line| block } -> nil
-  #   - File.foreach(...)                                            -> an_enumerator
-  # -->
-  # Executes the block for every line in the named I/O port, where lines are
-  # separated by *sep*.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  # If `name` starts with a pipe character (`"|"`) and the receiver is the IO
-  # class, a subprocess is created in the same way as Kernel#open, and its output
-  # is returned. Consider to use File.foreach to disable the behavior of
-  # subprocess invocation.
-  #
-  #     File.foreach("testfile") {|x| print "GOT ", x }
-  #     IO.foreach("| cat testfile") {|x| print "GOT ", x }
-  #
-  # *produces:*
-  #
-  #     GOT This is line one
-  #     GOT This is line two
-  #     GOT This is line three
-  #     GOT And so on...
-  #
-  # If the last argument is a hash, it's the keyword argument to open. See
-  # IO.readlines for details about getline_args. And see also IO.read for details
-  # about open_args.
-  #
-  def self.foreach: (string | _ToPath path, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) { (String line) -> void } -> nil
-                  | (string | _ToPath path, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) -> ::Enumerator[String, nil]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.pipe                             ->  [read_io, write_io]
-  #   - IO.pipe(ext_enc)                    ->  [read_io, write_io]
-  #   - IO.pipe("ext_enc:int_enc" [, opt])  ->  [read_io, write_io]
-  #   - IO.pipe(ext_enc, int_enc [, opt])   ->  [read_io, write_io]
-  #   - IO.pipe(...) {|read_io, write_io| ... }
-  # -->
-  # Creates a pair of pipe endpoints (connected to each other) and returns them as
-  # a two-element array of IO objects: `[` *read_io*, *write_io* `]`.
-  #
-  # If a block is given, the block is called and returns the value of the block.
-  # *read_io* and *write_io* are sent to the block as arguments. If read_io and
-  # write_io are not closed when the block exits, they are closed. i.e. closing
-  # read_io and/or write_io doesn't cause an error.
-  #
-  # Not available on all platforms.
-  #
-  # If an encoding (encoding name or encoding object) is specified as an optional
-  # argument, read string from pipe is tagged with the encoding specified. If the
-  # argument is a colon separated two encoding names "A:B", the read string is
-  # converted from encoding A (external encoding) to encoding B (internal
-  # encoding), then tagged with B. If two optional arguments are specified, those
-  # must be encoding objects or encoding names, and the first one is the external
-  # encoding, and the second one is the internal encoding. If the external
-  # encoding and the internal encoding is specified, optional hash argument
-  # specify the conversion option.
-  #
-  # In the example below, the two processes close the ends of the pipe that they
-  # are not using. This is not just a cosmetic nicety. The read end of a pipe will
-  # not generate an end of file condition if there are any writers with the pipe
-  # still open. In the case of the parent process, the `rd.read` will never return
-  # if it does not first issue a `wr.close`.
-  #
-  #     rd, wr = IO.pipe
-  #
-  #     if fork
-  #       wr.close
-  #       puts "Parent got: <#{rd.read}>"
-  #       rd.close
-  #       Process.wait
-  #     else
-  #       rd.close
-  #       puts "Sending message to parent"
-  #       wr.write "Hi Dad"
-  #       wr.close
-  #     end
-  #
-  # *produces:*
-  #
-  #     Sending message to parent
-  #     Parent got: <Hi Dad>
-  #
-  def self.pipe: (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) -> [IO, IO]
-               | [X] (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) { (IO read_io, IO write_io) -> X } -> X
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.read(name, [length [, offset]] [, opt])   -> string
-  #   - File.read(name, [length [, offset]] [, opt]) -> string
-  # -->
-  # Opens the file, optionally seeks to the given `offset`, then returns `length`
-  # bytes (defaulting to the rest of the file).  #read ensures the file is closed
-  # before returning.
-  #
-  # If `name` starts with a pipe character (`"|"`) and the receiver is the IO
-  # class, a subprocess is created in the same way as Kernel#open, and its output
-  # is returned. Consider to use File.read to disable the behavior of subprocess
-  # invocation.
-  #
-  # ### Options
-  #
-  # The options hash accepts the following keys:
-  #
-  # :encoding
-  # :   string or encoding
-  #
-  #     Specifies the encoding of the read string.  `:encoding` will be ignored if
-  #     `length` is specified.  See Encoding.aliases for possible encodings.
-  #
-  # :mode
-  # :   string or integer
-  #
-  #     Specifies the *mode* argument for open().  It must start with an "r",
-  #     otherwise it will cause an error. See IO.new for the list of possible
-  #     modes.
-  #
-  # :open_args
-  # :   array
-  #
-  #     Specifies arguments for open() as an array.  This key can not be used in
-  #     combination with either `:encoding` or `:mode`.
-  #
-  #
-  # Examples:
-  #
-  #     File.read("testfile")            #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
-  #     File.read("testfile", 20)        #=> "This is line one\nThi"
-  #     File.read("testfile", 20, 10)    #=> "ne one\nThis is line "
-  #     File.read("binfile", mode: "rb") #=> "\xF7\x00\x00\x0E\x12"
-  #     IO.read("|ls -a")                #=> ".\n..\n"...
-  #
-  def self.read: (String name, ?Integer length, ?Integer offset, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode) -> String
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.readlines(name, sep=$/ [, getline_args, open_args])     -> array
-  #   - IO.readlines(name, limit [, getline_args, open_args])      -> array
-  #   - IO.readlines(name, sep, limit [, getline_args, open_args]) -> array
-  #   - File.readlines(name, sep=$/ [, getline_args, open_args])     -> array
-  #   - File.readlines(name, limit [, getline_args, open_args])      -> array
-  #   - File.readlines(name, sep, limit [, getline_args, open_args]) -> array
-  # -->
-  # Reads the entire file specified by *name* as individual lines, and returns
-  # those lines in an array. Lines are separated by *sep*.
-  #
-  # If `name` starts with a pipe character (`"|"`) and the receiver is the IO
-  # class, a subprocess is created in the same way as Kernel#open, and its output
-  # is returned. Consider to use File.readlines to disable the behavior of
-  # subprocess invocation.
-  #
-  #     a = File.readlines("testfile")
-  #     a[0]   #=> "This is line one\n"
-  #
-  #     b = File.readlines("testfile", chomp: true)
-  #     b[0]   #=> "This is line one"
-  #
-  #     IO.readlines("|ls -a")     #=> [".\n", "..\n", ...]
-  #
-  # If the last argument is a hash, it's the keyword argument to open.
-  #
-  # ### Options for getline
-  #
-  # The options hash accepts the following keys:
-  #
-  # :chomp
-  # :   When the optional `chomp` keyword argument has a true value, `\n`, `\r`,
-  #     and `\r\n` will be removed from the end of each line.
-  #
-  #
-  # See also IO.read for details about `name` and open_args.
-  #
-  def self.readlines: (String | _ToPath name, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) -> ::Array[String]
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.select(read_array [, write_array [, error_array [, timeout]]]) -> array or nil
-  # -->
-  # Calls select(2) system call. It monitors given arrays of IO objects, waits
-  # until one or more of IO objects are ready for reading, are ready for writing,
-  # and have pending exceptions respectively, and returns an array that contains
-  # arrays of those IO objects.  It will return `nil` if optional *timeout* value
-  # is given and no IO object is ready in *timeout* seconds.
-  #
-  # IO.select peeks the buffer of IO objects for testing readability. If the IO
-  # buffer is not empty, IO.select immediately notifies readability.  This "peek"
-  # only happens for IO objects.  It does not happen for IO-like objects such as
-  # OpenSSL::SSL::SSLSocket.
-  #
-  # The best way to use IO.select is invoking it after nonblocking methods such as
-  # #read_nonblock, #write_nonblock, etc.  The methods raise an exception which is
-  # extended by IO::WaitReadable or IO::WaitWritable.  The modules notify how the
-  # caller should wait with IO.select.  If IO::WaitReadable is raised, the caller
-  # should wait for reading.  If IO::WaitWritable is raised, the caller should
-  # wait for writing.
-  #
-  # So, blocking read (#readpartial) can be emulated using #read_nonblock and
-  # IO.select as follows:
-  #
-  #     begin
-  #       result = io_like.read_nonblock(maxlen)
-  #     rescue IO::WaitReadable
-  #       IO.select([io_like])
-  #       retry
-  #     rescue IO::WaitWritable
-  #       IO.select(nil, [io_like])
-  #       retry
-  #     end
-  #
-  # Especially, the combination of nonblocking methods and IO.select is preferred
-  # for IO like objects such as OpenSSL::SSL::SSLSocket.  It has #to_io method to
-  # return underlying IO object.  IO.select calls #to_io to obtain the file
-  # descriptor to wait.
-  #
-  # This means that readability notified by IO.select doesn't mean readability
-  # from OpenSSL::SSL::SSLSocket object.
-  #
-  # The most likely situation is that OpenSSL::SSL::SSLSocket buffers some data.
-  # IO.select doesn't see the buffer.  So IO.select can block when
-  # OpenSSL::SSL::SSLSocket#readpartial doesn't block.
-  #
-  # However, several more complicated situations exist.
-  #
-  # SSL is a protocol which is sequence of records. The record consists of
-  # multiple bytes. So, the remote side of SSL sends a partial record, IO.select
-  # notifies readability but OpenSSL::SSL::SSLSocket cannot decrypt a byte and
-  # OpenSSL::SSL::SSLSocket#readpartial will block.
-  #
-  # Also, the remote side can request SSL renegotiation which forces the local SSL
-  # engine to write some data. This means OpenSSL::SSL::SSLSocket#readpartial may
-  # invoke #write system call and it can block. In such a situation,
-  # OpenSSL::SSL::SSLSocket#read_nonblock raises IO::WaitWritable instead of
-  # blocking. So, the caller should wait for ready for writability as above
-  # example.
-  #
-  # The combination of nonblocking methods and IO.select is also useful for
-  # streams such as tty, pipe socket socket when multiple processes read from a
-  # stream.
-  #
-  # Finally, Linux kernel developers don't guarantee that readability of select(2)
-  # means readability of following read(2) even for a single process. See
-  # select(2) manual on GNU/Linux system.
-  #
-  # Invoking IO.select before IO#readpartial works well as usual. However it is
-  # not the best way to use IO.select.
-  #
-  # The writability notified by select(2) doesn't show how many bytes are
-  # writable. IO#write method blocks until given whole string is written. So,
-  # `IO#write(two or more bytes)` can block after writability is notified by
-  # IO.select.  IO#write_nonblock is required to avoid the blocking.
-  #
-  # Blocking write (#write) can be emulated using #write_nonblock and IO.select as
-  # follows: IO::WaitReadable should also be rescued for SSL renegotiation in
-  # OpenSSL::SSL::SSLSocket.
-  #
-  #     while 0 < string.bytesize
-  #       begin
-  #         written = io_like.write_nonblock(string)
-  #       rescue IO::WaitReadable
-  #         IO.select([io_like])
-  #         retry
-  #       rescue IO::WaitWritable
-  #         IO.select(nil, [io_like])
-  #         retry
-  #       end
-  #       string = string.byteslice(written..-1)
-  #     end
-  #
-  # ### Parameters
-  # read_array
-  # :   an array of IO objects that wait until ready for read
-  # write_array
-  # :   an array of IO objects that wait until ready for write
-  # error_array
-  # :   an array of IO objects that wait for exceptions
-  # timeout
-  # :   a numeric value in second
-  #
-  #
-  # ### Example
-  #
-  #     rp, wp = IO.pipe
-  #     mesg = "ping "
-  #     100.times {
-  #       # IO.select follows IO#read.  Not the best way to use IO.select.
-  #       rs, ws, = IO.select([rp], [wp])
-  #       if r = rs[0]
-  #         ret = r.read(5)
-  #         print ret
-  #         case ret
-  #         when /ping/
-  #           mesg = "pong\n"
-  #         when /pong/
-  #           mesg = "ping "
-  #         end
-  #       end
-  #       if w = ws[0]
-  #         w.write(mesg)
-  #       end
-  #     }
-  #
-  # *produces:*
-  #
-  #     ping pong
-  #     ping pong
-  #     ping pong
-  #     (snipped)
-  #     ping
-  #
-  def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ]
-                 | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Numeric? timeout) -> [ Array[X], Array[Y], Array[Z] ]?
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.sysopen(path, [mode, [perm]])  -> integer
-  # -->
-  # Opens the given path, returning the underlying file descriptor as a Integer.
-  #
-  #     IO.sysopen("testfile")   #=> 3
-  #
-  def self.sysopen: (String path, ?String mode, ?String perm) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.try_convert(object) -> new_io or nil
-  # -->
-  # Attempts to convert `object` into an IO object via method `to_io`; returns the
-  # new IO object if successful, or `nil` otherwise:
-  #
-  #     IO.try_convert(STDOUT)   # => #<IO:<STDOUT>>
-  #     IO.try_convert(ARGF)     # => #<IO:<STDIN>>
-  #     IO.try_convert('STDOUT') # => nil
-  #
-  def self.try_convert: (untyped arg0) -> IO?
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.write(name, string [, offset])           -> integer
-  #   - IO.write(name, string [, offset] [, opt])   -> integer
-  #   - File.write(name, string [, offset])         -> integer
-  #   - File.write(name, string [, offset] [, opt]) -> integer
-  # -->
-  # Opens the file, optionally seeks to the given *offset*, writes *string*, then
-  # returns the length written.  #write ensures the file is closed before
-  # returning.  If *offset* is not given in write mode, the file is truncated.
-  # Otherwise, it is not truncated.
-  #
-  # If `name` starts with a pipe character (`"|"`) and the receiver is the IO
-  # class, a subprocess is created in the same way as Kernel#open, and its output
-  # is returned. Consider to use File.write to disable the behavior of subprocess
-  # invocation.
-  #
-  #     File.write("testfile", "0123456789", 20)  #=> 10
-  #     # File could contain:  "This is line one\nThi0123456789two\nThis is line three\nAnd so on...\n"
-  #     File.write("testfile", "0123456789")      #=> 10
-  #     # File would now read: "0123456789"
-  #     IO.write("|tr a-z A-Z", "abc")            #=> 3
-  #     # Prints "ABC" to the standard output
-  #
-  # If the last argument is a hash, it specifies options for the internal open().
-  # It accepts the following keys:
-  #
-  # :encoding
-  # :   string or encoding
-  #
-  #     Specifies the encoding of the read string. See Encoding.aliases for
-  #     possible encodings.
-  #
-  # :mode
-  # :   string or integer
-  #
-  #     Specifies the *mode* argument for open().  It must start with "w", "a", or
-  #     "r+", otherwise it will cause an error. See IO.new for the list of
-  #     possible modes.
-  #
-  # :perm
-  # :   integer
-  #
-  #     Specifies the *perm* argument for open().
-  #
-  # :open_args
-  # :   array
-  #
-  #     Specifies arguments for open() as an array. This key can not be used in
-  #     combination with other keys.
-  #
-  #
-  # See also IO.read for details about `name` and open_args.
-  #
-  def self.write: (String name, _ToS arg0, ?Integer offset, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode) -> Integer
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.for_fd(fd, mode [, opt])    -> io
-  # -->
-  # Synonym for IO.new.
-  #
-  def self.for_fd: (int fd, ?string | int mode, **untyped opt) -> instance
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.open(fd, mode="r" [, opt])                -> io
-  #   - IO.open(fd, mode="r" [, opt]) {|io| block }  -> obj
-  # -->
-  # With no associated block, IO.open is a synonym for IO.new.  If the optional
-  # code block is given, it will be passed `io` as an argument, and the IO object
-  # will automatically be closed when the block terminates. In this instance,
-  # IO.open returns the value of the block.
-  #
-  # See IO.new for a description of the `fd`, `mode` and `opt` parameters.
-  #
-  alias self.open self.for_fd
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - IO.open(fd, mode="r" [, opt])                -> io
-  #   - IO.open(fd, mode="r" [, opt]) {|io| block }  -> obj
-  # -->
-  # With no associated block, IO.open is a synonym for IO.new.  If the optional
-  # code block is given, it will be passed `io` as an argument, and the IO object
-  # will automatically be closed when the block terminates. In this instance,
-  # IO.open returns the value of the block.
-  #
-  # See IO.new for a description of the `fd`, `mode` and `opt` parameters.
-  #
-  def self.open: [A] (int fd, ?string | int mode, **untyped opt) { (instance) -> A } -> A
-               | ...
-
-  def bytes: () { (Integer arg0) -> untyped } -> self
-           | () -> ::Enumerator[Integer, self]
-
-  def chars: () { (String arg0) -> untyped } -> self
-           | () -> ::Enumerator[String, self]
-
-  def codepoints: () { (Integer arg0) -> untyped } -> self
-                | () -> ::Enumerator[Integer, self]
-
-  # <!-- rdoc-file=io.c -->
-  # Executes the block for every line in *ios*, where lines are separated by
-  # *sep*. *ios* must be opened for reading or an IOError will be raised.
-  #
-  # If no block is given, an enumerator is returned instead.
-  #
-  #     f = File.new("testfile")
-  #     f.each {|line| puts "#{f.lineno}: #{line}" }
-  #
-  # *produces:*
-  #
-  #     1: This is line one
-  #     2: This is line two
-  #     3: This is line three
-  #     4: And so on...
-  #
-  # See IO.readlines for details about getline_args.
-  #
-  def each_line: (?String sep, ?Integer limit) { (String arg0) -> untyped } -> self
-               | (?String sep, ?Integer limit) -> ::Enumerator[String, self]
-
-  # <!-- rdoc-file=io.c -->
-  # Returns `true` if the stream is positioned at its end, `false` otherwise; see
-  # [Position](#class-IO-label-Position):
-  #
-  #     f = File.open('t.txt')
-  #     f.eof           # => false
-  #     f.seek(0, :END) # => 0
-  #     f.eof           # => true
-  #
-  # Raises an exception unless the stream is opened for reading; see
-  # [Mode](#class-IO-label-Mode).
-  #
-  # If `self` is a stream such as pipe or socket, this method blocks until the
-  # other end sends some data or closes it:
-  #
-  #     r, w = IO.pipe
-  #     Thread.new { sleep 1; w.close }
-  #     r.eof? # => true # After 1-second wait.
-  #
-  #     r, w = IO.pipe
-  #     Thread.new { sleep 1; w.puts "a" }
-  #     r.eof?  # => false # After 1-second wait.
-  #
-  #     r, w = IO.pipe
-  #     r.eof?  # blocks forever
-  #
-  # Note that this method reads data to the input byte buffer.  So IO#sysread may
-  # not behave as you intend with IO#eof?, unless you call IO#rewind first (which
-  # is not available for some streams).
-  #
-  # I#eof? is an alias for IO#eof.
-  #
-  def eof?: () -> bool
-
-  def lines: (?String sep, ?Integer limit) { (String arg0) -> untyped } -> self
-           | (?String sep, ?Integer limit) -> ::Enumerator[String, self]
-
-  # <!-- rdoc-file=io.c -->
-  # Returns the integer file descriptor for the stream:
-  #
-  #     $stdin.fileno             # => 0
-  #     $stdout.fileno            # => 1
-  #     $stderr.fileno            # => 2
-  #     File.open('t.txt').fileno # => 10
-  #
-  # IO#to_i is an alias for IO#fileno.
-  #
-  def to_i: () -> Integer
-end
-
-IO::APPEND: Integer
-
-IO::BINARY: Integer
-
-IO::CREAT: Integer
-
-IO::DIRECT: Integer
-
-IO::DSYNC: Integer
-
-IO::EXCL: Integer
-
-IO::FNM_CASEFOLD: Integer
-
-IO::FNM_DOTMATCH: Integer
-
-IO::FNM_EXTGLOB: Integer
-
-IO::FNM_NOESCAPE: Integer
-
-IO::FNM_PATHNAME: Integer
-
-IO::FNM_SHORTNAME: Integer
-
-IO::FNM_SYSCASE: Integer
-
-IO::LOCK_EX: Integer
-
-IO::LOCK_NB: Integer
-
-IO::LOCK_SH: Integer
-
-IO::LOCK_UN: Integer
-
-IO::NOATIME: Integer
-
-IO::NOCTTY: Integer
-
-IO::NOFOLLOW: Integer
-
-IO::NONBLOCK: Integer
-
-IO::NULL: String
-
-IO::RDONLY: Integer
-
-IO::RDWR: Integer
-
-IO::RSYNC: Integer
-
-# <!-- rdoc-file=io.c -->
-# Set I/O position from the current position
-#
-IO::SEEK_CUR: Integer
-
-# <!-- rdoc-file=io.c -->
-# Set I/O position to the next location containing data
-#
-IO::SEEK_DATA: Integer
-
-# <!-- rdoc-file=io.c -->
-# Set I/O position from the end
-#
-IO::SEEK_END: Integer
-
-# <!-- rdoc-file=io.c -->
-# Set I/O position to the next hole
-#
-IO::SEEK_HOLE: Integer
-
-# <!-- rdoc-file=io.c -->
-# Set I/O position from the beginning
-#
-IO::SEEK_SET: Integer
-
-IO::SHARE_DELETE: Integer
-
-IO::SYNC: Integer
-
-IO::TMPFILE: Integer
-
-IO::TRUNC: Integer
-
-IO::WRONLY: Integer
-
-IO::READABLE: Integer
-
-IO::WRITABLE: Integer
-
-IO::PRIORITY: Integer
-
-# <!-- rdoc-file=io.c -->
-# exception to wait for reading by EAGAIN. see IO.select.
-#
-class IO::EAGAINWaitReadable < Errno::EAGAIN
-  include IO::WaitReadable
-end
-
-IO::EAGAINWaitReadable::Errno: Integer
-
-# <!-- rdoc-file=io.c -->
-# exception to wait for writing by EAGAIN. see IO.select.
-#
-class IO::EAGAINWaitWritable < Errno::EAGAIN
-  include IO::WaitWritable
-end
-
-IO::EAGAINWaitWritable::Errno: Integer
-
-# <!-- rdoc-file=io.c -->
-# exception to wait for reading by EINPROGRESS. see IO.select.
-#
-class IO::EINPROGRESSWaitReadable < Errno::EINPROGRESS
-  include IO::WaitReadable
-end
-
-IO::EINPROGRESSWaitReadable::Errno: Integer
-
-# <!-- rdoc-file=io.c -->
-# exception to wait for writing by EINPROGRESS. see IO.select.
-#
-class IO::EINPROGRESSWaitWritable < Errno::EINPROGRESS
-  include IO::WaitWritable
-end
-
-IO::EINPROGRESSWaitWritable::Errno: Integer
-
-# <!-- rdoc-file=io.c -->
-# exception to wait for reading. see IO.select.
-#
-module IO::WaitReadable
-end
-
-# <!-- rdoc-file=io.c -->
-# exception to wait for writing. see IO.select.
-#
-module IO::WaitWritable
-end