steep 0.14.0 → 0.15.0

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

@@ -1,74 +1,187 @@
-# [Random](Random) provides an interface to Ruby's
-# pseudo-random number generator, or PRNG. The PRNG produces a
-# deterministic sequence of bits which approximate true randomness. The
-# sequence may be represented by integers, floats, or binary strings.
-# 
+# Random provides an interface to Ruby's pseudo-random number generator, or
+# PRNG.  The PRNG produces a deterministic sequence of bits which approximate
+# true randomness. The sequence may be represented by integers, floats, or
+# binary strings.
+#
 # The generator may be initialized with either a system-generated or
-# user-supplied seed value by using
-# [::srand](Random#method-c-srand).
-# 
-# The class method [\#rand](Random#method-i-rand)
-# provides the base functionality of
-# [Kernel\#rand](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-rand)
-# along with better handling of floating point values. These are both
-# interfaces to Random::DEFAULT, the Ruby system PRNG.
-# 
-# [::new](Random#method-c-new) will create a new PRNG
-# with a state independent of Random::DEFAULT, allowing multiple
-# generators with different seed values or sequence positions to exist
-# simultaneously. [Random](Random) objects can be
-# marshaled, allowing sequences to be saved and resumed.
-# 
-# PRNGs are currently implemented as a modified Mersenne Twister with a
-# period of 2\*\*19937-1.
+# user-supplied seed value by using Random.srand.
+#
+# The class method Random.rand provides the base functionality of Kernel.rand
+# along with better handling of floating point values. These are both interfaces
+# to Random::DEFAULT, the Ruby system PRNG.
+#
+# Random.new will create a new PRNG with a state independent of Random::DEFAULT,
+# allowing multiple generators with different seed values or sequence positions
+# to exist simultaneously. Random objects can be marshaled, allowing sequences
+# to be saved and resumed.
+#
+# PRNGs are currently implemented as a modified Mersenne Twister with a period
+# of 2**19937-1.
+#
 class Random < Object
   include Random::Formatter
 
+  # Returns true if the two generators have the same internal state, otherwise
+  # false.  Equivalent generators will return the same sequence of pseudo-random
+  # numbers.  Two generators will generally have the same state only if they were
+  # initialized with the same seed
+  #
+  #     Random.new == Random.new             # => false
+  #     Random.new(1234) == Random.new(1234) # => true
+  #
+  # and have the same invocation history.
+  #
+  #     prng1 = Random.new(1234)
+  #     prng2 = Random.new(1234)
+  #     prng1 == prng2 # => true
+  #
+  #     prng1.rand     # => 0.1915194503788923
+  #     prng1 == prng2 # => false
+  #
+  #     prng2.rand     # => 0.1915194503788923
+  #     prng1 == prng2 # => true
+  #
   def ==: (untyped arg0) -> bool
 
+  # Returns a random binary string containing `size` bytes.
+  #
+  #     random_string = Random.new.bytes(10) # => "\xD7:R\xAB?\x83\xCE\xFAkO"
+  #     random_string.size                   # => 10
+  #
   def bytes: (Integer size) -> String
 
+  # Creates a new PRNG using `seed` to set the initial state. If `seed` is
+  # omitted, the generator is initialized with Random.new_seed.
+  #
+  # See Random.srand for more information on the use of seed values.
+  #
   def initialize: (?Integer seed) -> void
 
+  # When `max` is an Integer, `rand` returns a random integer greater than or
+  # equal to zero and less than `max`. Unlike Kernel.rand, when `max` is a
+  # negative integer or zero, `rand` raises an ArgumentError.
+  #
+  #     prng = Random.new
+  #     prng.rand(100)       # => 42
+  #
+  # When `max` is a Float, `rand` returns a random floating point number between
+  # 0.0 and `max`, including 0.0 and excluding `max`.
+  #
+  #     prng.rand(1.5)       # => 1.4600282860034115
+  #
+  # When `max` is a Range, `rand` returns a random number where
+  # range.member?(number) == true.
+  #
+  #     prng.rand(5..9)      # => one of [5, 6, 7, 8, 9]
+  #     prng.rand(5...9)     # => one of [5, 6, 7, 8]
+  #     prng.rand(5.0..9.0)  # => between 5.0 and 9.0, including 9.0
+  #     prng.rand(5.0...9.0) # => between 5.0 and 9.0, excluding 9.0
+  #
+  # Both the beginning and ending values of the range must respond to subtract
+  # (`-`) and add (`+`)methods, or rand will raise an ArgumentError.
+  #
   def rand: () -> Float
           | (Integer | ::Range[Integer] max) -> Integer
           | (Float | ::Range[Float] max) -> Float
 
