e621stream 0.0.0

data/sorbet/rbi/gems/io-stream@0.14.0.rbi

@@ -0,0 +1,805 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `io-stream` gem.
+# Please instead update this file by running `bin/tapioca gem io-stream`.
+
+
+# Socket extensions for buffering support.
+#
+# pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:26
+class BasicSocket < ::IO
+  # Set the buffered state of the socket.
+  # @parameter value [Boolean] True to enable buffering, false to disable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:49
+  def buffered=(value); end
+
+  # Check if the socket is buffered.
+  # @returns [Boolean] True if the socket is buffered.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:37
+  def buffered?; end
+
+  # Check if this socket uses TCP protocol.
+  # @returns [Boolean] True if the socket is TCP over IPv4 or IPv6.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:29
+  def ip_protocol_tcp?; end
+
+  # Check if the socket is readable.
+  # @returns [Boolean] True if the socket is readable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/readable.rb:23
+  def readable?; end
+end
+
+# @namespace
+# Released under the MIT License.
+# Copyright, 2023-2025, by Samuel Williams.
+#
+# pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:7
+class IO
+  include ::Enumerable
+  include ::File::Constants
+
+  # Set the buffered state of the IO.
+  # @parameter value [Boolean] True to enable buffering, false to disable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:16
+  def buffered=(value); end
+
+  # Check if the IO is buffered.
+  # @returns [Boolean] True if the IO is buffered (not synchronized).
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:10
+  def buffered?; end
+
+  # Check if the IO is readable.
+  # @returns [Boolean] True if the IO is readable (not closed).
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/readable.rb:10
+  def readable?; end
+
+  class << self
+    # Convert any IO-like object into a buffered stream.
+    # @parameter io [IO] The IO object to wrap.
+    # @returns [IO::Stream::Buffered] A buffered stream wrapper.
+    #
+    # pkg:gem/io-stream#lib/io/stream.rb:15
+    def Stream(io); end
+  end
+end
+
+class IO::Buffer
+  include ::Comparable
+
+  def initialize(*_arg0); end
+
+  def &(_arg0); end
+  def <=>(_arg0); end
+  def ^(_arg0); end
+  def and!(_arg0); end
+  def clear(*_arg0); end
+  def copy(*_arg0); end
+  def each(*_arg0); end
+  def each_byte(*_arg0); end
+  def empty?; end
+  def external?; end
+  def free; end
+  def get_string(*_arg0); end
+  def get_value(_arg0, _arg1); end
+  def get_values(_arg0, _arg1); end
+  def hexdump(*_arg0); end
+  def inspect; end
+  def internal?; end
+  def locked; end
+  def locked?; end
+  def mapped?; end
+  def not!; end
+  def null?; end
+  def or!(_arg0); end
+  def pread(*_arg0); end
+  def private?; end
+  def pwrite(*_arg0); end
+  def read(*_arg0); end
+  def readonly?; end
+  def resize(_arg0); end
+  def set_string(*_arg0); end
+  def set_value(_arg0, _arg1, _arg2); end
+  def set_values(_arg0, _arg1, _arg2); end
+  def shared?; end
+  def size; end
+  def slice(*_arg0); end
+  def to_s; end
+  def transfer; end
+  def valid?; end
+  def values(*_arg0); end
+  def write(*_arg0); end
+  def xor!(_arg0); end
+  def |(_arg0); end
+  def ~; end
+
+  private
+
+  def initialize_copy(_arg0); end
+
+  class << self
+    def for(_arg0); end
+    def map(*_arg0); end
+    def size_of(_arg0); end
+    def string(_arg0); end
+  end
+end
+
+class IO::Buffer::AccessError < ::RuntimeError; end
+class IO::Buffer::AllocationError < ::RuntimeError; end
+IO::Buffer::BIG_ENDIAN = T.let(T.unsafe(nil), Integer)
+IO::Buffer::DEFAULT_SIZE = T.let(T.unsafe(nil), Integer)
+IO::Buffer::EXTERNAL = T.let(T.unsafe(nil), Integer)
+IO::Buffer::HOST_ENDIAN = T.let(T.unsafe(nil), Integer)
+IO::Buffer::INTERNAL = T.let(T.unsafe(nil), Integer)
+class IO::Buffer::InvalidatedError < ::RuntimeError; end
+IO::Buffer::LITTLE_ENDIAN = T.let(T.unsafe(nil), Integer)
+IO::Buffer::LOCKED = T.let(T.unsafe(nil), Integer)
+class IO::Buffer::LockedError < ::RuntimeError; end
+IO::Buffer::MAPPED = T.let(T.unsafe(nil), Integer)
+class IO::Buffer::MaskError < ::ArgumentError; end
+IO::Buffer::NETWORK_ENDIAN = T.let(T.unsafe(nil), Integer)
+IO::Buffer::PAGE_SIZE = T.let(T.unsafe(nil), Integer)
+IO::Buffer::PRIVATE = T.let(T.unsafe(nil), Integer)
+IO::Buffer::READONLY = T.let(T.unsafe(nil), Integer)
+IO::Buffer::SHARED = T.let(T.unsafe(nil), Integer)
+
+class IO::EAGAINWaitReadable < ::Errno::EAGAIN
+  include ::IO::WaitReadable
+end
+
+class IO::EAGAINWaitWritable < ::Errno::EAGAIN
+  include ::IO::WaitWritable
+end
+
+class IO::EINPROGRESSWaitReadable < ::Errno::EINPROGRESS
+  include ::IO::WaitReadable
+end
+
+class IO::EINPROGRESSWaitWritable < ::Errno::EINPROGRESS
+  include ::IO::WaitWritable
+end
+
+IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
+IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
+IO::PRIORITY = T.let(T.unsafe(nil), Integer)
+IO::READABLE = T.let(T.unsafe(nil), Integer)
+
+# Provides buffered IO streams with consistent read, write, and transport semantics.
+# Released under the MIT License.
+# Copyright, 2025-2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2023-2025, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2023-2026, by Samuel Williams.
+#
+# pkg:gem/io-stream#lib/io/stream/version.rb:6
+module IO::Stream
+  class << self
+    # Construct a buffered stream from either one duplex IO-like object or two separate endpoints.
+    # @parameter input [IO] The duplex IO object, or the readable endpoint.
+    # @parameter output [IO | Nil] The writable endpoint, when distinct from the readable endpoint.
+    # @parameter options [Hash] Additional options passed to the buffered stream wrapper.
+    # @returns [IO::Stream::Buffered] A buffered stream wrapping the supplied transport.
+    #
+    # pkg:gem/io-stream#lib/io/stream/duplex.rb:115
+    def Duplex(input, output = T.unsafe(nil), **options); end
+  end
+end
+
+# The default block size for IO buffers. Defaults to 256KB (optimized for modern SSDs and networks).
+#
+# pkg:gem/io-stream#lib/io/stream/readable.rb:10
+IO::Stream::BLOCK_SIZE = T.let(T.unsafe(nil), Integer)
+
+# A buffered stream implementation that wraps an underlying IO object to provide efficient buffered reading and writing.
+#
+# pkg:gem/io-stream#lib/io/stream/buffered.rb:12
+class IO::Stream::Buffered < ::IO::Stream::Generic
+  # Initialize a new buffered stream.
+  # @parameter io [IO] The underlying IO object to wrap.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:54
+  def initialize(io, *, **, &); end
+
+  # Close the read end of the stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:81
+  def close_read; end
+
+  # Close the write end of the stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:86
+  def close_write; end
+
+  # Check if the stream is closed.
+  # @returns [Boolean] True if the stream is closed.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:76
+  def closed?; end
+
+  # @attribute [IO] The wrapped IO object.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:66
+  def io; end
+
+  # Check if the stream is readable.
+  # @returns [Boolean] True if the stream is readable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:94
+  def readable?; end
+
+  # Get the underlying IO object.
+  # @returns [IO] The underlying IO object.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:70
+  def to_io; end
+
+  protected
+
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:100
+  def sysclose; end
+
+  # Reads data from the underlying stream as efficiently as possible.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:114
+  def sysread(size, buffer); end
+
+  # Attempts to read data from the underlying stream without blocking.
+  #
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:109
+  def sysread_nonblock(size, buffer); end
+
+  # pkg:gem/io-stream#lib/io/stream/buffered.rb:104
+  def syswrite(buffer); end
+
+  class << self
+    # Open a file and wrap it in a buffered stream.
+    # @parameter path [String] The file path to open.
+    # @parameter mode [String] The file mode (e.g., "r+", "w", "a").
+    # @parameter options [Hash] Additional options passed to the stream constructor.
+    # @returns [IO::Stream::Buffered] A buffered stream wrapping the opened file.
+    #
+    # pkg:gem/io-stream#lib/io/stream/buffered.rb:18
+    def open(path, mode = T.unsafe(nil), **options); end
+
+    # Wrap an existing IO object in a buffered stream.
+    # @parameter io [IO] The IO object to wrap.
+    # @parameter options [Hash] Additional options passed to the stream constructor.
+    # @returns [IO::Stream::Buffered] A buffered stream wrapping the IO object.
+    #
+    # pkg:gem/io-stream#lib/io/stream/buffered.rb:34
+    def wrap(io, **options); end
+  end
+end
+
+# Represents a connection reset error in IO streams, usually occurring when the remote side closes the connection unexpectedly.
+#
+# pkg:gem/io-stream#lib/io/stream/connection_reset_error.rb:8
+class IO::Stream::ConnectionResetError < ::Errno::ECONNRESET; end
+
+# A low-level duplex IO adapter that composes distinct readable and writable endpoints.
+#
+# pkg:gem/io-stream#lib/io/stream/duplex.rb:8
+class IO::Stream::Duplex
+  # Initialize a duplex transport from separate readable and writable endpoints.
+  # @parameter input [IO] The readable endpoint.
+  # @parameter output [IO] The writable endpoint.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:12
+  def initialize(input, output = T.unsafe(nil)); end
+
+  # Close both endpoints.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:74
+  def close; end
+
+  # Close the readable endpoint.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:46
+  def close_read; end
+
+  # Close the writable endpoint.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:57
+  def close_write; end
+
+  # Check whether both endpoints are closed.
+  # @returns [Boolean] True if the duplex stream can no longer read or write.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:41
+  def closed?; end
+
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:17
+  def input; end
+
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:18
+  def output; end
+
+  # Read data from the readable endpoint without blocking.
+  # @parameter size [Integer] The maximum number of bytes to read.
+  # @parameter buffer [String] The destination buffer.
+  # @parameter exception [Boolean] Whether to raise on `:wait_readable` and EOF conditions.
+  # @returns [String | Symbol | Nil] Data read from the endpoint, or the underlying non-blocking result.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:91
+  def read_nonblock(size, buffer, exception: T.unsafe(nil)); end
+
+  # Check whether the readable endpoint may still produce data.
+  # @returns [Boolean] True if the readable endpoint reports it is readable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:69
+  def readable?; end
+
+  # Return the maximum timeout across both endpoints.
+  # @returns [Numeric | Nil] The effective timeout, or `nil` if no timeout is configured.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:28
+  def timeout; end
+
+  # Update the timeout on both endpoints.
+  # @parameter duration [Numeric | Nil] The timeout to assign.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:34
+  def timeout=(duration); end
+
+  # Return the underlying IO used to represent this duplex stream.
+  # @returns [IO] The readable endpoint if available, otherwise the writable endpoint.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:22
+  def to_io; end
+
+  # Wait until the readable endpoint can be read.
+  # @parameter duration [Numeric | Nil] The maximum time to wait.
+  # @returns [Boolean] True if the endpoint became readable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:98
+  def wait_readable(duration = T.unsafe(nil)); end
+
+  # Wait until the writable endpoint can be written.
+  # @parameter duration [Numeric | Nil] The maximum time to wait.
+  # @returns [Boolean] True if the endpoint became writable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:105
+  def wait_writable(duration = T.unsafe(nil)); end
+
+  # Write data to the writable endpoint.
+  # @parameter buffer [String] The data to write.
+  # @returns [Integer] The number of bytes written.
+  #
+  # pkg:gem/io-stream#lib/io/stream/duplex.rb:82
+  def write(buffer); end
+end
+
+# Base class for stream implementations providing common functionality.
+#
+# pkg:gem/io-stream#lib/io/stream/generic.rb:18
+class IO::Stream::Generic
+  include ::IO::Stream::Readable
+  include ::IO::Stream::Writable
+
+  # Initialize a new generic stream.
+  # @parameter options [Hash] Options passed to included modules.
+  #
+  # pkg:gem/io-stream#lib/io/stream/generic.rb:32
+  def initialize(**options); end
+
+  # Best effort to flush any unwritten data, and then close the underling IO.
+  #
+  # pkg:gem/io-stream#lib/io/stream/generic.rb:43
+  def close; end
+
+  # Check if the stream is closed.
+  # @returns [Boolean] False by default, should be overridden by subclasses.
+  #
+  # pkg:gem/io-stream#lib/io/stream/generic.rb:38
+  def closed?; end
+
+  protected
+
+  # Closes the underlying IO stream.
+  # This method should be implemented by subclasses to handle the specific closing logic.
+  #
+  # pkg:gem/io-stream#lib/io/stream/generic.rb:59
+  def sysclose; end
+
+  # Reads data from the underlying stream as efficiently as possible.
+  # This method should be implemented by subclasses to handle the specific reading logic.
+  #
+  # pkg:gem/io-stream#lib/io/stream/generic.rb:73
+  def sysread(size, buffer); end
+
+  # Writes data to the underlying stream.
+  # This method should be implemented by subclasses to handle the specific writing logic.
+  # @parameter buffer [String] The data to write.
+  # @returns [Integer] The number of bytes written.
+  #
+  # pkg:gem/io-stream#lib/io/stream/generic.rb:67
+  def syswrite(buffer); end
+
+  class << self
+    # Check if a method is async-safe.
+    #
+    # @parameter method [Symbol] The method name to check.
+    # @returns [Symbol | Boolean] The concurrency guard for the given method.
+    #
+    # pkg:gem/io-stream#lib/io/stream/generic.rb:26
+    def async_safe?(method); end
+  end
+end
+
+# The maximum read size for a single read operation. This limit exists because:
+# 1. System calls like read() cannot handle requests larger than SSIZE_MAX
+# 2. Very large reads can cause memory pressure and poor interactive performance
+# 3. Most socket buffers and pipe capacities are much smaller anyway
+# On 64-bit systems SSIZE_MAX is ~8.8 million MB, on 32-bit it's ~2GB.
+# Our default of 16MB provides a good balance of throughput and responsiveness, and is page aligned.
+# It is also a multiple of the minimum read size, so that we can read in chunks without exceeding the maximum.
+#
+# pkg:gem/io-stream#lib/io/stream/readable.rb:22
+IO::Stream::MAXIMUM_READ_SIZE = T.let(T.unsafe(nil), Integer)
+
+# The minimum read size for efficient I/O operations. Defaults to the same as BLOCK_SIZE.
+#
+# pkg:gem/io-stream#lib/io/stream/readable.rb:13
+IO::Stream::MINIMUM_READ_SIZE = T.let(T.unsafe(nil), Integer)
+
+# The minimum write size before flushing. Defaults to 64KB.
+#
+# pkg:gem/io-stream#lib/io/stream/writable.rb:10
+IO::Stream::MINIMUM_WRITE_SIZE = T.let(T.unsafe(nil), Integer)
+
+# A module providing readable stream functionality.
+#
+# You must implement the `sysread` method to read data from the underlying IO. You may implement `sysread_nonblock` to support non-blocking partial peeks.
+#
+# pkg:gem/io-stream#lib/io/stream/readable.rb:27
+module IO::Stream::Readable
+  # Initialize readable stream functionality.
+  # @parameter minimum_read_size [Integer] The minimum size for read operations.
+  # @parameter maximum_read_size [Integer] The maximum size for read operations.
+  # @parameter block_size [Integer] Legacy parameter, use minimum_read_size instead.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:58
+  def initialize(minimum_read_size: T.unsafe(nil), maximum_read_size: T.unsafe(nil), block_size: T.unsafe(nil), **, &block); end
+
+  # Legacy accessor for backwards compatibility
+  # @returns [Integer] The minimum read size.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:75
+  def block_size; end
+
+  # Legacy setter for backwards compatibility
+  # @parameter value [Integer] The minimum read size.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:81
+  def block_size=(value); end
+
+  # Close the read end of the stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:398
+  def close_read; end
+
+  # Efficiently discard data from the stream until encountering pattern.
+  # @parameter pattern [String] The pattern to match.
+  # @parameter offset [Integer] The offset to start searching from.
+  # @parameter limit [Integer] The maximum number of bytes to read, including the pattern.
+  # @returns [String | Nil] The contents of the stream up until the pattern, or nil if the pattern was not found.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:229
+  def discard_until(pattern, offset = T.unsafe(nil), limit: T.unsafe(nil)); end
+
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:378
+  def eof!; end
+
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:368
+  def eof?; end
+
+  # Mark the stream as finished and raise `EOFError`.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:371
+  def finish!; end
+
+  # Determins if the stream has consumed all available data. May block if the stream is not readable.
+  # See {readable?} for a non-blocking alternative.
+  #
+  # @returns [Boolean] If the stream is at file which means there is no more data to be read.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:358
+  def finished?; end
+
+  # Read a line from the stream, similar to IO#gets.
+  # @parameter separator [String] The line separator to search for.
+  # @parameter limit [Integer | Nil] The maximum number of bytes to read.
+  # @parameter chomp [Boolean] Whether to remove the separator from the returned line.
+  # @returns [String | Nil] The line read from the stream, or nil if at end of stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:313
+  def gets(separator = T.unsafe(nil), limit = T.unsafe(nil), chomp: T.unsafe(nil)); end
+
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:71
+  def minimum_read_size; end
+
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:71
+  def minimum_read_size=(_arg0); end
+
+  # Peek at data in the buffer without consuming it.
+  # @parameter size [Integer | Nil] The number of bytes to peek at. If nil, peek at all available data.
+  # @returns [String] The data in the buffer without consuming it.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:249
+  def peek(size = T.unsafe(nil)); end
+
+  # Peek at data without consuming it, making at most one non-blocking read attempt.
+  #
+  # Any data read from the underlying stream is preserved in the read buffer. If
+  # the read would block or the stream is at EOF, this method returns `nil`.
+  #
+  # After this method returns `nil`, {readable?} indicates whether the read would
+  # block or EOF was observed.
+  #
+  # @parameter size [Integer] The maximum number of bytes to peek at.
+  # @returns [String | Nil] The immediately available data, or nil if no data can be read without blocking.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:283
+  def peek_partial(size = T.unsafe(nil)); end
+
+  # Read data from the stream.
+  # @parameter size [Integer | Nil] The number of bytes to read. If nil, read until end of stream.
+  # @parameter buffer [String | Nil] An optional buffer to fill with data instead of allocating a new string.
+  # @returns [String] The data read from the stream, or the provided buffer filled with data.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:89
+  def read(size = T.unsafe(nil), buffer = T.unsafe(nil)); end
+
+  # Read exactly the specified number of bytes.
+  # @parameter size [Integer] The number of bytes to read.
+  # @parameter exception [Class] The exception to raise if not enough data is available.
+  # @returns [String] The data read from the stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:154
+  def read_exactly(size, buffer = T.unsafe(nil), exception: T.unsafe(nil)); end
+
+  # Read at most `size` bytes from the stream. Will avoid reading from the underlying stream if possible.
+  # @parameter size [Integer | Nil] The number of bytes to read. If nil, read all available data.
+  # @parameter buffer [String | Nil] An optional buffer to fill with data instead of allocating a new string.
+  # @returns [String] The data read from the stream, or the provided buffer filled with data.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:132
+  def read_partial(size = T.unsafe(nil), buffer = T.unsafe(nil)); end
+
+  # Efficiently read data from the stream until encountering pattern.
+  # @parameter pattern [String] The pattern to match.
+  # @parameter offset [Integer] The offset to start searching from.
+  # @parameter limit [Integer] The maximum number of bytes to read, including the pattern (even if chomped).
+  # @parameter chomp [Boolean] Whether to remove the pattern from the returned data.
+  # @returns [String | Nil] The contents of the stream up until the pattern, or nil if the pattern was not found.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:212
+  def read_until(pattern, offset = T.unsafe(nil), limit: T.unsafe(nil), chomp: T.unsafe(nil)); end
+
+  # Whether there is a chance that a read operation will succeed or not.
+  # @returns [Boolean] If the stream is readable, i.e. a `read` operation has a chance of success.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:382
+  def readable?; end
+
+  # This is a compatibility shim for existing code that uses `readpartial`.
+  # @parameter size [Integer | Nil] The number of bytes to read.
+  # @parameter buffer [String | Nil] An optional buffer to fill with data instead of allocating a new string.
+  # @returns [String] The data read from the stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:170
+  def readpartial(size = T.unsafe(nil), buffer = T.unsafe(nil)); end
+
+  private
+
+  # Consumes at most `size` bytes from the buffer.
+  # @parameter size [Integer | Nil] The amount of data to consume. If nil, consume entire buffer.
+  # @parameter buffer [String | Nil] An optional buffer to fill with data instead of allocating a new string.
+  # @returns [String | Nil] The consumed data, or nil if no data available.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:443
+  def consume_read_buffer(size = T.unsafe(nil), buffer = T.unsafe(nil)); end
+
+  # Fills the buffer from the underlying stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:410
+  def fill_read_buffer(size = T.unsafe(nil)); end
+
+  # Find the index of a pattern in the read buffer, reading more data if needed.
+  # @parameter pattern [String] The pattern to search for.
+  # @parameter offset [Integer] The offset to start searching from.
+  # @parameter limit [Integer | Nil] The maximum number of bytes to read while searching.
+  # @returns [Integer | Nil] The index of the pattern, or nil if not found.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:179
+  def index_of(pattern, offset, limit, discard = T.unsafe(nil)); end
+
+  # Attempts to read data from the underlying stream without blocking.
+  # Implementations may override this method when non-blocking reads are supported.
+  #
+  # pkg:gem/io-stream#lib/io/stream/readable.rb:405
+  def sysread_nonblock(size, buffer); end
+
+  class << self
+    # Check if a method is async-safe.
+    #
+    # @parameter method [Symbol] The method name to check.
+    # @returns [Symbol | Boolean] The concurrency guard for the given method.
+    #
+    # pkg:gem/io-stream#lib/io/stream/readable.rb:50
+    def async_safe?(method); end
+  end
+end
+
+# pkg:gem/io-stream#lib/io/stream/readable.rb:28
+IO::Stream::Readable::ASYNC_SAFE = T.let(T.unsafe(nil), Hash)
+
+# A specialized string buffer for binary data with automatic encoding handling.
+#
+# pkg:gem/io-stream#lib/io/stream/string_buffer.rb:8
+class IO::Stream::StringBuffer < ::String
+  # Initialize a new string buffer with binary encoding.
+  #
+  # pkg:gem/io-stream#lib/io/stream/string_buffer.rb:12
+  def initialize; end
+
+  # Append a string to the buffer, converting to binary encoding if necessary.
+  # @parameter string [String] The string to append.
+  # @returns [StringBuffer] Self for method chaining.
+  #
+  # pkg:gem/io-stream#lib/io/stream/string_buffer.rb:21
+  def <<(string); end
+
+  # pkg:gem/io-stream#lib/io/stream/string_buffer.rb:31
+  def concat(string); end
+end
+
+# pkg:gem/io-stream#lib/io/stream/string_buffer.rb:9
+IO::Stream::StringBuffer::BINARY = T.let(T.unsafe(nil), Encoding)
+
+# pkg:gem/io-stream#lib/io/stream/version.rb:7
+IO::Stream::VERSION = T.let(T.unsafe(nil), String)
+
+# A module providing writable stream functionality.
+#
+# You must implement the `syswrite` method to write data to the underlying IO.
+#
+# pkg:gem/io-stream#lib/io/stream/writable.rb:15
+module IO::Stream::Writable
+  # Initialize writable stream functionality.
+  # @parameter minimum_write_size [Integer] The minimum buffer size before flushing.
+  #
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:32
+  def initialize(minimum_write_size: T.unsafe(nil), **, &block); end
+
+  # Appends `string` to the buffer and returns self for method chaining.
+  # @parameter string [String] the string to write to the stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:71
+  def <<(string); end
+
+  # Close the write end of the stream by flushing any remaining data.
+  #
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:93
+  def close_write; end
+
+  # Flushes buffered data to the stream.
+  #
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:43
+  def flush; end
+
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:40
+  def minimum_write_size; end
+
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:40
+  def minimum_write_size=(_arg0); end
+
+  # Write arguments to the stream followed by a separator and flush immediately.
+  # @parameter arguments [Array] The arguments to write to the stream.
+  # @parameter separator [String] The separator to append after each argument.
+  #
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:80
+  def puts(*arguments, separator: T.unsafe(nil)); end
+
+  # Writes `string` to the buffer. When the buffer is full or #sync is true the
+  # buffer is flushed to the underlying `io`.
+  # @parameter string [String] the string to write to the buffer.
+  # @returns [Integer] the number of bytes appended to the buffer.
+  #
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:55
+  def write(string, flush: T.unsafe(nil)); end
+
+  private
+
+  # pkg:gem/io-stream#lib/io/stream/writable.rb:97
+  def drain(buffer); end
+
+  class << self
+    # Check if a method is async-safe.
+    #
+    # @parameter method [Symbol] The method name to check.
+    # @returns [Symbol | Boolean] The concurrency guard for the given method.
+    #
+    # pkg:gem/io-stream#lib/io/stream/writable.rb:26
+    def async_safe?(method); end
+  end
+end
+
+# pkg:gem/io-stream#lib/io/stream/writable.rb:16
+IO::Stream::Writable::ASYNC_SAFE = T.let(T.unsafe(nil), Hash)
+
+IO::WRITABLE = T.let(T.unsafe(nil), Integer)
+
+# SSL socket extensions for stream compatibility.
+#
+# pkg:gem/io-stream#lib/io/stream/shim/readable.rb:53
+class OpenSSL::SSL::SSLSocket
+  include ::Enumerable
+
+  # Set the buffered state of the SSL socket.
+  # @parameter value [Boolean] True to enable buffering, false to disable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/openssl.rb:25
+  def buffered=(value); end
+
+  # Check if the SSL socket is buffered.
+  # @returns [Boolean] True if the SSL socket is buffered.
+  #
+  # pkg:gem/io-stream#lib/io/stream/openssl.rb:17
+  def buffered?; end
+
+  # Check if the SSL socket is readable.
+  # @returns [Boolean] True if the SSL socket is readable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/readable.rb:57
+  def readable?; end
+end
+
+# StringIO extensions for buffering support.
+#
+# pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:68
+class StringIO
+  include ::Enumerable
+
+  # Set the buffered state of the StringIO.
+  # @parameter value [Boolean] True to enable buffering, false to disable.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:77
+  def buffered=(value); end
+
+  # Check if the StringIO is buffered.
+  # @returns [Boolean] True if the StringIO is buffered (not synchronized).
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/buffered.rb:71
+  def buffered?; end
+
+  # Check if the StringIO is readable.
+  # @returns [Boolean] True if the StringIO is readable (not at EOF).
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/readable.rb:45
+  def readable?; end
+
+  # Return the configured timeout for this in-memory stream.
+  # @returns [Numeric | Nil] The configured timeout, if any.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/timeout.rb:12
+  def timeout; end
+
+  # Store timeout state for compatibility with IO-like timeout interfaces.
+  # @parameter duration [Numeric | Nil] The timeout to assign.
+  # @returns [Numeric | Nil] The assigned timeout.
+  #
+  # pkg:gem/io-stream#lib/io/stream/shim/timeout.rb:21
+  def timeout=(duration); end
+end