e621stream 0.0.0

data/sorbet/rbi/gems/protocol-http1@0.41.1.rbi

@@ -0,0 +1,894 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `protocol-http1` gem.
+# Please instead update this file by running `bin/tapioca gem protocol-http1`.
+
+
+# @namespace
+# Released under the MIT License.
+# Copyright, 2019-2026, by Samuel Williams.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/version.rb:6
+module Protocol; end
+
+# @namespace
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/version.rb:7
+module Protocol::HTTP1; end
+
+# A header name or value was invalid, e.g. contains invalid characters.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/error.rb:28
+class Protocol::HTTP1::BadHeader < ::Protocol::HTTP1::BadRequest; end
+
+# The request was not able to be parsed correctly, or failed some kind of validation.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/error.rb:23
+class Protocol::HTTP1::BadRequest < ::Protocol::HTTP1::Error
+  include ::Protocol::HTTP::BadRequest
+end
+
+# A collection of classes for handling HTTP/1.1 request and response bodies.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:11
+module Protocol::HTTP1::Body; end
+
+# Represents a chunked body, which is a series of chunks, each with a length prefix.
+#
+# See https://tools.ietf.org/html/rfc7230#section-4.1 for more details on the chunked transfer encoding.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:15
+class Protocol::HTTP1::Body::Chunked < ::Protocol::HTTP::Body::Readable
+  # Initialize the chunked body.
+  #
+  # @parameter connection [Protocol::HTTP1::Connection] the connection to read the body from.
+  # @parameter headers [Protocol::HTTP::Headers] the headers to read the trailer into, if any.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:25
+  def initialize(connection, headers); end
+
+  # @returns [Hash] JSON representation for tracing and debugging.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:140
+  def as_json(*, **, &); end
+
+  # Close the connection and mark the body as finished.
+  #
+  # @parameter error [Exception | Nil] the error that caused the body to be closed, if any.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:55
+  def close(error = T.unsafe(nil)); end
+
+  # @attribute [Integer] the number of chunks read so far.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:37
+  def count; end
+
+  # @returns [Boolean] true if the body is empty, in other words {read} will return `nil`.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:48
+  def empty?; end
+
+  # @returns [String] a human-readable representation of the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:135
+  def inspect; end
+
+  # @attribute [Integer] the length of the body if known.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:40
+  def length; end
+
+  # Read a chunk of data.
+  #
+  # Follows the procedure outlined in https://tools.ietf.org/html/rfc7230#section-4.1.3
+  #
+  # @returns [String | Nil] the next chunk of data, or `nil` if the body is finished.
+  # @raises [EOFError] if the connection is closed before the expected length is read.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:75
+  def read; end
+
+  private
+
+  # Read the trailer from the connection, and add any headers to the trailer.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:151
+  def read_trailer; end
+end
+
+# The maximum amount of body data returned by a single read.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:19
+Protocol::HTTP1::Body::Chunked::BLOCK_SIZE = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:16
+Protocol::HTTP1::Body::Chunked::CRLF = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/body/chunked.rb:67
+Protocol::HTTP1::Body::Chunked::VALID_CHUNK_LENGTH = T.let(T.unsafe(nil), Regexp)
+
+# Represents a fixed length body.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:12
+class Protocol::HTTP1::Body::Fixed < ::Protocol::HTTP::Body::Readable
+  # Initialize the body with the given connection and length.
+  #
+  # @parameter connection [Protocol::HTTP1::Connection] the connection to read the body from.
+  # @parameter length [Integer] the length of the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:20
+  def initialize(connection, length); end
+
+  # @returns [Hash] JSON representation for tracing and debugging.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:84
+  def as_json(*, **, &); end
+
+  # Close the connection.
+  #
+  # @parameter error [Exception | Nil] the error that caused the connection to be closed, if any.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:41
+  def close(error = T.unsafe(nil)); end
+
+  # @returns [Boolean] true if the body is empty.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:34
+  def empty?; end
+
+  # @returns [String] a human-readable representation of the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:79
+  def inspect; end
+
+  # @attribute [Integer] the length of the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:28
+  def length; end
+
+  # Read a chunk of data.
+  #
+  # @returns [String | Nil] the next chunk of data.
+  # @raises [EOFError] if the connection is closed before the expected length is read.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:57
+  def read; end
+
+  # @attribute [Integer] the remaining bytes to read.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:31
+  def remaining; end
+end
+
+# The maximum amount of body data returned by a single read.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/body/fixed.rb:14
+Protocol::HTTP1::Body::Fixed::BLOCK_SIZE = T.let(T.unsafe(nil), Integer)
+
+# Represents the remainder of the body, which reads all the data from the connection until it is finished.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:12
+class Protocol::HTTP1::Body::Remainder < ::Protocol::HTTP::Body::Readable
+  # Initialize the body with the given connection.
+  #
+  # @parameter connection [Protocol::HTTP1::Connection] the connection to read the body from.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:18
+  def initialize(connection, block_size: T.unsafe(nil)); end
+
+  # @returns [Hash] JSON representation for tracing and debugging.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:67
+  def as_json(*, **, &); end
+
+  # Close the connection.
+  #
+  # @parameter error [Exception | Nil] the error that caused the connection to be closed, if any.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:41
+  def close(error = T.unsafe(nil)); end
+
+  # Discard the body, which will close the connection and prevent further reads.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:29
+  def discard; end
+
+  # @returns [Boolean] true if the body is empty.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:24
+  def empty?; end
+
+  # @returns [String] a human-readable representation of the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:62
+  def inspect; end
+
+  # Read a chunk of data.
+  #
+  # @returns [String | Nil] the next chunk of data.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:50
+  def read; end
+end
+
+# pkg:gem/protocol-http1#lib/protocol/http1/body/remainder.rb:13
+Protocol::HTTP1::Body::Remainder::BLOCK_SIZE = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:25
+Protocol::HTTP1::CHUNKED = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:28
+Protocol::HTTP1::CLOSE = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:27
+Protocol::HTTP1::CONNECTION = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:22
+Protocol::HTTP1::CONTENT_LENGTH = T.let(T.unsafe(nil), String)
+
+# Represents a single HTTP/1.x connection, which may be used to send and receive multiple requests and responses.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:52
+class Protocol::HTTP1::Connection
+  # Initialize the connection with the given stream.
+  #
+  # @parameter stream [IO] the stream to read and write data from.
+  # @parameter persistent [Boolean] whether the connection is persistent.
+  # @parameter state [Symbol] the initial state of the connection, typically idle.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:66
+  def initialize(stream, persistent: T.unsafe(nil), state: T.unsafe(nil), maximum_line_length: T.unsafe(nil)); end
+
+  # Close the connection and underlying stream and transition to the closed state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:227
+  def close(error = T.unsafe(nil)); end
+
+  # Transition to the closed state.
+  #
+  # If no error occurred, and the connection is persistent, this will immediately transition to the idle state.
+  #
+  # @parameter error [Exxception] the error that caused the connection to close.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:775
+  def close!(error = T.unsafe(nil)); end
+
+  # Close the read end of the connection and transition to the half-closed remote state (or closed if already in the half-closed local state).
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:218
+  def close_read; end
+
+  # The connection (stream) was closed. It may now be in the idle state.
+  #
+  # Sub-classes may override this method to perform additional cleanup.
+  #
+  # @parameter error [Exception | Nil] the error that caused the connection to be closed, if any.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:767
+  def closed(error = T.unsafe(nil)); end
+
+  # @return [Boolean] whether the connection is in the closed state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:145
+  def closed?; end
+
+  # @attribute [Integer] the number of requests and responses processed by this connection.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:150
+  def count; end
+
+  # Extract the content length from the headers, if possible.
+  #
+  # @parameter headers [Hash] the headers.
+  # @yields {|length| ...} if a content length is found.
+  # 	@parameter length [Integer] the content length.
+  # @raises [BadRequest] if the content length is invalid.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:910
+  def extract_content_length(headers); end
+
+  # @return [Boolean] whether the connection is in the half-closed local state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:135
+  def half_closed_local?; end
+
+  # @return [Boolean] whether the connection is in the half-closed remote state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:140
+  def half_closed_remote?; end
+
+  # Hijack the connection - that is, take over the underlying IO and close the connection.
+  #
+  # @returns [IO | Nil] the underlying non-blocking IO.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:203
+  def hijack!; end
+
+  # Indicates whether the connection has been hijacked meaning its IO has been handed over and is not usable anymore.
+  #
+  # @returns [Boolean] hijack status
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:196
+  def hijacked?; end
+
+  # @return [Boolean] whether the connection is in the idle state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:125
+  def idle?; end
+
+  # Indicates whether the status code is an interim status code.
+  #
+  # @parameter status [Integer] the status code.
+  # @returns [Boolean] whether the status code is an interim status code.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:485
+  def interim_status?(status); end
+
+  # Force a transition to the open state.
+  #
+  # @raises [ProtocolError] if the connection is not in the idle state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:244
+  def open!; end
+
+  # @return [Boolean] whether the connection is in the open state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:130
+  def open?; end
+
+  # @attribute [Boolean] true if the connection is persistent.
+  #
+  # This determines what connection headers are sent in the response and whether the connection can be reused after the response is sent. This setting is automatically managed according to the nature of the request and response. Changing to false is safe. Changing to true from outside this class should generally be avoided and, depending on the response semantics, may be reset to false anyway.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:83
+  def persistent; end
+
+  # @attribute [Boolean] true if the connection is persistent.
+  #
+  # This determines what connection headers are sent in the response and whether the connection can be reused after the response is sent. This setting is automatically managed according to the nature of the request and response. Changing to false is safe. Changing to true from outside this class should generally be avoided and, depending on the response semantics, may be reset to false anyway.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:83
+  def persistent=(_arg0); end
+
+  # Indicates whether the connection is persistent given the version, method, and headers.
+  #
+  # @parameter version [String] the HTTP version.
+  # @parameter method [String] the HTTP method.
+  # @parameter headers [Hash] the HTTP headers.
+  # @return [Boolean] whether the connection can be persistent.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:158
+  def persistent?(version, method, headers); end
+
+  # Read some data from the connection.
+  #
+  # @parameter length [Integer] the number of bytes to read.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:380
+  def read(length); end
+
+  # Read the body of the message.
+  #
+  # - The `transfer-encoding` header is used to determine if the body is chunked.
+  # - Otherwise, if the `content-length` is present, the body is read until the content length is reached.
+  # - Otherwise, if `remainder` is true, the body is read until the connection is closed.
+  #
+  # @parameter headers [Hash] the headers of the message.
+  # @parameter remainder [Boolean] whether to read the remainder of the body.
+  # @returns [Object] the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:1008
+  def read_body(headers, remainder = T.unsafe(nil)); end
+
+  # Read the body, assuming it is using the chunked transfer encoding.
+  #
+  # @parameters headers [Hash] the headers of the request.
+  # @returns [Protocol::HTTP1::Body::Chunked] the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:844
+  def read_chunked_body(headers); end
+
+  # Read the body, assuming it has a fixed length.
+  #
+  # @parameters length [Integer] the length of the body.
+  # @returns [Protocol::HTTP1::Body::Fixed] the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:852
+  def read_fixed_body(length); end
+
+  # Read the body, assuming that we are not receiving any actual data, but just the length.
+  #
+  # @parameters length [Integer] the length of the body.
+  # @returns [Protocol::HTTP::Body::Head] the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:868
+  def read_head_body(length); end
+
+  # Read headers from the connection until an empty line is encountered.
+  #
+  # @returns [HTTP::Headers] the headers read.
+  # @raises [EOFError] if the connection is closed.
+  # @raises [BadHeader] if a header could not be parsed.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:531
+  def read_headers; end
+
+  # Read a line from the connection.
+  #
+  # @raises [EOFError] if a line could not be read.
+  # @raises [LineLengthError] if the line is too long.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:414
+  def read_line; end
+
+  # Read a line from the connection.
+  #
+  # @returns [String | Nil] the line read, or nil if the connection is closed.
+  # @raises [LineLengthError] if the line is too long.
+  # @raises [ProtocolError] if the line is not terminated properly.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:391
+  def read_line?; end
+
+  # Read the body, assuming that we read until the connection is closed.
+  #
+  # @returns [Protocol::HTTP1::Body::Remainder] the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:859
+  def read_remainder_body; end
+
+  # Read a request from the connection, including the request line and request headers, and prepares to read the request body.
+  #
+  # Transitions to the open state.
+  #
+  # @yields {|host, method, path, version, headers, body| ...} if a block is given.
+  # @returns [Tuple(String, String, String, String, HTTP::Headers, Protocol::HTTP1::Body) | Nil] the host, method, path, version, headers, and body of the request, or `nil` if the connection is closed.
+  # @raises [ProtocolError] if the connection is not in the idle state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:440
+  def read_request; end
+
+  # Read the body of the request.
+  #
+  # - The `CONNECT` method is used to establish a tunnel, so the body is read until the connection is closed.
+  # - The `UPGRADE` method is used to upgrade the connection to a different protocol (typically WebSockets), so the body is read until the connection is closed.
+  # - Otherwise, the body is read according to {read_body}.
+  #
+  # @parameter method [String] the HTTP method.
+  # @parameter headers [Hash] the headers of the request.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:979
+  def read_request_body(method, headers); end
+
+  # Read a request line from the connection.
+  #
+  # @returns [Tuple(String, String, String) | Nil] the method, path, and version of the request, or nil if the connection is closed.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:421
+  def read_request_line; end
+
+  # Read a response from the connection.
+  #
+  # @parameter method [String] the HTTP method.
+  # @yields {|version, status, reason, headers, body| ...} if a block is given.
+  # @returns [Tuple(String, Integer, String, HTTP::Headers, Protocol::HTTP1::Body)] the version, status, reason, headers, and body of the response.
+  # @raises [ProtocolError] if the connection is not in the open or half-closed local state.
+  # @raises [EOFError] if the connection is closed.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:496
+  def read_response(method); end
+
+  # Read the body of the response.
+  #
+  # - The `HEAD` method is used to retrieve the headers of the response without the body, so {read_head_body} is invoked if there is a content length, otherwise nil is returned.
+  # - A 101 status code indicates that the connection will be upgraded, so {read_upgrade_body} is invoked.
+  # - Interim status codes (1xx), no content (204) and not modified (304) status codes do not have a body, so nil is returned.
+  # - The `CONNECT` method is used to establish a tunnel, so {read_tunnel_body} is invoked.
+  # - Otherwise, the body is read according to {read_body}.
+  #
+  # @parameter method [String] the HTTP method.
+  # @parameter status [Integer] the HTTP status code.
+  # @parameter headers [Hash] the headers of the response.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:931
+  def read_response_body(method, status, headers); end
+
+  # Read a response line from the connection.
+  #
+  # @returns [Tuple(String, Integer, String)] the version, status, and reason of the response.
+  # @raises [EOFError] if the connection is closed.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:473
+  def read_response_line; end
+
+  # Read the body, assuming it is a tunnel.
+  #
+  # Invokes {read_remainder_body}.
+  #
+  # @returns [Protocol::HTTP::Body::Remainder] the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:880
+  def read_tunnel_body; end
+
+  # Read the body, assuming it is an upgrade.
+  #
+  # Invokes {read_remainder_body}.
+  #
+  # @returns [Protocol::HTTP::Body::Remainder] the body.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:889
+  def read_upgrade_body; end
+
+  # Read some data from the connection.
+  #
+  # @parameter length [Integer] the maximum number of bytes to read.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:371
+  def readpartial(length); end
+
+  # Indicate that the end of the stream (body) has been received.
+  #
+  # This will transition to the half-closed remote state if the connection is open, or the closed state if the connection is half-closed local.
+  #
+  # @raises [ProtocolError] if the connection is not in the open or half-closed remote state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:830
+  def receive_end_stream!; end
+
+  # Transition to the half-closed local state, in other words, the connection is closed for writing.
+  #
+  # If the connection is already in the half-closed remote state, it will transition to the closed state.
+  #
+  # @raises [ProtocolError] if the connection is not in the open state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:553
+  def send_end_stream!; end
+
+  # The current state of the connection.
+  #
+  # ```
+  #                          ┌────────┐
+  #                          │        │
+  # ┌───────────────────────►│  idle  │
+  # │                        │        │
+  # │                        └───┬────┘
+  # │                            │
+  # │                            │ send request /
+  # │                            │ receive request
+  # │                            │
+  # │                            ▼
+  # │                        ┌────────┐
+  # │                recv ES │        │ send ES
+  # │           ┌────────────┤  open  ├────────────┐
+  # │           │            │        │            │
+  # │           ▼            └───┬────┘            ▼
+  # │      ┌──────────┐          │           ┌──────────┐
+  # │      │   half   │          │           │   half   │
+  # │      │  closed  │          │ send R /  │  closed  │
+  # │      │ (remote) │          │ recv R    │ (local)  │
+  # │      └────┬─────┘          │           └─────┬────┘
+  # │           │                │                 │
+  # │           │ send ES /      │       recv ES / │
+  # │           │ close          ▼           close │
+  # │           │            ┌────────┐            │
+  # │           └───────────►│        │◄───────────┘
+  # │                        │ closed │
+  # └────────────────────────┤        │
+  #         persistent       └────────┘
+  # ```
+  #
+  # - `ES`: the body was fully received or sent (end of stream).
+  # - `R`: the connection was closed unexpectedly (reset).
+  #
+  # State transition methods use a trailing "!".
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:122
+  def state; end
+
+  # The current state of the connection.
+  #
+  # ```
+  #                          ┌────────┐
+  #                          │        │
+  # ┌───────────────────────►│  idle  │
+  # │                        │        │
+  # │                        └───┬────┘
+  # │                            │
+  # │                            │ send request /
+  # │                            │ receive request
+  # │                            │
+  # │                            ▼
+  # │                        ┌────────┐
+  # │                recv ES │        │ send ES
+  # │           ┌────────────┤  open  ├────────────┐
+  # │           │            │        │            │
+  # │           ▼            └───┬────┘            ▼
+  # │      ┌──────────┐          │           ┌──────────┐
+  # │      │   half   │          │           │   half   │
+  # │      │  closed  │          │ send R /  │  closed  │
+  # │      │ (remote) │          │ recv R    │ (local)  │
+  # │      └────┬─────┘          │           └─────┬────┘
+  # │           │                │                 │
+  # │           │ send ES /      │       recv ES / │
+  # │           │ close          ▼           close │
+  # │           │            ┌────────┐            │
+  # │           └───────────►│        │◄───────────┘
+  # │                        │ closed │
+  # └────────────────────────┤        │
+  #         persistent       └────────┘
+  # ```
+  #
+  # - `ES`: the body was fully received or sent (end of stream).
+  # - `R`: the connection was closed unexpectedly (reset).
+  #
+  # State transition methods use a trailing "!".
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:122
+  def state=(_arg0); end
+
+  # The underlying IO stream.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:78
+  def stream; end
+
+  # Write a body to the connection.
+  #
+  # The behavior of this method is determined by the HTTP version, the body, and the request method. We try to choose the best approach possible, given the constraints, connection persistence, whether the length is known, etc.
+  #
+  # @parameter version [String] the HTTP version.
+  # @parameter body [Object] the body to write.
+  # @parameter head [Boolean] whether the request was a `HEAD` request.
+  # @parameter trailer [Hash | Nil] the trailers to write.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:794
+  def write_body(version, body, head = T.unsafe(nil), trailer = T.unsafe(nil)); end
+
+  # Write the body to the connection and close the connection.
+  #
+  # @parameter body [Object] the body to write.
+  # @parameter head [Boolean] whether the request was a `HEAD` request.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:735
+  def write_body_and_close(body, head); end
+
+  # Write a chunked body to the connection.
+  #
+  # If the request was a `HEAD` request, the body will be closed, and no data will be written.
+  #
+  # If trailers are given, they will be written after the body.
+  #
+  # @parameter body [Object] the body to write.
+  # @parameter head [Boolean] whether the request was a `HEAD` request.
+  # @parameter trailer [Hash | Nil] the trailers to write.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:693
+  def write_chunked_body(body, head, trailer = T.unsafe(nil)); end
+
+  # Write the appropriate header for connection persistence.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:179
+  def write_connection_header(version); end
+
+  # Write an empty body to the connection.
+  #
+  # If given, the body will be closed.
+  #
+  # @parameter body [Object | Nil] the body to write.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:631
+  def write_empty_body(body = T.unsafe(nil)); end
+
+  # Write a fixed length body to the connection.
+  #
+  # If the request was a `HEAD` request, the body will be closed, and no data will be written.
+  #
+  # @parameter body [Object] the body to write.
+  # @parameter length [Integer] the length of the body.
+  # @parameter head [Boolean] whether the request was a `HEAD` request.
+  # @raises [ContentLengthError] if the body length does not match the content length specified.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:648
+  def write_fixed_length_body(body, length, head); end
+
+  # Write a header to the connection, rejecting CR, LF, and NUL in its value.
+  #
+  # @parameter name [String] the header name.
+  # @parameter value [String] the header value.
+  # @raises [BadHeader] if the header name or value is invalid.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:340
+  def write_header(name, value); end
+
+  # Write headers to the connection.
+  #
+  # @parameter headers [Hash] the headers to write.
+  # @raises [BadHeader] if the header name or value is invalid.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:362
+  def write_headers(headers); end
+
+  # Write an interim response to the connection. It is expected you will eventually write the final response after this method.
+  #
+  # @parameter version [String] the HTTP version.
+  # @parameter status [Integer] the HTTP status code.
+  # @parameter headers [Hash] the HTTP headers.
+  # @parameter reason [String] the reason phrase, defaults to the standard reason phrase for the status code.
+  # @raises [ProtocolError] if the connection is not in the open or half-closed remote state.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:320
+  def write_interim_response(version, status, headers, reason = T.unsafe(nil)); end
+
+  # Write a request to the connection. It is expected you will write the body after this method.
+  #
+  # Transitions to the open state.
+  #
+  # Requires the method to be an HTTP token and rejects CR, LF, and NUL bytes in the authority and target before writing any request bytes.
+  #
+  # @parameter authority [String] the authority of the request.
+  # @parameter method [String] the HTTP method.
+  # @parameter target [String] the request target.
+  # @parameter version [String] the HTTP version.
+  # @parameter headers [Hash] the HTTP headers.
+  # @raises [RefusedError] if the request was not processed.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:266
+  def write_request(authority, method, target, version, headers); end
+
+  # Write a response to the connection. It is expected you will write the body after this method.
+  #
+  # @parameter version [String] the HTTP version.
+  # @parameter status [Integer] the HTTP status code.
+  # @parameter headers [Hash] the HTTP headers.
+  # @parameter reason [String] the reason phrase, defaults to the standard reason phrase for the status code.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:300
+  def write_response(version, status, headers, reason = T.unsafe(nil)); end
+
+  # Write a tunnel body to the connection.
+  #
+  # This writes the connection header and the body to the connection. If the body is `nil`, you should coordinate writing to the stream.
+  #
+  # The connection will not be persistent after this method is called.
+  #
+  # @parameter version [String] the HTTP version.
+  # @parameter body [Object | Nil] the body to write.
+  # @returns [IO] the underlying IO stream.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:604
+  def write_tunnel_body(version, body = T.unsafe(nil)); end
+
+  # Write an upgrade body to the connection.
+  #
+  # This writes the upgrade header and the body to the connection. If the body is `nil`, you should coordinate writing to the stream.
+  #
+  # The connection will not be persistent after this method is called.
+  #
+  # @parameter protocol [String] the protocol to upgrade to.
+  # @parameter body [Object | Nil] the body to write.
+  # @returns [IO] the underlying IO stream.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:572
+  def write_upgrade_body(protocol, body = T.unsafe(nil)); end
+
+  # Write the appropriate header for connection upgrade.
+  #
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:188
+  def write_upgrade_header(upgrade); end
+
+  private
+
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:1078
+  def close_write_stream; end
+
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:1072
+  def flush_stream; end
+
+  # pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:1066
+  def write_stream(data); end
+end
+
+# The HTTP `CONNECT` method.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:899
+Protocol::HTTP1::Connection::CONNECT = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:53
+Protocol::HTTP1::Connection::CRLF = T.let(T.unsafe(nil), String)
+
+# The HTTP `HEAD` method.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:896
+Protocol::HTTP1::Connection::HEAD = T.let(T.unsafe(nil), String)
+
+# The HTTP/1.0 version string.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:56
+Protocol::HTTP1::Connection::HTTP10 = T.let(T.unsafe(nil), String)
+
+# The HTTP/1.1 version string.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:59
+Protocol::HTTP1::Connection::HTTP11 = T.let(T.unsafe(nil), String)
+
+# The pattern for valid content length values.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:902
+Protocol::HTTP1::Connection::VALID_CONTENT_LENGTH = T.let(T.unsafe(nil), Regexp)
+
+# The specified content length and the given content's length do not match.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/error.rb:36
+class Protocol::HTTP1::ContentLengthError < ::Protocol::HTTP1::Error; end
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:49
+Protocol::HTTP1::DEFAULT_MAXIMUM_LINE_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# The base class for all HTTP/1.x errors.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/error.rb:11
+class Protocol::HTTP1::Error < ::Protocol::HTTP::Error; end
+
+# HTTP/1.x header parser:
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:40
+Protocol::HTTP1::FIELD_NAME = T.let(T.unsafe(nil), Regexp)
+
+# A field value is any string of characters that does not contain a null character, CR, or LF. After reflecting on the RFCs and surveying real implementations, I came to the conclusion that the RFCs are too restrictive. Most servers only check for the presence of null bytes, and obviously CR/LF characters have semantic meaning in the parser. So, I decided to follow this defacto standard, even if I'm not entirely happy with it.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:43
+Protocol::HTTP1::FIELD_VALUE = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:44
+Protocol::HTTP1::HEADER = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:31
+Protocol::HTTP1::HOST = T.let(T.unsafe(nil), String)
+
+# Indicates that the request is invalid for some reason, e.g. syntax error, invalid headers, etc.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/error.rb:32
+class Protocol::HTTP1::InvalidRequest < ::Protocol::HTTP1::BadRequest; end
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:29
+Protocol::HTTP1::KEEP_ALIVE = T.let(T.unsafe(nil), String)
+
+# The request line was too long.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/error.rb:19
+class Protocol::HTTP1::LineLengthError < ::Protocol::HTTP1::Error; end
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:41
+Protocol::HTTP1::OWS = T.let(T.unsafe(nil), Regexp)
+
+# The protocol was violated in some way, e.g. trying to write a request while reading a response.
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/error.rb:15
+class Protocol::HTTP1::ProtocolError < ::Protocol::HTTP1::Error; end
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:37
+Protocol::HTTP1::REQUEST_LINE = T.let(T.unsafe(nil), Regexp)
+
+# HTTP/1.x request line parser:
+#
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:35
+Protocol::HTTP1::TOKEN = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:24
+Protocol::HTTP1::TRANSFER_ENCODING = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:32
+Protocol::HTTP1::UPGRADE = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:46
+Protocol::HTTP1::VALID_FIELD_NAME = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:47
+Protocol::HTTP1::VALID_FIELD_VALUE = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/connection.rb:36
+Protocol::HTTP1::VALID_METHOD = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http1#lib/protocol/http1/version.rb:8
+Protocol::HTTP1::VERSION = T.let(T.unsafe(nil), String)