-  # Returns the seed value used to initialize the generator. This may be
-  # used to initialize another generator with the same state at a later
-  # time, causing it to produce the same sequence of numbers.
-  # 
-  # ```ruby
-  # prng1 = Random.new(1234)
-  # prng1.seed       #=> 1234
-  # prng1.rand(100)  #=> 47
-  # 
-  # prng2 = Random.new(prng1.seed)
-  # prng2.rand(100)  #=> 47
-  # ```
+  # Returns the seed value used to initialize the generator. This may be used to
+  # initialize another generator with the same state at a later time, causing it
+  # to produce the same sequence of numbers.
+  #
+  #     prng1 = Random.new(1234)
+  #     prng1.seed       #=> 1234
+  #     prng1.rand(100)  #=> 47
+  #
+  #     prng2 = Random.new(prng1.seed)
+  #     prng2.rand(100)  #=> 47
+  #
   def seed: () -> Integer
 
-  # Returns an arbitrary seed value. This is used by
-  # [::new](Random.downloaded.ruby_doc#method-c-new) when no seed value is
-  # specified as an argument.
-  # 
-  # ```ruby
-  # Random.new_seed  #=> 115032730400174366788466674494640623225
-  # ```
+  # Returns an arbitrary seed value. This is used by Random.new when no seed value
+  # is specified as an argument.
+  #
+  #     Random.new_seed  #=> 115032730400174366788466674494640623225
+  #
   def self.new_seed: () -> Integer
 
+  # Alias of Random::DEFAULT.rand.
+  #
   def self.rand: (?Integer max) -> Numeric
 
+  # Seeds the system pseudo-random number generator, Random::DEFAULT, with
+  # `number`.  The previous seed value is returned.
+  #
+  # If `number` is omitted, seeds the generator using a source of entropy provided
+  # by the operating system, if available (/dev/urandom on Unix systems or the RSA
+  # cryptographic provider on Windows), which is then combined with the time, the
+  # process id, and a sequence number.
+  #
+  # srand may be used to ensure repeatable sequences of pseudo-random numbers
+  # between different runs of the program. By setting the seed to a known value,
+  # programs can be made deterministic during testing.
+  #
+  #     srand 1234               # => 268519324636777531569100071560086917274
+  #     [ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
+  #     [ rand(10), rand(1000) ] # => [4, 664]
+  #     srand 1234               # => 1234
+  #     [ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
+  #
   def self.srand: (?Integer number) -> Numeric
 end
 
+# The default Pseudorandom number generator.  Used by class methods of Random.
+#
+#
 Random::DEFAULT: Random
 
+# Format raw random number as Random does
+#
+#
 module Random::Formatter
+  # SecureRandom.base64 generates a random base64 string.
+  #
+  # The argument *n* specifies the length, in bytes, of the random number to be
+  # generated. The length of the result string is about 4/3 of *n*.
+  #
+  # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
+  # future.
+  #
+  # The result may contain A-Z, a-z, 0-9, "+", "/" and "=".
+  #
+  #     require 'securerandom'
+  #
+  #     SecureRandom.base64 #=> "/2BuBuLf3+WfSKyQbRcc/A=="
+  #     SecureRandom.base64 #=> "6BbW0pxO0YENxn38HMUbcQ=="
+  #
+  # If a secure random number generator is not available, `NotImplementedError` is
+  # raised.
+  #
+  # See RFC 3548 for the definition of base64.
+  #
   def base64: (?Integer? n) -> String
 
+  # SecureRandom.hex generates a random hexadecimal string.
+  #
+  # The argument *n* specifies the length, in bytes, of the random number to be
+  # generated. The length of the resulting hexadecimal string is twice of *n*.
+  #
+  # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
+  # future.
+  #
+  # The result may contain 0-9 and a-f.
+  #
+  #     require 'securerandom'
+  #
+  #     SecureRandom.hex #=> "eb693ec8252cd630102fd0d0fb7c3485"
+  #     SecureRandom.hex #=> "91dc3bfb4de5b11d029d376634589b61"
+  #
+  # If a secure random number generator is not available, `NotImplementedError` is
+  # raised.
+  #
   def hex: (?Integer? n) -> String
 
+  # Generates formatted random number from raw random bytes. See Random#rand.
+  #
   def rand: () -> Float
           | (?Float? n) -> Float
           | (?Integer? n) -> Integer
@@ -77,8 +190,26 @@ module Random::Formatter
           | (?::Range[Integer]? n) -> Integer
           | (?::Range[Numeric]? n) -> Numeric
 
+  # SecureRandom.random_bytes generates a random binary string.
+  #
+  # The argument *n* specifies the length of the result string.
+  #
+  # If *n* is not specified or is nil, 16 is assumed. It may be larger in future.
+  #
+  # The result may contain any byte: "x00" - "xff".
+  #
+  #     require 'securerandom'
+  #
+  #     SecureRandom.random_bytes #=> "\xD8\\\xE0\xF4\r\xB2\xFC*WM\xFF\x83\x18\xF45\xB6"
+  #     SecureRandom.random_bytes #=> "m\xDC\xFC/\a\x00Uf\xB2\xB2P\xBD\xFF6S\x97"
+  #
+  # If a secure random number generator is not available, `NotImplementedError` is
+  # raised.
+  #
   def random_bytes: (?Integer? n) -> String
 
+  # Generates formatted random number from raw random bytes. See Random#rand.
+  #
   def random_number: () -> Float
                    | (?Float? n) -> Float
                    | (?Integer? n) -> Integer
@@ -87,7 +218,50 @@ module Random::Formatter
                    | (?::Range[Integer]? n) -> Integer
                    | (?::Range[Numeric]? n) -> Numeric
 
+  # SecureRandom.urlsafe_base64 generates a random URL-safe base64 string.
+  #
+  # The argument *n* specifies the length, in bytes, of the random number to be
+  # generated. The length of the result string is about 4/3 of *n*.
+  #
+  # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
+  # future.
+  #
+  # The boolean argument *padding* specifies the padding. If it is false or nil,
+  # padding is not generated. Otherwise padding is generated. By default, padding
+  # is not generated because "=" may be used as a URL delimiter.
+  #
+  # The result may contain A-Z, a-z, 0-9, "-" and "_". "=" is also used if
+  # *padding* is true.
+  #
+  #     require 'securerandom'
+  #
+  #     SecureRandom.urlsafe_base64 #=> "b4GOKm4pOYU_-BOXcrUGDg"
+  #     SecureRandom.urlsafe_base64 #=> "UZLdOkzop70Ddx-IJR0ABg"
+  #
+  #     SecureRandom.urlsafe_base64(nil, true) #=> "i0XQ-7gglIsHGV2_BNPrdQ=="
+  #     SecureRandom.urlsafe_base64(nil, true) #=> "-M8rLhr7JEpJlqFGUMmOxg=="
+  #
+  # If a secure random number generator is not available, `NotImplementedError` is
+  # raised.
+  #
+  # See RFC 3548 for the definition of URL-safe base64.
+  #
   def urlsafe_base64: (?Integer? n, ?bool padding) -> String
 
+  # SecureRandom.uuid generates a random v4 UUID (Universally Unique IDentifier).
+  #
+  #     require 'securerandom'
+  #
+  #     SecureRandom.uuid #=> "2d931510-d99f-494a-8c67-87feb05e1594"
+  #     SecureRandom.uuid #=> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
+  #     SecureRandom.uuid #=> "62936e70-1815-439b-bf89-8492855a7e6b"
+  #
+  # The version 4 UUID is purely random (except the version). It doesn't contain
+  # meaningful information such as MAC addresses, timestamps, etc.
+  #
+  # The result contains 122 random bits (15.25 random bytes).
+  #
+  # See RFC 4122 for details of UUID.
+  #
   def uuid: () -> String
 end

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

@@ -1,10 +1,57 @@
+# The module storing Ruby interpreter configurations on building.
+#
+# This file was created by mkconfig.rb when ruby was built.  It contains build
+# information for ruby which is used e.g. by mkmf to build compatible native
+# extensions.  Any changes made to this file will be lost the next time ruby is
+# built.
+#
 module RbConfig
+  # expands variable with given `val` value.
+  #
+  #     RbConfig.expand("$(bindir)") # => /home/foobar/all-ruby/ruby19x/bin
+  #
+  def self.expand: (String val, ?Hash[String, String] config) -> String
+
+  def self.fire_update!: (String key, String val, ?Hash[String, String] mkconf, ?Hash[String, String] conf) -> Array[String]?
+
+  def self.ruby: () -> String
 end
 
+# The hash configurations stored.
+#
 RbConfig::CONFIG: Hash[String, String]
 
+# DESTDIR on make install.
+#
 RbConfig::DESTDIR: String
 
+# Almost same with CONFIG. MAKEFILE_CONFIG has other variable reference like
+# below.
+#
+#     MAKEFILE_CONFIG["bindir"] = "$(exec_prefix)/bin"
+#
+# The values of this constant is used for creating Makefile.
+#
+#     require 'rbconfig'
+#
+#     print <<-END_OF_MAKEFILE
+#     prefix = #{Config::MAKEFILE_CONFIG['prefix']}
+#     exec_prefix = #{Config::MAKEFILE_CONFIG['exec_prefix']}
+#     bindir = #{Config::MAKEFILE_CONFIG['bindir']}
+#     END_OF_MAKEFILE
+#
+#     => prefix = /usr/local
+#        exec_prefix = $(prefix)
+#        bindir = $(exec_prefix)/bin  MAKEFILE_CONFIG = {}
+#
+# RbConfig.expand is used for resolving references like above in rbconfig.
+#
+#     require 'rbconfig'
+#     p Config.expand(Config::MAKEFILE_CONFIG["bindir"])
+#     # => "/usr/local/bin"
+#
 RbConfig::MAKEFILE_CONFIG: Hash[String, String]
 
+# Ruby installed directory.
+#
 RbConfig::TOPDIR: String

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

@@ -754,14 +754,14 @@ class String
   # :   Replaces CRLF ("r\n") and CR ("r") with LF ("n") if value is true.
   #
   #
-  def encode: (?Encoding | string encoding, ?Encoding | string from_encoding, ?invalid: :replace ?, ?undef: :replace ?, ?replace: String, ?fallback: Hash[String, String] | Proc | Method, ?xml: :text | :attr, ?universal_newline: true, ?cr_newline: true, ?crlf_newline: true) -> String
+  def encode: (?Encoding | string encoding, ?Encoding | string from_encoding, ?invalid: :replace ?, ?undef: :replace ?, ?replace: String, ?fallback: String::encode_fallback, ?xml: :text | :attr, ?universal_newline: true, ?cr_newline: true, ?crlf_newline: true) -> String
 
   # The first form transcodes the contents of *str* from str.encoding to
   # `encoding`. The second form transcodes the contents of *str* from src_encoding
   # to dst_encoding. The options Hash gives details for conversion. See
   # String#encode for details. Returns the string even if no changes were made.
   #
-  def encode!: (?Encoding | string encoding, ?Encoding | string from_encoding, ?invalid: :replace ?, ?undef: :replace ?, ?replace: String, ?fallback: Hash[String, String] | Proc | Method, ?xml: :text | :attr, ?universal_newline: true, ?cr_newline: true, ?crlf_newline: true) -> self
+  def encode!: (?Encoding | string encoding, ?Encoding | string from_encoding, ?invalid: :replace ?, ?undef: :replace ?, ?replace: String, ?fallback: String::encode_fallback, ?xml: :text | :attr, ?universal_newline: true, ?cr_newline: true, ?crlf_newline: true) -> self
 
   # Returns the Encoding object that represents the encoding of obj.
   #
@@ -1005,6 +1005,7 @@ class String
   # The return value in this case is the value from block execution.
   #
   def match: (Regexp | string pattern, ?int pos) -> MatchData?
+           | [A] (Regexp | string pattern, ?int pos) { (MatchData) -> A } -> A
 
   # Converts *pattern* to a `Regexp` (if it isn't already one), then returns a
   # `true` or `false` indicates whether the regexp is matched *str* or not without
@@ -1892,3 +1893,9 @@ class String
   #
   alias initialize_copy replace
 end
+
+interface _ArefFromStringToString
+  def []: (String) -> String
+end
+
+type String::encode_fallback = Hash[String, String] | Proc | Method | _ArefFromStringToString

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

@@ -1,13 +1,284 @@
+# Pseudo I/O on String object, with interface corresponding to IO.
+#
+# Commonly used to simulate `$stdio` or `$stderr`
+#
+# ### Examples
+#
+#     require 'stringio'
+#
+#     # Writing stream emulation
+#     io = StringIO.new
+#     io.puts "Hello World"
+#     io.string #=> "Hello World\n"
+#
+#     # Reading stream emulation
+#     io = StringIO.new "first\nsecond\nlast\n"
+#     io.getc #=> "f"
+#     io.gets #=> "irst\n"
+#     io.read #=> "second\nlast\n"
+#
 class StringIO
-  def initialize: (?String, ?String) -> untyped
-  def puts: (*untyped) -> void
-  def readline: () -> String
-              | (String) -> String
-  def write: (String) -> void
-  def flush: () -> void
-  def string: -> String
-  def close_read: -> nil
-  def closed_read?: -> bool
-  def close_write: -> nil
-  def closed_write?: -> bool
+  # Creates new StringIO instance from with *string* and *mode*.
+  #
+  def initialize: (?String string, ?String? mode) -> void
+
+  # Equivalent to StringIO.new except that when it is called with a block, it
+  # yields with the new instance and closes it, and returns the result which
+  # returned from the block.
+  #
+  def self.open: [U] (?String string, ?String? mode) { (StringIO arg) -> U } -> U
+
+  def <<: (untyped arg0) -> self
+
+  # Puts stream into binary mode. See IO#binmode.
+  #
+  def binmode: () -> self
+
+  # Closes a StringIO. The stream is unavailable for any further data operations;
+  # an `IOError` is raised if such an attempt is made.
+  #
+  def close: () -> nil
+
+  # Closes the read end of a StringIO.  Will raise an `IOError` if the receiver is
+  # not readable.
+  #
+  def close_read: () -> nil
+
+  # Closes the write end of a StringIO.  Will raise an  `IOError` if the receiver
+  # is not writeable.
+  #
+  def close_write: () -> nil
+
+  # Returns `true` if the stream is completely closed, `false` otherwise.
+  #
+  def closed?: () -> bool
+
+  # Returns `true` if the stream is not readable, `false` otherwise.
+  #
+  def closed_read?: () -> bool
+
+  # Returns `true` if the stream is not writable, `false` otherwise.
+  #
+  def closed_write?: () -> bool
+
+  # See IO#each.
+  #
+  def each: (?String sep, ?Integer limit, ?chomp: bool) { (String arg0) -> untyped } -> self
+          | (?String sep, ?Integer limit, ?chomp: bool) -> ::Enumerator[String, self]
+
+  # See IO#each_byte.
+  #
+  def each_byte: () { (Integer arg0) -> untyped } -> self
+               | () -> ::Enumerator[Integer, self]
+
+  # See IO#each_char.
+  #
+  def each_char: () { (String arg0) -> untyped } -> self
+               | () -> ::Enumerator[String, self]
+
+  # See IO#each_codepoint.
+  #
+  def each_codepoint: () { (Integer arg0) -> untyped } -> self
+                    | () -> ::Enumerator[Integer, self]
+
+  # Returns true if the stream is at the end of the data (underlying string). The
+  # stream must be opened for reading or an `IOError` will be raised.
+  #
+  def eof: () -> bool
+
+  # Raises NotImplementedError.
+  #
+  def fcntl: (Integer integer_cmd, String | Integer arg) -> Integer
+
+  # Returns `nil`.  Just for compatibility to IO.
+  #
+  def fileno: () -> nil
+
+  # Returns an object itself.  Just for compatibility to IO.
+  #
+  def flush: () -> self
+
+  # Returns 0.  Just for compatibility to IO.
+  #
+  def fsync: () -> Integer?
+
+  # See IO#getbyte.
+  #
+  def getbyte: () -> Integer?
+
+  # See IO#getc.
+  #
+  def getc: () -> String?
+
+  # See IO#gets.
+  #
+  def gets: (?String sep, ?Integer limit, ?chomp: bool) -> String?
+
+  # Returns the Encoding of the internal string if conversion is specified. 
+  # Otherwise returns `nil`.
+  #
+  def internal_encoding: () -> Encoding
+
+  # Returns the Encoding object that represents the encoding of the file. If the
+  # stream is write mode and no encoding is specified, returns `nil`.
+  #
+  def external_encoding: () -> Encoding
+
+  # Returns `false`.  Just for compatibility to IO.
+  #
+  def isatty: () -> bool
+
+  # Returns the current line number. 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.  See also the  `$.` variable.
+  #
+  def lineno: () -> Integer
+
+  # Manually sets the current line number to the given value. `$.` is updated only
+  # on the next read.
+  #
+  def lineno=: (Integer arg0) -> Integer
+
+  # Returns `nil`.  Just for compatibility to IO.
+  #
+  def pid: () -> nil
+
+  # Returns the current offset (in bytes).
+  #
+  def pos: () -> Integer
+
+  # Seeks to the given position (in bytes).
+  #
+  def pos=: (Integer arg0) -> Integer
+
+  def print: (*untyped arg0) -> nil
+
+  def printf: (String format_string, *untyped arg0) -> nil
+
+  # See IO#putc.
+  #
+  def putc: (Numeric | String arg0) -> untyped
+
+  def puts: (*untyped arg0) -> nil
+
+  # See IO#read.
+  #
+  def read: (?Integer length, ?String outbuf) -> String?
+
+  def read_nonblock: (Integer len) -> String
+                   | (Integer len, ?String buf) -> String
+
+  def readbyte: () -> Integer
+
+  def readchar: () -> String
+
+  def readline: (?String sep, ?Integer limit) -> String
+
+  # See IO#readlines.
+  #
+  def readlines: (?String sep, ?Integer limit, ?chomp: bool) -> ::Array[String]
+
+  def readpartial: (Integer maxlen) -> String
+                 | (Integer maxlen, ?String outbuf) -> String
+
+  # Reinitializes the stream with the given *other_StrIO* or *string* and *mode*
+  # (see StringIO#new).
+  #
+  def reopen: (StringIO other) -> self
+            | (String other, ?String mode_str) -> self
+
+  # Positions the stream to the beginning of input, resetting `lineno` to zero.
+  #
+  def rewind: () -> Integer
+
+  # Seeks to a given offset *amount* in the stream according to the value of
+  # *whence* (see IO#seek).
+  #
+  def seek: (Integer amount, ?Integer whence) -> Integer
+
+  # Specify the encoding of the StringIO as *ext_enc*. Use the default external
+  # encoding if *ext_enc* is nil. 2nd argument *int_enc* and optional hash *opt*
+  # argument are ignored; they are for API compatibility to IO.
+  #
+  def set_encoding: (?String | Encoding ext_or_ext_int_enc) -> self
+                  | (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc) -> self
+
+  # Returns underlying String object, the subject of IO.
+  #
+  def string: () -> String
+
+  # Changes underlying String object, the subject of IO.
+  #
+  def string=: (String str) -> String
+
+  # Returns the size of the buffer string.
+  #
+  def size: () -> Integer
+
+  # Returns `true` always.
+  #
+  def sync: () -> bool
+
+  # Returns the argument unchanged.  Just for compatibility to IO.
+  #
+  def sync=: (bool arg0) -> bool
+
+  def sysread: (Integer maxlen, String outbuf) -> String
+
+  def syswrite: (String arg0) -> Integer
+
+  # Returns the current offset (in bytes).
+  #
+  def tell: () -> Integer
+
+  # Returns `false`.  Just for compatibility to IO.
+  #
+  def tty?: () -> bool
+
+  # See IO#ungetbyte
+  #
+  def ungetbyte: (String | Integer arg0) -> nil
+
+  # Pushes back one character (passed as a parameter) such that a subsequent
+  # buffered read will return it.  There is no limitation for multiple pushbacks
+  # including pushing back behind the beginning of the buffer string.
+  #
+  def ungetc: (String arg0) -> nil
+
+  # Appends the given string to the underlying buffer string. The stream must be
+  # opened for writing.  If the argument is not a string, it will be converted to
+  # a string using `to_s`. Returns the number of bytes written.  See IO#write.
+  #
+  def write: (String arg0) -> Integer
+
+  # This is a deprecated alias for #each_byte.
+  #
+  def bytes: () { (Integer arg0) -> untyped } -> self
+           | () -> ::Enumerator[Integer, self]
+
+  # This is a deprecated alias for #each_char.
+  #
+  def chars: () { (String arg0) -> untyped } -> self
+           | () -> ::Enumerator[String, self]
+
+  # This is a deprecated alias for #each_codepoint.
+  #
+  def codepoints: () { (Integer arg0) -> untyped } -> self
+                | () -> ::Enumerator[Integer, self]
+
+  # See IO#each.
+  #
+  def each_line: (?String sep, ?Integer limit, ?chomp: bool) { (String arg0) -> untyped } -> self
+               | (?String sep, ?Integer limit, ?chomp: bool) -> ::Enumerator[String, self]
+
+  # Returns true if the stream is at the end of the data (underlying string). The
+  # stream must be opened for reading or an `IOError` will be raised.
+  #
+  def eof?: () -> bool
+
+  # This is a deprecated alias for #each_line.
+  #
+  def lines: (?String sep, ?Integer limit) { (String arg0) -> untyped } -> self
+           | (?String sep, ?Integer limit) -> ::Enumerator[String, self]
 end