e621stream 0.0.0

data/sorbet/rbi/gems/protocol-http@0.72.1.rbi

@@ -0,0 +1,3801 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `protocol-http` gem.
+# Please instead update this file by running `bin/tapioca gem protocol-http`.
+
+
+# @namespace
+# Released under the MIT License.
+# Copyright, 2019-2024, by Samuel Williams.
+# Copyright, 2022, by Dan Olson.
+# Released under the MIT License.
+# Copyright, 2019-2026, by Samuel Williams.
+# Copyright, 2023, by Genki Takiuchi.
+# Copyright, 2025, by William T. Nelson.
+# Released under the MIT License.
+# Copyright, 2018-2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2019-2025, by Samuel Williams.
+# Copyright, 2024, by Earlopain.
+# Released under the MIT License.
+# Copyright, 2020-2025, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2019-2025, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2019-2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2024-2025, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2025-2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:8
+module Protocol; end
+
+# @namespace
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:9
+module Protocol::HTTP; end
+
+# Marks errors which may indicate a malformed or invalid request when raised while processing an incoming request.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:26
+module Protocol::HTTP::BadRequest; end
+
+# @namespace
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:10
+module Protocol::HTTP::Body; end
+
+# A body which buffers all its contents.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:14
+class Protocol::HTTP::Body::Buffered < ::Protocol::HTTP::Body::Readable
+  # Initialize the buffered body with some chunks.
+  #
+  # @parameter chunks [Array(String)] the chunks to buffer.
+  # @parameter length [Integer] the length of the body, if known.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:51
+  def initialize(chunks = T.unsafe(nil), length = T.unsafe(nil)); end
+
+  # A rewindable body wraps some other body. Convert it to a buffered body. The buffered body will share the same chunks as the rewindable body.
+  #
+  # @returns [Buffered] the buffered body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:64
+  def buffered; end
+
+  # @attribute [Array(String)] chunks the buffered chunks.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:59
+  def chunks; end
+
+  # Clear the buffered chunks.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:85
+  def clear; end
+
+  # Ensure that future reads return `nil`, but allow for rewinding.
+  #
+  # @parameter error [Exception | Nil] the error that caused the body to be closed, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:78
+  def close(error = T.unsafe(nil)); end
+
+  # Close the body for writing. This is a no-op.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:132
+  def close_write(error); end
+
+  # Discard the body. Invokes {#close}.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:121
+  def discard; end
+
+  # @returns [Boolean] if the body is empty.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:97
+  def empty?; end
+
+  # Finish the body, this is a no-op.
+  #
+  # @returns [Buffered] self.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:71
+  def finish; end
+
+  # Inspect the buffered body.
+  #
+  # @returns [String] a string representation of the buffered body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:155
+  def inspect; end
+
+  # The length of the body. Will compute and cache the length of the body, if it was not provided.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:92
+  def length; end
+
+  # Read the next chunk from the buffered body.
+  #
+  # @returns [String | Nil] the next chunk or nil if there are no more chunks.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:110
+  def read; end
+
+  # Whether the body is ready to be read.
+  # @returns [Boolean] a buffered response is always ready.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:103
+  def ready?; end
+
+  # Rewind the body to the beginning, causing a subsequent read to return the first chunk.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:144
+  def rewind; end
+
+  # Whether the body can be rewound.
+  #
+  # @returns [Boolean] if the body has chunks.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:139
+  def rewindable?; end
+
+  # Write a chunk to the buffered body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:127
+  def write(chunk); end
+
+  class << self
+    # Read the entire body into a buffered representation.
+    #
+    # @parameter body [Readable] the body to read.
+    # @returns [Buffered] the buffered body.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:37
+    def read(body); end
+
+    # Tries to wrap an object in a {Buffered} instance.
+    #
+    # For compatibility, also accepts anything that behaves like an `Array(String)`.
+    #
+    # @parameter body [String | Array(String) | Readable | nil] the body to wrap.
+    # @returns [Readable | nil] the wrapped body or nil if nil was given.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/body/buffered.rb:21
+    def wrap(object); end
+  end
+end
+
+# Invokes a callback once the body has completed, either successfully or due to an error.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:12
+class Protocol::HTTP::Body::Completable < ::Protocol::HTTP::Body::Wrapper
+  # Initialize the completable body with a callback.
+  #
+  # @parameter body [Readable] the body to wrap.
+  # @parameter callback [Proc] the callback to invoke when the body is closed.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:29
+  def initialize(body, callback); end
+
+  # Convert the body to a hash suitable for serialization.
+  #
+  # @returns [Hash] The body as a hash.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:60
+  def as_json(*, **, &); end
+
+  # Close the body and invoke the callback. If an error is given, it is passed to the callback.
+  #
+  # The calback is only invoked once, and before `super` is invoked.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:48
+  def close(error = T.unsafe(nil)); end
+
+  # Inspect the completable body.
+  #
+  # @returns [String] a string representation of the completable body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:69
+  def inspect; end
+
+  # Rewind the body, is not supported.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:41
+  def rewind; end
+
+  # @returns [Boolean] completable bodies are not rewindable.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:36
+  def rewindable?; end
+
+  class << self
+    # Wrap a message body with a callback. If the body is empty, the callback is invoked immediately.
+    #
+    # @parameter message [Request | Response] the message body.
+    # @parameter block [Proc] the callback to invoke when the body is closed.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/body/completable.rb:17
+    def wrap(message, &block); end
+  end
+end
+
+# Represents a body suitable for HEAD requests, in other words, a body that is empty and has a known length.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/head.rb:13
+class Protocol::HTTP::Body::Head < ::Protocol::HTTP::Body::Readable
+  # Initialize the head body with the given length.
+  #
+  # @parameter length [Integer] the length of the body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/head.rb:38
+  def initialize(length); end
+
+  # @returns [Boolean] the body is empty.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/head.rb:43
+  def empty?; end
+
+  # Inspect the head body.
+  #
+  # @returns [String] a string representation of the head body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/head.rb:60
+  def inspect; end
+
+  # @returns [Integer] the length of the body, if known.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/head.rb:53
+  def length; end
+
+  # @returns [Boolean] the body is ready.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/head.rb:48
+  def ready?; end
+
+  class << self
+    # Create a head body for the given body, capturing its length and then closing it.
+    #
+    # If a body is provided, the length is determined from the body, and the body is closed.
+    # If no body is provided, and the content length is provided, a head body is created with that length.
+    # This is useful for creating a head body when you only know the content length but not the actual body, which may happen in adapters for HTTP applications where the application may not provide a body for HEAD requests, but the content length is known.
+    #
+    # @parameter body [Readable | Nil] the body to create a head for.
+    # @parameter length [Integer | Nil] the content length of the body, if known.
+    # @returns [Head | Nil] the head body, or nil if the body is nil.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/body/head.rb:23
+    def for(body, length = T.unsafe(nil)); end
+  end
+end
+
+# Represents a readable input streams.
+#
+# There are two major modes of operation:
+#
+# 1. Reading chunks using {read} (or {each}/{join}), until the body is empty, or
+# 2. Streaming chunks using {call}, which writes chunks to a provided output stream.
+#
+# In both cases, reading can fail, for example if the body represents a streaming upload, and the connection is lost. In this case, {read} will raise some kind of error, or the stream will be closed with an error.
+#
+# At any point, you can use {close} to close the stream and release any resources, or {discard} to read all remaining data without processing it which may allow the underlying connection to be reused (but can be slower).
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:22
+class Protocol::HTTP::Body::Readable
+  # Convert the body to a hash suitable for serialization. This won't include the contents of the body, but will include metadata such as the length, streamability, and readiness, etc.
+  #
+  # @returns [Hash] The body as a hash.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:179
+  def as_json(*, **, &); end
+
+  # Return a buffered representation of this body.
+  #
+  # This method must return a buffered body if `#rewindable?`.
+  #
+  # @returns [Buffered | Nil] The buffered body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:73
+  def buffered; end
+
+  # Invoke the body with the given stream.
+  #
+  # The default implementation simply writes each chunk to the stream. If the body is not ready, it will be flushed after each chunk. Closes the stream when finished or if an error occurs.
+  #
+  # Write the body to the given stream.
+  #
+  # @parameter stream [IO | Object] An `IO`-like object that responds to `#read`, `#write` and `#flush`.
+  # @returns [Boolean] Whether the ownership of the stream was transferred.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:144
+  def call(stream); end
+
+  # Close the stream immediately. After invoking this method, the stream should be considered closed, and all internal resources should be released.
+  #
+  # Closing the stream before it reaches end-of-file abandons any remaining input. The protocol implementation must account for that unread data before the associated exchange or connection can be reused. Depending on the protocol, it may discard the remaining data, terminate the exchange, or make the connection non-reusable. Use {discard} when preserving the exchange or connection is preferred.
+  #
+  # When closing before end-of-file, omitting the error represents deliberate application-level abandonment, not a protocol failure.
+  #
+  # If an error occurred while handling the output, it can be passed as an argument. This may be propagated to the client, for example the client may be informed that the stream was not fully read correctly.
+  #
+  # Invoking {read} after {close} will return `nil`.
+  #
+  # @parameter error [Exception | Nil] The error that caused this stream to be closed, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:34
+  def close(error = T.unsafe(nil)); end
+
+  # Discard the body as efficiently as possible.
+  #
+  # The default implementation simply reads all chunks until the body is empty.
+  #
+  # Useful for discarding the body when it is not needed, but preserving the underlying connection.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:171
+  def discard; end
+
+  # Enumerate all chunks until finished, then invoke {close}.
+  #
+  # Closes the stream when finished or if an error occurs.
+  #
+  # @yields {|chunk| ...} The block to call with each chunk of data.
+  # 	@parameter chunk [String | Nil] The chunk of data, or `nil` if the stream has finished.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:98
+  def each; end
+
+  # Optimistically determine whether read (may) return any data.
+  #
+  # - If this returns true, then calling read will definitely return nil.
+  # - If this returns false, then calling read may return nil.
+  #
+  # @return [Boolean] Whether the stream is empty.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:43
+  def empty?; end
+
+  # Read all remaining chunks into a buffered body and close the underlying input.
+  #
+  # @returns [Buffered] The buffered body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:161
+  def finish; end
+
+  # Read all remaining chunks into a single binary string using `#each`.
+  #
+  # @returns [String | Nil] The binary string containing all chunks of data, or `nil` if the stream has finished (or did not contain any data).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:115
+  def join; end
+
+  # The total length of the body, if known.
+  #
+  # @returns [Integer | Nil] The total length of the body, or `nil` if the length is unknown.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:80
+  def length; end
+
+  # Read the next available chunk.
+  #
+  # @returns [String | Nil] The chunk of data, or `nil` if the stream has finished.
+  # @raises [StandardError] If an error occurs while reading.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:88
+  def read; end
+
+  # Whether calling read will return a chunk of data without blocking. We prefer pessimistic implementation, and thus default to `false`.
+  #
+  # @return [Boolean] Whether the stream is ready (read will not block).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:50
+  def ready?; end
+
+  # Rewind the stream to the beginning.
+  #
+  # @returns [Boolean] Whether the stream was successfully rewound.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:64
+  def rewind; end
+
+  # Whether the stream can be rewound using {rewind}.
+  #
+  # @return [Boolean] Whether the stream is rewindable.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:57
+  def rewindable?; end
+
+  # Whether to prefer streaming the body using {call} rather than reading it using {read} or {each}.
+  #
+  # @returns [Boolean] Whether the body should be streamed.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:132
+  def stream?; end
+
+  # Return an IO-compatible stream for reading this body.
+  # @returns [Stream] The IO-compatible stream adapter.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:198
+  def to_io; end
+
+  # Convert the body to JSON.
+  #
+  # @returns [String] The body as JSON.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/readable.rb:192
+  def to_json(*, **, &); end
+end
+
+# General operations for interacting with a request or response body.
+#
+# This module is included in both {Request} and {Response}.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:13
+module Protocol::HTTP::Body::Reader
+  # Whether there is a body?
+  #
+  # @returns [Boolean] whether there is a body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:98
+  def body?; end
+
+  # Buffer the entire request/response body.
+  #
+  # @returns [Reader] itself.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:61
+  def buffered!; end
+
+  # Close the connection as quickly as possible. Discards body. May close the underlying connection if necessary to terminate the stream.
+  #
+  # @parameter error [Exception | Nil] the error that caused the stream to be closed, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:88
+  def close(error = T.unsafe(nil)); end
+
+  # Discard the body as efficiently as possible.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:49
+  def discard; end
+
+  # Read chunks from the body.
+  #
+  # @yields {|chunk| ...} chunks from the body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:17
+  def each(&block); end
+
+  # Gracefully finish reading the body. This will buffer the remainder of the body.
+  #
+  # @returns [Buffered] buffers the entire body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:39
+  def finish; end
+
+  # Reads the entire request/response body.
+  #
+  # @returns [String] the entire body as a string.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:27
+  def read; end
+
+  # Write the body of the response to the given file path.
+  #
+  # @parameter path [String] the path to write the body to.
+  # @parameter mode [Integer] the mode to open the file with.
+  # @parameter options [Hash] additional options to pass to `File.open`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/reader.rb:75
+  def save(path, mode = T.unsafe(nil), **options); end
+end
+
+# The input stream is an IO-like object which contains the raw HTTP POST data. When applicable, its external encoding must be "ASCII-8BIT" and it must be opened in binary mode, for Ruby 1.9 compatibility. The input stream must respond to gets, each, read and rewind.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:12
+class Protocol::HTTP::Body::Stream
+  include ::Protocol::HTTP::Body::Stream::Reader
+
+  # Initialize the stream with the given input and output.
+  #
+  # @parameter input [Readable | Nil] The input stream.
+  # @parameter output [Writable | Nil] The output stream.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:20
+  def initialize(input = T.unsafe(nil), output = T.unsafe(nil)); end
+
+  # Write data to the stream using {write}.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:324
+  def <<(buffer); end
+
+  # Close the input and output bodies.
+  #
+  # Closing without an error represents orderly completion or abandonment of both application-facing directions, not cancellation. If the peer has not completed the exchange, the protocol implementation may need to terminate it without reporting an application error.
+  #
+  # Repeated calls are safe; each underlying direction will be closed at most once.
+  #
+  # @parameter error [Exception | Nil] The error that caused this stream to be closed, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:395
+  def close(error = T.unsafe(nil)); end
+
+  # Close the application-facing input body. This does not close the output body, which may continue to be written independently.
+  #
+  # If the input has not reached end-of-file, any remaining data is abandoned. The protocol implementation must ensure that unread data cannot interfere with subsequent exchanges. Depending on the protocol, it may discard the remaining data, terminate the current exchange, or make the connection non-reusable.
+  #
+  # Closing without an error represents orderly application-level abandonment, not a protocol failure.
+  #
+  # This method is idempotent. After the first call, subsequent calls have no effect.
+  #
+  # If, while processing the data that was read from this stream, an error is encountered, it should be passed to this method.
+  #
+  # @parameter error [Exception | Nil] The error that was encountered, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:361
+  def close_read(error = T.unsafe(nil)); end
+
+  # Close the application-facing output body. This does not close the input body, which may continue to be read independently.
+  #
+  # Closing without an error indicates that no more output will be produced. Previously written data remains part of the output and should be followed by a normal end-of-stream from the protocol implementation. If an error is provided, the protocol implementation may terminate the exchange instead.
+  #
+  # This method is idempotent. After the first call, subsequent calls have no effect.
+  #
+  # If, while generating the data that is written to this stream, an error is encountered, it should be passed to this method.
+  #
+  # @parameter error [Exception | Nil] The error that was encountered, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:380
+  def close_write(error = T.unsafe(nil)); end
+
+  # @returns [Boolean] Whether the stream has been closed.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:405
+  def closed?; end
+
+  # @returns [Boolean] Whether there are any output chunks remaining.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:425
+  def empty?; end
+
+  # Flush the output stream.
+  #
+  # This is currently a no-op.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:347
+  def flush; end
+
+  # @attribute [Readable | Nil] The input stream.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:36
+  def input; end
+
+  # Inspect the stream.
+  #
+  # @returns [String] a string representation of the stream.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:412
+  def inspect; end
+
+  # @attribute [Writable | Nil] The output stream.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:39
+  def output; end
+
+  # Write lines to the stream.
+  #
+  # The current implementation buffers the lines and writes them in a single operation.
+  #
+  # @parameter arguments [Array(String)] The lines to write.
+  # @parameter separator [String] The line separator, defaults to `\n`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:334
+  def puts(*arguments, separator: T.unsafe(nil)); end
+
+  # Write data to the underlying stream.
+  #
+  # @parameter buffer [String] The data to write.
+  # @raises [IOError] If the stream is not writable.
+  # @returns [Integer] The number of bytes written.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:303
+  def write(buffer); end
+
+  # Write data to the stream using {write}.
+  #
+  # Provided for compatibility with IO-like objects.
+  #
+  # @parameter buffer [String] The data to write.
+  # @parameter exception [Boolean] Whether to raise an exception if the write would block, currently ignored.
+  # @returns [Integer] The number of bytes written.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:319
+  def write_nonblock(buffer, exception: T.unsafe(nil)); end
+
+  private
+
+  # Read the next chunk of data from the input stream.
+  #
+  # @returns [String] The next chunk of data.
+  # @raises [IOError] If the input stream was explicitly closed.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:439
+  def read_next; end
+end
+
+# The default line separator, used by {gets}.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:14
+Protocol::HTTP::Body::Stream::NEWLINE = T.let(T.unsafe(nil), String)
+
+# This provides a read-only interface for data, which is surprisingly tricky to implement correctly.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:42
+module Protocol::HTTP::Body::Stream::Reader
+  # Iterate over each chunk of data from the input stream.
+  #
+  # @yields {|chunk| ...} Each chunk of data.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:149
+  def each(&block); end
+
+  # Read a single line from the stream.
+  #
+  # @parameter separator [String] The line separator, defaults to `\n`.
+  # @parameter limit [Integer] The maximum number of bytes to read.
+  # @parameter *options [Hash] Additional options, passed to {read_until}.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:232
+  def gets(separator = T.unsafe(nil), limit = T.unsafe(nil), chomp: T.unsafe(nil)); end
+
+  # Read data from the underlying stream.
+  #
+  # If given a non-negative length, it will read at most that many bytes from the stream. If the stream is at EOF, it will return nil.
+  #
+  # If the length is not given, it will read all data until EOF, or return an empty string if the stream is already at EOF.
+  #
+  # If buffer is given, then the read data will be placed into buffer instead of a newly created String object.
+  #
+  # @parameter length [Integer] the amount of data to read
+  # @parameter buffer [String] the buffer which will receive the data
+  # @returns [String] a buffer containing the data
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:54
+  def read(length = T.unsafe(nil), buffer = T.unsafe(nil)); end
+
+  # Read data from the stream without blocking if possible.
+  #
+  # @parameter length [Integer] The maximum number of bytes to read.
+  # @parameter buffer [String | Nil] The buffer to read into.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:166
+  def read_nonblock(length, buffer = T.unsafe(nil), exception: T.unsafe(nil)); end
+
+  # Read some bytes from the stream.
+  #
+  # If the length is given, at most length bytes will be read. Otherwise, one chunk of data from the underlying stream will be read.
+  #
+  # Will avoid reading from the underlying stream if there is buffered data available.
+  #
+  # @parameter length [Integer] The maximum number of bytes to read.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:104
+  def read_partial(length = T.unsafe(nil), buffer = T.unsafe(nil)); end
+
+  # 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 chomp [Boolean] Whether to remove the pattern from the returned data.
+  # @returns [String] The contents of the stream up until the pattern, which is consumed but not returned.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:198
+  def read_until(pattern, offset = T.unsafe(nil), chomp: T.unsafe(nil)); end
+
+  # Similar to {read_partial} but raises an `EOFError` if the stream is at EOF.
+  #
+  # @parameter length [Integer] The maximum number of bytes to read.
+  # @parameter buffer [String] The buffer to read into.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/stream.rb:142
+  def readpartial(length, buffer = T.unsafe(nil)); end
+end
+
+# Wrapping body instance. Typically you'd override `#read`.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:12
+class Protocol::HTTP::Body::Wrapper < ::Protocol::HTTP::Body::Readable
+  # Initialize the wrapper with the given body.
+  #
+  # @parameter body [Readable] The body to wrap.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:26
+  def initialize(body); end
+
+  # Convert the body to a hash suitable for serialization.
+  #
+  # @returns [Hash] The body as a hash.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:86
+  def as_json(*, **, &); end
+
+  # @attribute [Readable] The wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:31
+  def body; end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:54
+  def buffered; end
+
+  # Close the body.
+  #
+  # @parameter error [Exception | Nil] The error that caused this stream to be closed, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:36
+  def close(error = T.unsafe(nil)); end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:79
+  def discard; end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:44
+  def empty?; end
+
+  # Inspect the wrapped body. The wrapper, by default, is transparent.
+  #
+  # @returns [String] a string representation of the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:103
+  def inspect; end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:69
+  def length; end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:74
+  def read; end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:49
+  def ready?; end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:59
+  def rewind; end
+
+  # Forwards to the wrapped body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:64
+  def rewindable?; end
+
+  # Convert the body to JSON.
+  #
+  # @returns [String] The body as JSON.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:96
+  def to_json(*, **, &); end
+
+  class << self
+    # Wrap the body of the given message in a new instance of this class.
+    #
+    # @parameter message [Request | Response] the message to wrap.
+    # @returns [Wrapper | Nil] the wrapped body or `nil`` if the body was `nil`.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/body/wrapper.rb:17
+    def wrap(message); end
+  end
+end
+
+# A dynamic body which you can write to and read from.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:12
+class Protocol::HTTP::Body::Writable < ::Protocol::HTTP::Body::Readable
+  # Initialize the writable body.
+  #
+  # @parameter length [Integer] The length of the response body if known.
+  # @parameter queue [Thread::Queue] Specify a different queue implementation, e.g. `Thread::SizedQueue` to enable back-pressure.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:21
+  def initialize(length = T.unsafe(nil), queue: T.unsafe(nil)); end
+
+  # Stop generating output; cause the next call to write to fail with the given error. Does not prevent existing chunks from being read. In other words, this indicates both that no more data will be or should be written to the body.
+  #
+  # @parameter error [Exception] The error that caused this body to be closed, if any. Will be raised on the next call to {read}.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:37
+  def close(error = T.unsafe(nil)); end
+
+  # Signal that no more data will be written to the body.
+  #
+  # @parameter error [Exception] The error that caused this body to be closed, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:101
+  def close_write(error = T.unsafe(nil)); end
+
+  # Whether the body is closed. A closed body can not be written to or read from.
+  #
+  # @returns [Boolean] Whether the body is closed.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:49
+  def closed?; end
+
+  # @attribute [Integer] The number of chunks written to the body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:32
+  def count; end
+
+  # Indicates whether the body is empty. This can occur if the body has been closed, or if the producer has invoked {close_write} and the reader has consumed all available chunks.
+  #
+  # @returns [Boolean] Whether the body is empty.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:61
+  def empty?; end
+
+  # Inspect the body.
+  #
+  # @returns [String] A string representation of the body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:170
+  def inspect; end
+
+  # @attribute [Integer] The length of the response body if known.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:29
+  def length; end
+
+  # Create an output wrapper which can be used to write chunks to the body.
+  #
+  # If a block is given, and the block raises an error, the error will used to close the body by invoking {close} with the error.
+  #
+  # @yields {|output| ...} if a block is given.
+  # 	@parameter output [Output] The output wrapper.
+  # @returns [Output] The output wrapper.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:151
+  def output; end
+
+  # Read the next available chunk.
+  #
+  # @returns [String | Nil] The next chunk, or `nil` if the body is finished.
+  # @raises [Exception] If the body was closed due to an error.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:69
+  def read; end
+
+  # @returns [Boolean] Whether the body is ready to be read from, without blocking.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:54
+  def ready?; end
+
+  # Write a single chunk to the body. Signal completion by calling {close_write}.
+  #
+  # @parameter chunk [String] The chunk to write.
+  # @raises [Closed] If the body has been closed without error.
+  # @raises [Exception] If the body has been closed due to an error.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:89
+  def write(chunk); end
+
+  private
+
+  # @returns [String] A string representation of the body's status.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:181
+  def status; end
+end
+
+# An error indicating that the body has been closed and no further writes are allowed.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:14
+class Protocol::HTTP::Body::Writable::Closed < ::StandardError; end
+
+# The output interface for writing chunks to the body.
+#
+# pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:107
+class Protocol::HTTP::Body::Writable::Output
+  # Initialize the output with the given writable body.
+  #
+  # @parameter writable [Writable] The writable body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:111
+  def initialize(writable); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:126
+  def <<(chunk); end
+
+  # Close the output stream.
+  #
+  # If an error is given, the error will be used to close the body by invoking {close} with the error. Otherwise, only the write side of the body will be closed.
+  #
+  # @parameter error [Exception | Nil] The error that caused this stream to be closed, if any.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:133
+  def close(error = T.unsafe(nil)); end
+
+  # @returns [Boolean] Whether the output is closed for writing only.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:117
+  def closed?; end
+
+  # Write a chunk to the body.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/body/writable.rb:122
+  def write(chunk); end
+end
+
+# Represents an individual cookie key-value pair.
+#
+# pkg:gem/protocol-http#lib/protocol/http/cookie.rb:12
+class Protocol::HTTP::Cookie
+  # Initialize the cookie with the given name, value, and directives.
+  #
+  # @parameter name [String] The name of the cookie, e.g. "session_id".
+  # @parameter value [String] The value of the cookie, e.g. "1234".
+  # @parameter directives [Hash] The directives of the cookie, e.g. `{"path" => "/"}`.
+  # @raises [ArgumentError] If the name or value contains invalid characters.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:29
+  def initialize(name, value, directives = T.unsafe(nil)); end
+
+  # @attribute [Hash] The directives of the cookie.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:50
+  def directives; end
+
+  # @attribute [Hash] The directives of the cookie.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:50
+  def directives=(_arg0); end
+
+  # @attribute [String] The name of the cookie.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:44
+  def name; end
+
+  # @attribute [String] The name of the cookie.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:44
+  def name=(_arg0); end
+
+  # Convert the cookie to a string.
+  #
+  # @returns [String] The string representation of the cookie.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:55
+  def to_s; end
+
+  # @attribute [String] The value of the cookie.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:47
+  def value; end
+
+  # @attribute [String] The value of the cookie.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:47
+  def value=(_arg0); end
+
+  class << self
+    # Parse a string into a cookie.
+    #
+    # @parameter string [String] The string to parse.
+    # @returns [Cookie] The parsed cookie.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:78
+    def parse(string); end
+
+    # Parse a list of strings into a hash of directives.
+    #
+    # @parameter strings [Array(String)] The list of strings to parse.
+    # @returns [Hash] The hash of directives.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/cookie.rb:91
+    def parse_directives(strings); end
+  end
+end
+
+# Valid cookie name characters according to RFC 6265.
+# cookie-name = token (RFC 2616 defines token)
+#
+# pkg:gem/protocol-http#lib/protocol/http/cookie.rb:15
+Protocol::HTTP::Cookie::VALID_COOKIE_KEY = T.let(T.unsafe(nil), Regexp)
+
+# Valid cookie value characters according to RFC 6265.
+# cookie-value = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
+# cookie-octet = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
+# Excludes control chars, whitespace, DQUOTE, comma, semicolon, and backslash
+#
+# pkg:gem/protocol-http#lib/protocol/http/cookie.rb:21
+Protocol::HTTP::Cookie::VALID_COOKIE_VALUE = T.let(T.unsafe(nil), Regexp)
+
+# Raised when a singleton (e.g. `content-length`) header is duplicated in a request or response.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:35
+class Protocol::HTTP::DuplicateHeaderError < ::Protocol::HTTP::InvalidHeaderError
+  # @parameter key [String] The header key that was duplicated.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/error.rb:37
+  def initialize(key, existing_value, new_value); end
+
+  # Provides a detailed error message including the existing and new values.
+  # @parameter highlight [Boolean] Whether to highlight the message (not currently used).
+  # @return [String] The detailed error message.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/error.rb:57
+  def detailed_message(highlight: T.unsafe(nil)); end
+
+  # @attribute [String] existing_value The existing value for the duplicated header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/error.rb:49
+  def existing_value; end
+
+  # @attribute [String] key The header key that was duplicated.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/error.rb:46
+  def key; end
+
+  # @attribute [String] new_value The new value for the duplicated header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/error.rb:52
+  def new_value; end
+end
+
+# A generic, HTTP protocol error.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:9
+class Protocol::HTTP::Error < ::StandardError; end
+
+# @namespace
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/split.rb:8
+module Protocol::HTTP::Header; end
+
+# The `accept-content-type` header represents a list of content-types that the client can accept.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:15
+class Protocol::HTTP::Header::Accept < ::Protocol::HTTP::Header::Split
+  # Adds one or more comma-separated values to the header.
+  #
+  # The input string is split into distinct entries and appended to the array.
+  #
+  # @parameter value [String] a raw header value containing one or more media types separated by commas.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:84
+  def <<(value); end
+
+  # Parse the `accept` header.
+  #
+  # @returns [Array(Charset)] the list of content types and their associated parameters.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:104
+  def media_ranges; end
+
+  # Parse the `accept` header and order media ranges by preference.
+  #
+  # Media ranges with equal quality factors retain their original relative order.
+  #
+  # @returns [Array(MediaRange)] the preferred media ranges.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:115
+  def preferred_media_ranges; end
+
+  # The string representation of the media range, including the type, subtype, and any parameters.
+  # Converts the parsed header value into a raw header value.
+  #
+  # @returns [String] a raw header value (comma-separated string).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:91
+  def to_s; end
+
+  private
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:121
+  def parse_media_range(value); end
+
+  class << self
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value containing comma-separated media types.
+    # @returns [Accept] a new instance containing the parsed media types.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:75
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # @returns [Boolean] `false`, as Accept headers are used for response content negotiation.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:97
+    def trailer?; end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:28
+Protocol::HTTP::Header::Accept::MEDIA_RANGE = T.let(T.unsafe(nil), Regexp)
+
+# A single entry in the Accept: header, which includes a mime type and associated parameters. A media range can include wild cards, but a media type is a specific type and subtype.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+class Protocol::HTTP::Header::Accept::MediaRange < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:39
+  def initialize(type, subtype = T.unsafe(nil), parameters = T.unsafe(nil)); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:44
+  def <=>(other); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+  def parameters; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+  def parameters=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:66
+  def quality_factor; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+  def subtype; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+  def subtype=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:57
+  def to_s; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:61
+  def to_str; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+  def type; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+  def type=(_); end
+
+  private
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:48
+  def parameters_string; end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:33
+    def new(*_arg0); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:30
+Protocol::HTTP::Header::Accept::PARAMETER = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:26
+class Protocol::HTTP::Header::Accept::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# Regular expression used to split values on commas, with optional surrounding whitespace, taking into account quoted strings.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept.rb:17
+Protocol::HTTP::Header::Accept::SEPARATOR = T.let(T.unsafe(nil), Regexp)
+
+# The `accept-charset` header represents a list of character sets that the client can accept.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:14
+class Protocol::HTTP::Header::AcceptCharset < ::Protocol::HTTP::Header::Split
+  # Parse the `accept-charset` header value into a list of character sets.
+  #
+  # @returns [Array(Charset)] the list of character sets and their associated quality factors.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:41
+  def charsets; end
+
+  # Parse the `accept-charset` header and order character sets by preference.
+  #
+  # Character sets with equal quality factors retain their original relative order.
+  #
+  # @returns [Array(Charset)] the preferred character sets.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:56
+  def preferred_charsets; end
+end
+
+# https://tools.ietf.org/html/rfc7231#section-5.3.3
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:18
+Protocol::HTTP::Header::AcceptCharset::CHARSET = T.let(T.unsafe(nil), Regexp)
+
+# A parsed character set entry with an optional quality factor.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+class Protocol::HTTP::Header::AcceptCharset::Charset < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:33
+  def <=>(other); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+  def name; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+  def name=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+  def q; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+  def q=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:25
+  def quality_factor; end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:21
+    def new(*_arg0); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_charset.rb:15
+class Protocol::HTTP::Header::AcceptCharset::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# The `accept-encoding` header represents a list of encodings that the client can accept.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:14
+class Protocol::HTTP::Header::AcceptEncoding < ::Protocol::HTTP::Header::Split
+  # Parse the `accept-encoding` header value into a list of encodings.
+  #
+  # @returns [Array(Charset)] the list of character sets and their associated quality factors.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:44
+  def encodings; end
+
+  # Parse the `accept-encoding` header and order encodings by preference.
+  #
+  # Encodings with equal quality factors retain their original relative order.
+  #
+  # @returns [Array(Encoding)] the preferred encodings.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:59
+  def preferred_encodings; end
+end
+
+# https://tools.ietf.org/html/rfc7231#section-5.3.4
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:21
+Protocol::HTTP::Header::AcceptEncoding::ENCODING = T.let(T.unsafe(nil), Regexp)
+
+# A parsed content encoding entry with an optional quality factor.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+class Protocol::HTTP::Header::AcceptEncoding::Encoding < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:36
+  def <=>(other); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+  def name; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+  def name=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+  def q; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+  def q=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:28
+  def quality_factor; end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:24
+    def new(*_arg0); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:15
+class Protocol::HTTP::Header::AcceptEncoding::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# https://tools.ietf.org/html/rfc7231#section-5.3.1
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_encoding.rb:18
+Protocol::HTTP::Header::AcceptEncoding::QVALUE = T.let(T.unsafe(nil), Regexp)
+
+# The `accept-language` header represents a list of languages that the client can accept.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:14
+class Protocol::HTTP::Header::AcceptLanguage < ::Protocol::HTTP::Header::Split
+  # Parse the `accept-language` header value into a list of languages.
+  #
+  # @returns [Array(Charset)] the list of character sets and their associated quality factors.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:47
+  def languages; end
+
+  # Parse the `accept-language` header and order languages by preference.
+  #
+  # Languages with equal quality factors retain their original relative order.
+  #
+  # @returns [Array(Language)] the preferred languages.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:62
+  def preferred_languages; end
+end
+
+# https://greenbytes.de/tech/webdav/rfc7231.html#quality.values
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:24
+Protocol::HTTP::Header::AcceptLanguage::LANGUAGE = T.let(T.unsafe(nil), Regexp)
+
+# A parsed language entry with an optional quality factor.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+class Protocol::HTTP::Header::AcceptLanguage::Language < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:39
+  def <=>(other); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+  def name; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+  def name=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+  def q; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+  def q=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:31
+  def quality_factor; end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:27
+    def new(*_arg0); end
+  end
+end
+
+# https://tools.ietf.org/html/rfc3066#section-2.1
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:18
+Protocol::HTTP::Header::AcceptLanguage::NAME = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:15
+class Protocol::HTTP::Header::AcceptLanguage::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.9
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/accept_language.rb:21
+Protocol::HTTP::Header::AcceptLanguage::QVALUE = T.let(T.unsafe(nil), Regexp)
+
+# Used for basic authorization.
+#
+# ~~~ ruby
+# headers.add('authorization', Authorization.basic("my_username", "my_password"))
+# ~~~
+#
+# TODO Support other authorization mechanisms, e.g. bearer token.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/authorization.rb:17
+class Protocol::HTTP::Header::Authorization < ::String
+  # Splits the header into the credentials.
+  #
+  # @returns [Tuple(String, String)] The username and password.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/authorization.rb:37
+  def credentials; end
+
+  class << self
+    # Generate a new basic authorization header, encoding the given username and password.
+    #
+    # @parameter username [String] The username.
+    # @parameter password [String] The password.
+    # @returns [Authorization] The basic authorization header.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/authorization.rb:46
+    def basic(username, password); end
+
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String] the value to coerce.
+    # @returns [Authorization] a parsed header object.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/authorization.rb:30
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value.
+    # @returns [Authorization] a new instance.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/authorization.rb:22
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # @returns [Boolean] `false`, as authorization headers are used for request authentication.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/authorization.rb:56
+    def trailer?; end
+  end
+end
+
+# Represents the `cache-control` header, which is a list of cache directives.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:13
+class Protocol::HTTP::Header::CacheControl < ::Protocol::HTTP::Header::Split
+  # Adds a directive to the `cache-control` header. The value will be normalized to lowercase before being added.
+  #
+  # @parameter value [String] a raw header value containing directives to add.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:71
+  def <<(value); end
+
+  # @returns [Boolean] whether the `dynamic` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:81
+  def dynamic?; end
+
+  # @returns [Integer | Nil] the value of the `max-age` directive in seconds, or `nil` if the directive is not present or invalid.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:121
+  def max_age; end
+
+  # @returns [Boolean] whether the `must-revalidate` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:111
+  def must_revalidate?; end
+
+  # @returns [Boolean] whether the `no-cache` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:101
+  def no_cache?; end
+
+  # @returns [Boolean] whether the `no-store` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:106
+  def no_store?; end
+
+  # @returns [Boolean] whether the `private` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:91
+  def private?; end
+
+  # @returns [Boolean] whether the `proxy-revalidate` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:116
+  def proxy_revalidate?; end
+
+  # @returns [Boolean] whether the `public` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:96
+  def public?; end
+
+  # @returns [Integer | Nil] the value of the `s-maxage` directive in seconds, or `nil` if the directive is not present or invalid.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:126
+  def s_maxage; end
+
+  # @returns [Boolean] whether the `static` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:76
+  def static?; end
+
+  # @returns [Boolean] whether the `streaming` directive is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:86
+  def streaming?; end
+
+  private
+
+  # Finds and parses an integer value from a directive.
+  #
+  # @parameter value_name [String] the directive name to search for (e.g., "max-age").
+  # @returns [Integer | Nil] the parsed integer value, or `nil` if not found or invalid.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:136
+  def find_integer_value(value_name); end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [CacheControl] a parsed header object with normalized values.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:59
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value containing comma-separated directives.
+    # @returns [CacheControl] a new instance containing the parsed and normalized directives.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:51
+    def parse(value); end
+  end
+end
+
+# The `dynamic` directive is a custom directive used to indicate that the resource is generated dynamically and may change frequently, requiring shorter caching periods.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:36
+Protocol::HTTP::Header::CacheControl::DYNAMIC = T.let(T.unsafe(nil), String)
+
+# The `max-age` directive indicates the maximum amount of time, in seconds, that a response is considered fresh.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:27
+Protocol::HTTP::Header::CacheControl::MAX_AGE = T.let(T.unsafe(nil), String)
+
+# The `must-revalidate` directive indicates that once a response becomes stale, caches must not use it to satisfy subsequent requests without revalidating it with the origin server.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:42
+Protocol::HTTP::Header::CacheControl::MUST_REVALIDATE = T.let(T.unsafe(nil), String)
+
+# The `no-cache` directive indicates that caches must revalidate the response with the origin server before serving it to clients.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:21
+Protocol::HTTP::Header::CacheControl::NO_CACHE = T.let(T.unsafe(nil), String)
+
+# The `no-store` directive indicates that caches must not store the response under any circumstances.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:24
+Protocol::HTTP::Header::CacheControl::NO_STORE = T.let(T.unsafe(nil), String)
+
+# The `private` directive indicates that the response is intended for a single user and must not be stored by shared caches.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:15
+Protocol::HTTP::Header::CacheControl::PRIVATE = T.let(T.unsafe(nil), String)
+
+# The `proxy-revalidate` directive is similar to `must-revalidate` but applies only to shared caches.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:45
+Protocol::HTTP::Header::CacheControl::PROXY_REVALIDATE = T.let(T.unsafe(nil), String)
+
+# The `public` directive indicates that the response may be stored by any cache, even if it would normally be considered non-cacheable.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:18
+Protocol::HTTP::Header::CacheControl::PUBLIC = T.let(T.unsafe(nil), String)
+
+# The `static` directive is a custom directive often used to indicate that the resource is immutable or rarely changes, allowing longer caching periods.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:33
+Protocol::HTTP::Header::CacheControl::STATIC = T.let(T.unsafe(nil), String)
+
+# The `streaming` directive is a custom directive used to indicate that the resource is intended for progressive or chunked delivery, such as live video streams.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:39
+Protocol::HTTP::Header::CacheControl::STREAMING = T.let(T.unsafe(nil), String)
+
+# The `s-maxage` directive is similar to `max-age` but applies only to shared caches. If both `s-maxage` and `max-age` are present, `s-maxage` takes precedence in shared caches.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cache_control.rb:30
+Protocol::HTTP::Header::CacheControl::S_MAXAGE = T.let(T.unsafe(nil), String)
+
+# Represents the `connection` HTTP header, which controls options for the current connection.
+#
+# The `connection` header is used to specify control options such as whether the connection should be kept alive, closed, or upgraded to a different protocol.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:15
+class Protocol::HTTP::Header::Connection < ::Protocol::HTTP::Header::Split
+  # Adds a directive to the `connection` header. The value will be normalized to lowercase before being added.
+  #
+  # @parameter value [String] a raw header value containing directives to add.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:49
+  def <<(value); end
+
+  # @returns [Boolean] whether the `close` directive is present, indicating that the connection should be closed after the current request and response.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:59
+  def close?; end
+
+  # @returns [Boolean] whether the `keep-alive` directive is present and the connection is not marked for closure with the `close` directive.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:54
+  def keep_alive?; end
+
+  # @returns [Boolean] whether the `upgrade` directive is present, indicating that the connection should be upgraded to a different protocol.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:64
+  def upgrade?; end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [Connection] a parsed header object with normalized values.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:37
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value containing comma-separated directives.
+    # @returns [Connection] a new instance with normalized (lowercase) directives.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:29
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # Connection headers control the current connection and must not appear in trailers.
+    # @returns [Boolean] `false`, as connection headers are hop-by-hop and forbidden in trailers.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:71
+    def trailer?; end
+  end
+end
+
+# The `close` directive indicates that the connection should be closed after the current request and response are complete.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:20
+Protocol::HTTP::Header::Connection::CLOSE = T.let(T.unsafe(nil), String)
+
+# The `keep-alive` directive indicates that the connection should remain open for future requests or responses, avoiding the overhead of opening a new connection.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:17
+Protocol::HTTP::Header::Connection::KEEP_ALIVE = T.let(T.unsafe(nil), String)
+
+# The `upgrade` directive indicates that the connection should be upgraded to a different protocol, as specified in the `Upgrade` header.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/connection.rb:23
+Protocol::HTTP::Header::Connection::UPGRADE = T.let(T.unsafe(nil), String)
+
+# The `cookie` header contains stored HTTP cookies previously sent by the server with the `set-cookie` header.
+#
+# It is used by clients to send key-value pairs representing stored cookies back to the server.
+# Multiple cookies within a single `Cookie` header are joined with `"; "` per RFC 6265.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/cookie.rb:16
+class Protocol::HTTP::Header::Cookie < ::Array
+  # Initializes the cookie header with the given values.
+  #
+  # @parameter value [Array | Nil] an array of cookie strings, or `nil` for an empty header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cookie.rb:41
+  def initialize(value = T.unsafe(nil)); end
+
+  # Parses the `cookie` header into a hash of cookie names and their corresponding cookie objects.
+  #
+  # @returns [Hash(String, HTTP::Cookie)] a hash where keys are cookie names and values are {HTTP::Cookie} objects.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cookie.rb:52
+  def to_h; end
+
+  # Serializes the `cookie` header by joining individual cookie strings with `"; "` per RFC 6265.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/cookie.rb:64
+  def to_s; end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [Cookie] a parsed header object.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/cookie.rb:29
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a single raw header value.
+    # @returns [Cookie] a new instance containing the parsed value.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/cookie.rb:21
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # Cookie headers should not appear in trailers as they contain state information needed early in processing.
+    # @returns [Boolean] `false`, as cookie headers are needed during initial request processing.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/cookie.rb:71
+    def trailer?; end
+  end
+end
+
+# The `date` header represents the date and time at which the message was originated.
+#
+# This header is typically included in HTTP responses and follows the format defined in RFC 9110.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/date.rb:14
+class Protocol::HTTP::Header::Date < ::String
+  # Replaces the current value of the `date` header.
+  #
+  # @parameter value [String] a raw header value for the `date` header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/date.rb:34
+  def <<(value); end
+
+  # Converts the `date` header value to a `Time` object.
+  #
+  # @returns [Time] the parsed time object corresponding to the `date` header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/date.rb:41
+  def to_time; end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String] the value to coerce.
+    # @returns [Date] a parsed header object.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/date.rb:27
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value.
+    # @returns [Date] a new instance.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/date.rb:19
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # Date headers can safely appear in trailers as they provide metadata about response generation.
+    # @returns [Boolean] `true`, as date headers are metadata that can be computed after response generation.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/date.rb:48
+    def trailer?; end
+  end
+end
+
+# The `digest` header provides a digest of the message body for integrity verification.
+#
+# This header allows servers to send cryptographic hashes of the response body, enabling clients to verify data integrity. Multiple digest algorithms can be specified, and the header is particularly useful as a trailer since the digest can only be computed after the entire message body is available.
+#
+# ## Examples
+#
+# ```ruby
+# digest = Digest.new("sha-256=X48E9qOokqqrvdts8nOJRJN3OWDUoyWxBf7kbu9DBPE=")
+# digest << "md5=9bb58f26192e4ba00f01e2e7b136bbd8"
+# puts digest.to_s
+# # => "sha-256=X48E9qOokqqrvdts8nOJRJN3OWDUoyWxBf7kbu9DBPE=, md5=9bb58f26192e4ba00f01e2e7b136bbd8"
+# ```
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:25
+class Protocol::HTTP::Header::Digest < ::Protocol::HTTP::Header::Split
+  # Parse the `digest` header value into a list of digest entries.
+  #
+  # @returns [Array(Entry)] the list of digest entries with their algorithms and values.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:52
+  def entries; end
+
+  class << self
+    # Whether this header is acceptable in HTTP trailers.
+    # @returns [Boolean] `true`, as digest headers contain integrity hashes that can only be calculated after the entire message body is available.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:64
+    def trailer?; end
+  end
+end
+
+# https://tools.ietf.org/html/rfc3230#section-4.3.2
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:29
+Protocol::HTTP::Header::Digest::ENTRY = T.let(T.unsafe(nil), Regexp)
+
+# A single digest entry in the Digest header.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+class Protocol::HTTP::Header::Digest::Entry < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:37
+  def initialize(algorithm, value); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+  def algorithm; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+  def algorithm=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:44
+  def to_s; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+  def value; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+  def value=(_); end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:32
+    def new(*_arg0); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/digest.rb:26
+class Protocol::HTTP::Header::Digest::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# The `etag` header represents the entity tag for a resource.
+#
+# The `etag` header provides a unique identifier for a specific version of a resource, typically used for cache validation or conditional requests. It can be either a strong or weak validator as defined in RFC 9110.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/etag.rb:12
+class Protocol::HTTP::Header::ETag < ::String
+  # Replaces the current value of the `etag` header.
+  #
+  # @parameter value [String] a raw header value for the `etag` header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etag.rb:32
+  def <<(value); end
+
+  # Checks whether the `etag` is a weak validator.
+  #
+  # Weak validators indicate semantically equivalent content but may not be byte-for-byte identical.
+  #
+  # @returns [Boolean] whether the `etag` is weak.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etag.rb:41
+  def weak?; end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String] the value to coerce.
+    # @returns [ETag] a parsed header object.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/etag.rb:25
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value.
+    # @returns [ETag] a new instance.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/etag.rb:17
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # ETag headers can safely appear in trailers as they provide cache validation metadata.
+    # @returns [Boolean] `true`, as ETag headers are metadata that can be computed after response generation.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/etag.rb:48
+    def trailer?; end
+  end
+end
+
+# The `etags` header represents a list of entity tags (ETags) for resources.
+#
+# The `etags` header is used for conditional requests to compare the current version of a resource with previously stored versions. It supports both strong and weak validators, as well as the wildcard character (`*`) to indicate a match for any resource.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/etags.rb:15
+class Protocol::HTTP::Header::ETags < ::Protocol::HTTP::Header::Split
+  # Checks if the specified ETag matches the `etags` header.
+  #
+  # This method returns `true` if the wildcard is present or if the exact ETag is found in the list. Note that this implementation is not strictly compliant with the RFC-specified format.
+  #
+  # @parameter etag [String] the ETag to compare against the `etags` header.
+  # @returns [Boolean] whether the specified ETag matches.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etags.rb:31
+  def match?(etag); end
+
+  # Checks for a strong match with the specified ETag, useful with the `if-match` header.
+  #
+  # A strong match requires that the ETag in the header list matches the specified ETag and that neither is a weak validator.
+  #
+  # @parameter etag [String] the ETag to compare against the `etags` header.
+  # @returns [Boolean] whether a strong match is found.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etags.rb:41
+  def strong_match?(etag); end
+
+  # Checks for a weak match with the specified ETag, useful with the `if-none-match` header.
+  #
+  # A weak match allows for semantically equivalent content, including weak validators and their strong counterparts.
+  #
+  # @parameter etag [String] the ETag to compare against the `etags` header.
+  # @returns [Boolean] whether a weak match is found.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etags.rb:51
+  def weak_match?(etag); end
+
+  # Checks if the `etags` header contains the wildcard (`*`) character.
+  #
+  # The wildcard character matches any resource version, regardless of its actual value.
+  #
+  # @returns [Boolean] whether the wildcard is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etags.rb:21
+  def wildcard?; end
+
+  private
+
+  # Converts a weak tag to its strong counterpart or vice versa.
+  #
+  # @parameter etag [String] the ETag to convert.
+  # @returns [String] the opposite form of the provided ETag.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etags.rb:61
+  def opposite_tag(etag); end
+
+  # Checks if the given ETag is a weak validator.
+  #
+  # @parameter tag [String] the ETag to check.
+  # @returns [Boolean] whether the tag is weak.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/etags.rb:69
+  def weak_tag?(tag); end
+end
+
+# Represents generic or custom headers that can be used in trailers.
+#
+# This class is used as the default policy for headers not explicitly defined in the POLICY hash.
+#
+# It allows generic headers to be used in HTTP trailers, which is important for:
+# - Custom application headers.
+# - gRPC status headers (grpc-status, grpc-message).
+# - Headers used by proxies and middleware.
+# - Future HTTP extensions.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/generic.rb:20
+class Protocol::HTTP::Header::Generic < ::Protocol::HTTP::Header::Split
+  class << self
+    # Whether this header is acceptable in HTTP trailers.
+    # Generic headers are allowed in trailers by default to support extensibility.
+    # @returns [Boolean] `true`, generic headers are allowed in trailers.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/generic.rb:24
+    def trailer?; end
+  end
+end
+
+# Represents headers that can contain multiple distinct values separated by newline characters.
+#
+# This isn't a specific header but is used as a base for headers that store multiple values, such as cookies. The values are split and stored as an array internally, and serialized back to a newline-separated string when needed.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/multiple.rb:12
+class Protocol::HTTP::Header::Multiple < ::Array
+  # Initializes the multiple header with the given values.
+  #
+  # @parameter value [Array | Nil] an array of header values, or `nil` for an empty header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/multiple.rb:41
+  def initialize(value = T.unsafe(nil)); end
+
+  # Converts the parsed header value into a raw header value.
+  #
+  # Multiple headers are transmitted as separate header entries, so this serializes to a newline-separated string for storage.
+  #
+  # @returns [String] a raw header value (newline-separated string).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/multiple.rb:54
+  def to_s; end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # This method is used by the Headers class when setting values via `[]=` to convert application values into the appropriate policy type.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [Multiple] a parsed header object.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/multiple.rb:29
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # Multiple headers receive each value as a separate header entry, so this method takes a single string value and creates a new instance containing it.
+    #
+    # @parameter value [String] a single raw header value.
+    # @returns [Multiple] a new instance containing the parsed value.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/multiple.rb:19
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # This is a base class for headers with multiple values, default is to disallow in trailers.
+    # @returns [Boolean] `false`, as most multiple-value headers should not appear in trailers by default.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/multiple.rb:61
+    def trailer?; end
+  end
+end
+
+# Represents the `priority` header, used to indicate the relative importance of an HTTP request.
+#
+# The `priority` header allows clients to express their preference for how resources should be prioritized by the server. It supports directives like `u=` to specify the urgency level of a request, and `i` to indicate whether a response can be delivered incrementally. The urgency levels range from 0 (highest priority) to 7 (lowest priority), while the `i` directive is a boolean flag.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/priority.rb:14
+class Protocol::HTTP::Header::Priority < ::Protocol::HTTP::Header::Split
+  # Add a value to the priority header.
+  #
+  # @parameter value [String] a raw header value containing directives to add to the header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/priority.rb:39
+  def <<(value); end
+
+  # Checks if the response should be delivered incrementally.
+  #
+  # The `i` directive, when present, indicates that the response can be delivered incrementally as data becomes available.
+  #
+  # @returns [Boolean] whether the request should be delivered incrementally.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/priority.rb:65
+  def incremental?; end
+
+  # The urgency level, if specified using `u=`. 0 is the highest priority, and 7 is the lowest.
+  #
+  # Note that when duplicate Dictionary keys are encountered, all but the last instance are ignored.
+  #
+  # @returns [Integer | Nil] the urgency level if specified, or `nil` if not present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/priority.rb:51
+  def urgency(default = T.unsafe(nil)); end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [Priority] a parsed header object with normalized values.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/priority.rb:27
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value containing comma-separated directives.
+    # @returns [Priority] a new instance with normalized (lowercase) directives.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/priority.rb:19
+    def parse(value); end
+  end
+end
+
+# The default urgency level if not specified.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/priority.rb:44
+Protocol::HTTP::Header::Priority::DEFAULT_URGENCY = T.let(T.unsafe(nil), Integer)
+
+# Represents a `range` request header.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:12
+class Protocol::HTTP::Header::Range
+  # Initialize a range header.
+  # @parameter unit [String] The range unit.
+  # @parameter ranges [Array] The range specifiers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:106
+  def initialize(unit, ranges); end
+
+  # Combine another raw range header value with this one.
+  # @parameter value [String] The raw range header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:139
+  def <<(value); end
+
+  # Whether this header contains byte ranges.
+  # @returns [Boolean] Whether the range unit is `bytes`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:119
+  def bytes?; end
+
+  # @attribute [Array] The range specifiers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:115
+  def ranges; end
+
+  # Resolve this byte range against the selected representation size.
+  # @parameter size [Integer] The size of the selected representation.
+  # @returns [::Range | Nil] The resolved range, or `nil` when it is unsatisfiable.
+  # Resolve all byte ranges against the selected representation size.
+  # @parameter size [Integer] The size of the selected representation.
+  # @returns [Array(::Range)] The satisfiable byte ranges.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:126
+  def resolve(size); end
+
+  # Convert this byte range to its wire representation.
+  # @returns [String] The serialized byte range.
+  # Convert this header to its wire representation.
+  # @returns [String] The serialized range header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:153
+  def to_s; end
+
+  # @attribute [String] The range unit.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:112
+  def unit; end
+
+  class << self
+    # Coerce a value into a range header.
+    # @parameter value [Object] The value to coerce.
+    # @returns [Range] The parsed range header.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:99
+    def coerce(value); end
+
+    # Parse a raw range header value.
+    # @parameter value [String] The raw header value.
+    # @returns [Range] The parsed range header.
+    # Parse one byte range.
+    # @parameter value [String] The byte range to parse.
+    # @returns [ByteRange] The parsed byte range.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:75
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # @returns [Boolean] `false`, as range headers apply to a selected representation.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:159
+    def trailer?; end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:17
+Protocol::HTTP::Header::Range::BYTE_RANGE = T.let(T.unsafe(nil), Regexp)
+
+# Represents one byte-range-spec or suffix-byte-range-spec.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+class Protocol::HTTP::Header::Range::ByteRange < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+  def first; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+  def first=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+  def last; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+  def last=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:49
+  def resolve(size); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:63
+  def to_s; end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:22
+    def new(*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/range.rb:26
+    def parse(value); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:16
+Protocol::HTTP::Header::Range::HEADER = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:18
+Protocol::HTTP::Header::Range::OTHER_RANGE = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:13
+class Protocol::HTTP::Header::Range::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:19
+Protocol::HTTP::Header::Range::SEPARATOR = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http#lib/protocol/http/header/range.rb:15
+Protocol::HTTP::Header::Range::TOKEN = T.let(T.unsafe(nil), Regexp)
+
+# The `server-timing` header communicates performance metrics about the request-response cycle to the client.
+#
+# This header allows servers to send timing information about various server-side operations, which can be useful for performance monitoring and debugging. Each metric can include a name, optional duration, and optional description.
+#
+# ## Examples
+#
+# ```ruby
+# server_timing = ServerTiming.new("db;dur=53.2")
+# server_timing << "cache;dur=12.1;desc=\"Redis lookup\""
+# puts server_timing.to_s
+# # => "db;dur=53.2, cache;dur=12.1;desc=\"Redis lookup\""
+# ```
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:25
+class Protocol::HTTP::Header::ServerTiming < ::Protocol::HTTP::Header::Split
+  # Parse the `server-timing` header value into a list of metrics.
+  #
+  # @returns [Array(Metric)] the list of metrics with their names, durations, and descriptions.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:57
+  def metrics; end
+
+  class << self
+    # Whether this header is acceptable in HTTP trailers.
+    # @returns [Boolean] `true`, as server-timing headers contain performance metrics that are typically calculated during response generation.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:86
+    def trailer?; end
+  end
+end
+
+# https://www.w3.org/TR/server-timing/
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:29
+Protocol::HTTP::Header::ServerTiming::METRIC = T.let(T.unsafe(nil), Regexp)
+
+# A single metric in the Server-Timing header.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+class Protocol::HTTP::Header::ServerTiming::Metric < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:39
+  def initialize(name, duration = T.unsafe(nil), description = T.unsafe(nil)); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+  def description; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+  def description=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+  def duration; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+  def duration=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+  def name; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+  def name=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:46
+  def to_s; end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:33
+    def new(*_arg0); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:30
+Protocol::HTTP::Header::ServerTiming::PARAMETER = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/protocol-http#lib/protocol/http/header/server_timing.rb:26
+class Protocol::HTTP::Header::ServerTiming::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# The `set-cookie` header sends cookies from the server to the user agent.
+#
+# Each `Set-Cookie` header must be a separate header field — they cannot be combined.
+# It is used to store cookies on the client side, which are then sent back to the server
+# in subsequent requests using the `cookie` header.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/set_cookie.rb:18
+class Protocol::HTTP::Header::SetCookie < ::Protocol::HTTP::Header::Multiple
+  # Parses the `set-cookie` headers into a hash of cookie names and their corresponding cookie objects.
+  #
+  # @returns [Hash(String, HTTP::Cookie)] a hash where keys are cookie names and values are {HTTP::Cookie} objects.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/set_cookie.rb:22
+  def to_h; end
+
+  class << self
+    # Whether this header is acceptable in HTTP trailers.
+    # @returns [Boolean] `false`, as set-cookie headers are needed during initial response processing.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/set_cookie.rb:32
+    def trailer?; end
+  end
+end
+
+# Represents headers that can contain multiple distinct values separated by commas.
+#
+# This isn't a specific header  class is a utility for handling headers with comma-separated values, such as `accept`, `cache-control`, and other similar headers. The values are split and stored as an array internally, and serialized back to a comma-separated string when needed.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/split.rb:12
+class Protocol::HTTP::Header::Split < ::Array
+  # Initializes a `Split` header with the given values.
+  #
+  # @parameter value [Array | String | Nil] an array of values, a raw header value, or `nil` for an empty header.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:44
+  def initialize(value = T.unsafe(nil)); end
+
+  # Adds one or more comma-separated values to the header.
+  #
+  # The input string is split into distinct entries and appended to the array.
+  #
+  # @parameter value [String] a raw header value containing one or more values separated by commas.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:61
+  def <<(value); end
+
+  # Converts the parsed header value into a raw header value.
+  #
+  # @returns [String] a raw header value (comma-separated string).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:68
+  def to_s; end
+
+  protected
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:89
+  def reverse_find(&block); end
+
+  # Order weighted values by descending quality while preserving their relative order.
+  # @parameter values [Enumerable] The values which respond to `#quality_factor`.
+  # @returns [Array] The ordered values.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:83
+  def sort_by_quality_factor(values); end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # This method is used by the Headers class when setting values via `[]=` to convert application values into the appropriate policy type.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [Split] a parsed header object.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:32
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # Split headers receive comma-separated values in a single header entry. This method splits the raw value into individual entries.
+    #
+    # @parameter value [String] a raw header value containing multiple entries separated by commas.
+    # @returns [Split] a new instance containing the parsed values.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:22
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # This is a base class for comma-separated headers, default is to disallow in trailers.
+    # @returns [Boolean] `false`, as most comma-separated headers should not appear in trailers by default.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/split.rb:75
+    def trailer?; end
+  end
+end
+
+# Regular expression used to split values on commas, with optional surrounding whitespace.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/split.rb:14
+Protocol::HTTP::Header::Split::COMMA = T.let(T.unsafe(nil), Regexp)
+
+# The `te` header indicates the transfer encodings the client is willing to accept. AKA `accept-transfer-encoding`. How we ended up with `te` instead of `accept-transfer-encoding` is a mystery lost to time.
+#
+# The `te` header allows a client to indicate which transfer encodings it can handle, and in what order of preference using quality factors.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:16
+class Protocol::HTTP::Header::TE < ::Protocol::HTTP::Header::Split
+  # Adds one or more comma-separated values to the TE header. The values are converted to lowercase for normalization.
+  #
+  # @parameter value [String] a raw header value containing one or more values separated by commas.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:99
+  def <<(value); end
+
+  # @returns [Boolean] whether the `chunked` encoding is accepted.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:126
+  def chunked?; end
+
+  # @returns [Boolean] whether the `compress` encoding is accepted.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:141
+  def compress?; end
+
+  # @returns [Boolean] whether the `deflate` encoding is accepted.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:136
+  def deflate?; end
+
+  # @returns [Boolean] whether the `gzip` encoding is accepted.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:131
+  def gzip?; end
+
+  # @returns [Boolean] whether the `identity` encoding is accepted.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:146
+  def identity?; end
+
+  # Parse the `te` header and order transfer codings by preference.
+  #
+  # Transfer codings with equal quality factors retain their original relative order.
+  #
+  # @returns [Array(TransferCoding)] the preferred transfer codings.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:121
+  def preferred_transfer_codings; end
+
+  # @returns [Boolean] whether trailers are accepted.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:151
+  def trailers?; end
+
+  # Parse the `te` header value into a list of transfer codings with quality factors.
+  #
+  # @returns [Array(TransferCoding)] the list of transfer codings and their associated quality factors.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:106
+  def transfer_codings; end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [TE] a parsed header object with normalized values.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:87
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value containing comma-separated encodings.
+    # @returns [TE] a new instance with normalized (lowercase) encodings.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:79
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # TE headers negotiate transfer encodings and must not appear in trailers.
+    # @returns [Boolean] `false`, as TE headers are hop-by-hop and control message framing.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:158
+    def trailer?; end
+  end
+end
+
+# The `chunked` transfer encoding
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:29
+Protocol::HTTP::Header::TE::CHUNKED = T.let(T.unsafe(nil), String)
+
+# The `compress` transfer encoding
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:38
+Protocol::HTTP::Header::TE::COMPRESS = T.let(T.unsafe(nil), String)
+
+# The `deflate` transfer encoding
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:35
+Protocol::HTTP::Header::TE::DEFLATE = T.let(T.unsafe(nil), String)
+
+# The `gzip` transfer encoding
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:32
+Protocol::HTTP::Header::TE::GZIP = T.let(T.unsafe(nil), String)
+
+# The `identity` transfer encoding
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:41
+Protocol::HTTP::Header::TE::IDENTITY = T.let(T.unsafe(nil), String)
+
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:17
+class Protocol::HTTP::Header::TE::ParseError < ::Protocol::HTTP::InvalidHeaderError; end
+
+# Quality value pattern (0.0 to 1.0)
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:23
+Protocol::HTTP::Header::TE::QVALUE = T.let(T.unsafe(nil), Regexp)
+
+# Transfer encoding token pattern
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:20
+Protocol::HTTP::Header::TE::TOKEN = T.let(T.unsafe(nil), Regexp)
+
+# The `trailers` pseudo-encoding indicates willingness to accept trailer fields
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:44
+Protocol::HTTP::Header::TE::TRAILERS = T.let(T.unsafe(nil), String)
+
+# Pattern for parsing transfer encoding with optional quality factor
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:26
+Protocol::HTTP::Header::TE::TRANSFER_CODING = T.let(T.unsafe(nil), Regexp)
+
+# A single transfer coding entry with optional quality factor
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+class Protocol::HTTP::Header::TE::TransferCoding < ::Struct
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:59
+  def <=>(other); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+  def name; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+  def name=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+  def q; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+  def q=(_); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:51
+  def quality_factor; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:66
+  def to_s; end
+
+  class << self
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+    def [](*_arg0); end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+    def inspect; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+    def keyword_init?; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+    def members; end
+
+    # pkg:gem/protocol-http#lib/protocol/http/header/te.rb:47
+    def new(*_arg0); end
+  end
+end
+
+# Represents headers that can contain multiple distinct values separated by commas.
+#
+# This isn't a specific header  class is a utility for handling headers with comma-separated values, such as `accept`, `cache-control`, and other similar headers. The values are split and stored as an array internally, and serialized back to a comma-separated string when needed.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/trailer.rb:14
+class Protocol::HTTP::Header::Trailer < ::Protocol::HTTP::Header::Split
+  class << self
+    # Whether this header is acceptable in HTTP trailers.
+    # @returns [Boolean] `false`, as Trailer headers control trailer processing and must appear before the message body.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/trailer.rb:17
+    def trailer?; end
+  end
+end
+
+# The `transfer-encoding` header indicates the encoding transformations that have been applied to the message body.
+#
+# The `transfer-encoding` header is used to specify the form of encoding used to safely transfer the message body between the sender and receiver.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:14
+class Protocol::HTTP::Header::TransferEncoding < ::Protocol::HTTP::Header::Split
+  # Adds one or more comma-separated values to the transfer encoding header. The values are converted to lowercase for normalization.
+  #
+  # @parameter value [String] a raw header value containing one or more values separated by commas.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:54
+  def <<(value); end
+
+  # @returns [Boolean] whether the `chunked` encoding is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:59
+  def chunked?; end
+
+  # @returns [Boolean] whether the `compress` encoding is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:74
+  def compress?; end
+
+  # @returns [Boolean] whether the `deflate` encoding is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:69
+  def deflate?; end
+
+  # @returns [Boolean] whether the `gzip` encoding is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:64
+  def gzip?; end
+
+  # @returns [Boolean] whether the `identity` encoding is present.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:79
+  def identity?; end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [TransferEncoding] a parsed header object with normalized values.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:42
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value containing comma-separated encodings.
+    # @returns [TransferEncoding] a new instance with normalized (lowercase) encodings.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:34
+    def parse(value); end
+
+    # Whether this header is acceptable in HTTP trailers.
+    # Transfer-Encoding headers control message framing and must not appear in trailers.
+    # @returns [Boolean] `false`, as Transfer-Encoding headers are hop-by-hop and must precede the message body.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:86
+    def trailer?; end
+  end
+end
+
+# The `chunked` transfer encoding allows a server to send data of unknown length by breaking it into chunks.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:16
+Protocol::HTTP::Header::TransferEncoding::CHUNKED = T.let(T.unsafe(nil), String)
+
+# The `compress` transfer encoding compresses the message body using the compress algorithm.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:25
+Protocol::HTTP::Header::TransferEncoding::COMPRESS = T.let(T.unsafe(nil), String)
+
+# The `deflate` transfer encoding compresses the message body using the deflate algorithm.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:22
+Protocol::HTTP::Header::TransferEncoding::DEFLATE = T.let(T.unsafe(nil), String)
+
+# The `gzip` transfer encoding compresses the message body using the gzip algorithm.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:19
+Protocol::HTTP::Header::TransferEncoding::GZIP = T.let(T.unsafe(nil), String)
+
+# The `identity` transfer encoding indicates no transformation has been applied.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/transfer_encoding.rb:28
+Protocol::HTTP::Header::TransferEncoding::IDENTITY = T.let(T.unsafe(nil), String)
+
+# Represents the `vary` header, which specifies the request headers a server considers when determining the response.
+#
+# The `vary` header is used in HTTP responses to indicate which request headers affect the selected response. It allows caches to differentiate stored responses based on specific request headers.
+#
+# pkg:gem/protocol-http#lib/protocol/http/header/vary.rb:14
+class Protocol::HTTP::Header::Vary < ::Protocol::HTTP::Header::Split
+  # Adds one or more comma-separated values to the `vary` header. The values are converted to lowercase for normalization.
+  #
+  # @parameter value [String] a raw header value containing one or more values separated by commas.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/header/vary.rb:39
+  def <<(value); end
+
+  class << self
+    # Coerces a value into a parsed header object.
+    #
+    # @parameter value [String | Array] the value to coerce.
+    # @returns [Vary] a parsed header object with normalized values.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/vary.rb:27
+    def coerce(value); end
+
+    # Parses a raw header value.
+    #
+    # @parameter value [String] a raw header value containing comma-separated header names.
+    # @returns [Vary] a new instance with normalized (lowercase) header names.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/header/vary.rb:19
+    def parse(value); end
+  end
+end
+
+# Headers are an array of key-value pairs. Some header keys represent multiple values.
+#
+# pkg:gem/protocol-http#lib/protocol/http/headers.rb:42
+class Protocol::HTTP::Headers
+  # Initialize the headers with the specified fields.
+  #
+  # @parameter fields [Array] An array of `[key, value]` pairs.
+  # @parameter tail [Integer | Nil] The index of the trailer start in the @fields array.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:77
+  def initialize(fields = T.unsafe(nil), tail = T.unsafe(nil), indexed: T.unsafe(nil), policy: T.unsafe(nil)); end
+
+  # Compare this object to another object. May depend on the order of the fields.
+  #
+  # @returns [Boolean] Whether the other object is equal to this one.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:504
+  def ==(other); end
+
+  # Get the value of the specified header key.
+  #
+  # @parameter key [String] The header key.
+  # @returns [String | Array | Object] The header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:319
+  def [](key); end
+
+  # Set the specified header key to the specified value, replacing any existing values.
+  #
+  # The value can be a String or a coercable value.
+  #
+  # @parameter key [String] the header key.
+  # @parameter value [String | Array] the header value to assign.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:287
+  def []=(key, value); end
+
+  # Add the specified header key value pair.
+  #
+  # @parameter key [String] the header key.
+  # @parameter value [String] the header value to assign.
+  # @parameter trailer [Boolean] whether this header is being added as a trailer.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:254
+  def add(key, value, trailer: T.unsafe(nil)); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:492
+  def as_json; end
+
+  # Clear all headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:113
+  def clear; end
+
+  # Delete all header values for the given key, and return the merged value.
+  #
+  # @parameter key [String] The header key.
+  # @returns [String | Array | Object] The merged header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:422
+  def delete(key); end
+
+  # Enumerate all header keys and values.
+  #
+  # @yields {|key, value| ...}
+  # 	@parameter key [String] The header key.
+  # 	@parameter value [String] The raw header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:216
+  def each(&block); end
+
+  # @returns [Boolean] Whether the headers are empty.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:207
+  def empty?; end
+
+  # Extract the specified keys from the headers.
+  #
+  # @parameter keys [Array] The keys to extract.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:235
+  def extract(keys); end
+
+  # @attribute [Array] An array of `[key, value]` pairs.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:135
+  def fields; end
+
+  # Flatten trailer into the headers, returning a new instance of {Headers}.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:130
+  def flatten; end
+
+  # Flatten trailer into the headers, in-place.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:120
+  def flatten!; end
+
+  # Freeze the headers, and ensure the indexed hash is generated.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:194
+  def freeze; end
+
+  # Enumerate all the headers in the header, if there are any.
+  #
+  # @yields {|key, value| ...} The header key and value.
+  # 	@parameter key [String] The header key.
+  # 	@parameter value [String] The raw header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:170
+  def header(&block); end
+
+  # @returns [Boolean] Whether the headers include the specified key.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:221
+  def include?(key); end
+
+  # Inspect the headers.
+  #
+  # @returns [String] A string representation of the headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:497
+  def inspect; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:225
+  def key?(key); end
+
+  # @returns [Array] All the keys of the headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:228
+  def keys; end
+
+  # Merge the headers into a new instance of {Headers}.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:333
+  def merge(headers); end
+
+  # Merge the headers into this instance.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:324
+  def merge!(headers); end
+
+  # @attribute [Hash] The policy for the headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:90
+  def policy; end
+
+  # Set the policy for the headers.
+  #
+  # The policy is used to determine how headers are merged and normalized. For example, if a header is specified multiple times, the policy will determine how the values are merged.
+  #
+  # @parameter policy [Hash] The policy for the headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:97
+  def policy=(policy); end
+
+  # Set the specified header key to the specified value, replacing any existing header keys with the same name.
+  #
+  # @parameter key [String] the header key to replace.
+  # @parameter value [String] the header value to assign.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:276
+  def set(key, value); end
+
+  # @attribute [Integer | Nil] The index where trailers begin.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:138
+  def tail; end
+
+  # @returns [Array] The fields of the headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:141
+  def to_a; end
+
+  # Compute a hash table of headers, where the keys are normalized to lower case and the values are normalized according to the policy for that header.
+  #
+  # This will enforce policy rules, such as merging multiple headers into arrays, or raising errors for duplicate headers.
+  #
+  # @returns [Hash] A hash table of `{key, value}` pairs.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:477
+  def to_h; end
+
+  # Enumerate all headers in the trailer, if there are any.
+  #
+  # @yields {|key, value| ...} The header key and value.
+  # 	@parameter key [String] The header key.
+  # 	@parameter value [String] The raw header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:185
+  def trailer(&block); end
+
+  # Record the current headers, and prepare to add trailers.
+  #
+  # This method is typically used after headers are sent to capture any additional headers which should then be sent as trailers.
+  #
+  # A sender that intends to generate one or more trailer fields in a message should generate a trailer header field in the header section of that message to indicate which fields might be present in the trailers.
+  #
+  # @parameter names [Array] The trailer header names which will be added later.
+  # @yields {|name, value| ...} the trailing headers if a block is given.
+  # @returns An enumerator which is suitable for iterating over trailers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:159
+  def trailer!(&block); end
+
+  # @returns [Boolean] Whether there are any trailers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:146
+  def trailer?; end
+
+  protected
+
+  # Merge the value into the hash according to the policy for the given key.
+  #
+  # @parameter hash [Hash] The hash to merge into.
+  # @parameter key [String] The header key.
+  # @parameter value [String] The raw header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:456
+  def merge_into(hash, key, value); end
+
+  private
+
+  # Initialize a copy of the headers.
+  #
+  # @parameter other [Headers] The headers to copy.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:105
+  def initialize_dup(other); end
+
+  class << self
+    # Construct an instance from a headers Array or Hash. No-op if already an instance of `Headers`. If the underlying array is frozen, it will be duped.
+    #
+    # @return [Headers] an instance of headers.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/headers.rb:51
+    def [](headers); end
+  end
+end
+
+# Used for merging objects into a sequential list of headers. Normalizes header keys and values.
+#
+# pkg:gem/protocol-http#lib/protocol/http/headers.rb:516
+class Protocol::HTTP::Headers::Merged
+  include ::Enumerable
+
+  # Construct a merged list of headers.
+  #
+  # @parameter *all [Array] An array of all headers to merge.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:522
+  def initialize(*all); end
+
+  # Add a new set of headers to the merged list.
+  #
+  # @parameter headers [Headers | Array | Hash] A list of headers to add.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:544
+  def <<(headers); end
+
+  # Clear the references to all headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:537
+  def clear; end
+
+  # Enumerate all headers in the merged list.
+  #
+  # @yields {|key, value| ...} The header key and value.
+  # 	@parameter key [String] The header key (lower case).
+  # 	@parameter value [String] The header value.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:555
+  def each(&block); end
+
+  # @returns [Array] A list of all headers, in the order they were added, as `[key, value]` pairs.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:527
+  def fields; end
+
+  # @returns [Headers] A new instance of {Headers} containing all the merged headers.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/headers.rb:532
+  def flatten; end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/headers.rb:44
+Protocol::HTTP::Headers::Multiple = Protocol::HTTP::Header::Multiple
+
+# The policy for various headers, including how they are merged and normalized.
+#
+# A policy may be `false` to indicate that the header may only be specified once and is a simple string.
+#
+# Otherwise, the policy is a class which implements the header normalization logic, including `parse` and `coerce` class methods.
+#
+# pkg:gem/protocol-http#lib/protocol/http/headers.rb:342
+Protocol::HTTP::Headers::POLICY = T.let(T.unsafe(nil), Hash)
+
+# pkg:gem/protocol-http#lib/protocol/http/headers.rb:43
+Protocol::HTTP::Headers::Split = Protocol::HTTP::Header::Split
+
+# pkg:gem/protocol-http#lib/protocol/http/headers.rb:46
+Protocol::HTTP::Headers::TRAILER = T.let(T.unsafe(nil), String)
+
+# Raised when an HTTP header is malformed or invalid. When raised while processing an incoming request, it may be treated as a bad request.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:30
+class Protocol::HTTP::InvalidHeaderError < ::Protocol::HTTP::Error
+  include ::Protocol::HTTP::BadRequest
+end
+
+# Raised when an invalid trailer header is encountered in headers.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:67
+class Protocol::HTTP::InvalidTrailerError < ::Protocol::HTTP::InvalidHeaderError
+  # @parameter key [String] The trailer key that is invalid.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/error.rb:69
+  def initialize(key); end
+
+  # @attribute [String] key The trailer key that is invalid.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/error.rb:74
+  def key; end
+end
+
+# Provides a convenient interface for commonly supported HTTP methods.
+#
+#
+# These methods are defined in this module using lower case names. They are for convenience only and you should not overload those methods.
+#
+# See <https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods> for more details.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:26
+class Protocol::HTTP::Methods
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def connect(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def delete(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def get(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def head(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def options(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def patch(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def post(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def put(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def query(*arguments, **options); end
+
+  # pkg:gem/protocol-http#lib/protocol/http/methods.rb:82
+  def trace(*arguments, **options); end
+
+  class << self
+    # Enumerate all HTTP methods.
+    # @yields {|name, value| ...}
+    # 	@parameter name [Symbol] The name of the method, e.g. `:GET`.
+    # 	@parameter value [String] The value of the method, e.g. `"GET"`.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/methods.rb:73
+    def each; end
+
+    # Check if the given name is a valid HTTP method, according to this module.
+    #
+    # Note that this method only knows about the methods defined in this module, however there are many other methods defined in different specifications.
+    #
+    # @returns [Boolean] True if the name is a valid HTTP method.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/methods.rb:62
+    def valid?(name); end
+  end
+end
+
+# The CONNECT method establishes a tunnel to the server identified by the target resource.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:43
+Protocol::HTTP::Methods::CONNECT = T.let(T.unsafe(nil), String)
+
+# The DELETE method deletes the specified resource.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:40
+Protocol::HTTP::Methods::DELETE = T.let(T.unsafe(nil), String)
+
+# The GET method requests a representation of the specified resource. Requests using GET should only retrieve data.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:28
+Protocol::HTTP::Methods::GET = T.let(T.unsafe(nil), String)
+
+# The HEAD method asks for a response identical to a GET request, but without the response body.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:31
+Protocol::HTTP::Methods::HEAD = T.let(T.unsafe(nil), String)
+
+# The OPTIONS method describes the communication options for the target resource.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:46
+Protocol::HTTP::Methods::OPTIONS = T.let(T.unsafe(nil), String)
+
+# The PATCH method applies partial modifications to a resource.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:52
+Protocol::HTTP::Methods::PATCH = T.let(T.unsafe(nil), String)
+
+# The POST method submits an entity to the specified resource, often causing a change in state or side effects on the server.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:34
+Protocol::HTTP::Methods::POST = T.let(T.unsafe(nil), String)
+
+# The PUT method replaces all current representations of the target resource with the request payload.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:37
+Protocol::HTTP::Methods::PUT = T.let(T.unsafe(nil), String)
+
+# The QUERY method performs a read-only, idempotent query using a request body.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:55
+Protocol::HTTP::Methods::QUERY = T.let(T.unsafe(nil), String)
+
+# The TRACE method performs a message loop-back test along the path to the target resource.
+#
+# pkg:gem/protocol-http#lib/protocol/http/methods.rb:49
+Protocol::HTTP::Methods::TRACE = T.let(T.unsafe(nil), String)
+
+# The middleware interface provides a convenient wrapper for implementing HTTP middleware.
+#
+# A middleware instance generally needs to respond to two methods:
+#
+# - `call(request)` -> `response`
+# - `close()`
+#
+# The call method is called for each request. The close method is called when the server is shutting down.
+#
+# You do not need to use the Middleware class to implement middleware. You can implement the interface directly.
+#
+# pkg:gem/protocol-http#lib/protocol/http/middleware.rb:23
+class Protocol::HTTP::Middleware < ::Protocol::HTTP::Methods
+  # Initialize the middleware with the given delegate.
+  #
+  # @parameter delegate [Object] The delegate object. A delegate is used for passing along requests that are not handled by *this* middleware.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:39
+  def initialize(delegate); end
+
+  # Call the middleware with the given request. Invokes the call method on the delegate.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:52
+  def call(request); end
+
+  # Close the middleware. Invokes the close method on the delegate.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:47
+  def close; end
+
+  # @attribute [Object] The delegate object that is used for passing along requests that are not handled by *this* middleware.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:44
+  def delegate; end
+
+  class << self
+    # Convert a block to a middleware delegate.
+    #
+    # @parameter block [Proc] The block to convert to a middleware delegate.
+    # @returns [Middleware] The middleware delegate.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:28
+    def for(&block); end
+  end
+end
+
+# A simple middleware that always returns "Hello World!".
+#
+# pkg:gem/protocol-http#lib/protocol/http/middleware.rb:87
+module Protocol::HTTP::Middleware::HelloWorld
+  class << self
+    # Call the middleware with the given request.
+    #
+    # @parameter request [Request] The request object.
+    # @returns [Response] The response object, whihc always contains "Hello World!".
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:96
+    def call(request); end
+
+    # Close the middleware - idempotent no-op.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:89
+    def close; end
+  end
+end
+
+# A simple middleware that always returns a 404 response.
+#
+# pkg:gem/protocol-http#lib/protocol/http/middleware.rb:72
+module Protocol::HTTP::Middleware::NotFound
+  class << self
+    # Call the middleware with the given request, always returning a 404 response. This middleware is useful as a default.
+    #
+    # @parameter request [Request] The request object.
+    # @returns [Response] The response object, which always contains a 404 status code.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:81
+    def call(request); end
+
+    # Close the middleware - idempotent no-op.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:74
+    def close; end
+  end
+end
+
+# A simple middleware that always returns a 200 response.
+#
+# pkg:gem/protocol-http#lib/protocol/http/middleware.rb:57
+module Protocol::HTTP::Middleware::Okay
+  class << self
+    # Call the middleware with the given request, always returning a 200 response.
+    #
+    # @parameter request [Request] The request object.
+    # @returns [Response] The response object, which always contains a 200 status code.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:66
+    def call(request); end
+
+    # Close the middleware - idempotent no-op.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/middleware.rb:59
+    def close; end
+  end
+end
+
+# Provide a well defined, cached representation of a peer (address).
+#
+# pkg:gem/protocol-http#lib/protocol/http/peer.rb:9
+class Protocol::HTTP::Peer
+  # Initialize the peer with the given address.
+  #
+  # @parameter address [Addrinfo] The remote address of the peer.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/peer.rb:22
+  def initialize(address); end
+
+  # @attribute [Addrinfo] The remote address of the peer.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/peer.rb:31
+  def address; end
+
+  # @attribute [String] The IP address of the peer, if available.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/peer.rb:34
+  def ip_address; end
+
+  # pkg:gem/protocol-http#lib/protocol/http/peer.rb:36
+  def remote_address; end
+
+  class << self
+    # Create a new peer object for the given IO object, using the remote address if available.
+    #
+    # @returns [Peer | Nil] The peer object, or nil if the remote address is not available.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/peer.rb:13
+    def for(io); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/quoted_string.rb:11
+Protocol::HTTP::QUOTED_STRING = T.let(T.unsafe(nil), Regexp)
+
+# https://tools.ietf.org/html/rfc7231#section-5.3.1
+#
+# pkg:gem/protocol-http#lib/protocol/http/quoted_string.rb:14
+Protocol::HTTP::QVALUE = T.let(T.unsafe(nil), Regexp)
+
+# Handling of HTTP quoted strings.
+#
+# pkg:gem/protocol-http#lib/protocol/http/quoted_string.rb:17
+module Protocol::HTTP::QuotedString
+  class << self
+    # Quote a string for HTTP header values if required.
+    #
+    # @raises [ArgumentError] if the value contains invalid characters like control characters or newlines.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/quoted_string.rb:37
+    def quote(value, force = T.unsafe(nil)); end
+
+    # Unquote a "quoted-string" value according to <https://tools.ietf.org/html/rfc7230#section-3.2.6>. It should already match the QUOTED_STRING pattern above by the parser.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/quoted_string.rb:19
+    def unquote(value, normalize_whitespace = T.unsafe(nil)); end
+  end
+end
+
+# pkg:gem/protocol-http#lib/protocol/http/quoted_string.rb:32
+Protocol::HTTP::QuotedString::QUOTES_REQUIRED = T.let(T.unsafe(nil), Regexp)
+
+# Raised when an HTTP stream or request was refused before any processing occurred.
+# In the case of requests, it indicates that the request was refused before any processing occurred, and can be safely retried.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:14
+class Protocol::HTTP::RefusedError < ::Protocol::HTTP::Error; end
+
+# Raised when the remote endpoint fails while processing an HTTP stream or request.
+# This error does not indicate whether application processing occurred. Where available, the protocol-specific error should be attached as the cause.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:19
+class Protocol::HTTP::RemoteError < ::Protocol::HTTP::Error; end
+
+# Represents an HTTP request which can be used both server and client-side.
+#
+# ~~~ ruby
+# require 'protocol/http'
+#
+# # Long form:
+# Protocol::HTTP::Request.new("http", "example.com", "GET", "/index.html", "HTTP/1.1", Protocol::HTTP::Headers[["accept", "text/html"]])
+#
+# # Short form:
+# Protocol::HTTP::Request["GET", "/index.html", {"accept" => "text/html"}]
+# ~~~
+#
+# pkg:gem/protocol-http#lib/protocol/http/request.rb:25
+class Protocol::HTTP::Request
+  include ::Protocol::HTTP::Body::Reader
+
+  # Initialize the request.
+  #
+  # @parameter scheme [String | Nil] The request scheme, usually `"http"` or `"https"`.
+  # @parameter authority [String | Nil] The request authority, usually a hostname and port number, e.g. `"example.com:80"`.
+  # @parameter method [String | Nil] The request method, usually one of `"GET"`, `"HEAD"`, `"POST"`, `"PUT"`, `"DELETE"`, `"CONNECT"` or `"OPTIONS"`, etc.
+  # @parameter path [String | Nil] The request path, usually a path and query string, e.g. `"/index.html"`, `"/search?q=hello"`, etc.
+  # @parameter version [String | Nil] The request version, usually `"http/1.0"`, `"http/1.1"`, `"h2"`, or `"h3"`.
+  # @parameter headers [Headers] The request headers, usually containing metadata associated with the request such as the `"user-agent"`, `"accept"` (content type), `"accept-language"`, etc.
+  # @parameter body [Body::Readable] The request body.
+  # @parameter protocol [String | Array(String) | Nil] The request protocol, usually empty, but occasionally `"websocket"` or `"webtransport"`.
+  # @parameter interim_response [Proc] A callback which is called when an interim response is received.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:39
+  def initialize(scheme = T.unsafe(nil), authority = T.unsafe(nil), method = T.unsafe(nil), path = T.unsafe(nil), version = T.unsafe(nil), headers = T.unsafe(nil), body = T.unsafe(nil), protocol = T.unsafe(nil), interim_response = T.unsafe(nil)); end
+
+  # Convert the request to a hash, suitable for serialization.
+  #
+  # @returns [Hash] The request as a hash.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:181
+  def as_json(*, **, &); end
+
+  # @attribute [String] the request authority, usually a hostname and port number, e.g. `"example.com:80"`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:55
+  def authority; end
+
+  # @attribute [String] the request authority, usually a hostname and port number, e.g. `"example.com:80"`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:55
+  def authority=(_arg0); end
+
+  # @attribute [Body::Readable] the request body. It should only be read once (it may not be idempotent).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:70
+  def body; end
+
+  # @attribute [Body::Readable] the request body. It should only be read once (it may not be idempotent).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:70
+  def body=(_arg0); end
+
+  # Send the request to the given connection.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:86
+  def call(connection); end
+
+  # Whether this is a CONNECT request: typically used to establish a tunnel.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:117
+  def connect?; end
+
+  # Whether this is a HEAD request: no body is expected in the response.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:112
+  def head?; end
+
+  # @attribute [Headers] the request headers, usually containing metadata associated with the request such as the `"user-agent"`, `"accept"` (content type), `"accept-language"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:67
+  def headers; end
+
+  # @attribute [Headers] the request headers, usually containing metadata associated with the request such as the `"user-agent"`, `"accept"` (content type), `"accept-language"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:67
+  def headers=(_arg0); end
+
+  # Whether the request can be replayed without side-effects.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:136
+  def idempotent?; end
+
+  # @attribute [Proc] a callback which is called when an interim response is received.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:76
+  def interim_response; end
+
+  # @attribute [Proc] a callback which is called when an interim response is received.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:76
+  def interim_response=(_arg0); end
+
+  # @attribute [String] the request method, usually one of `"GET"`, `"HEAD"`, `"POST"`, `"PUT"`, `"DELETE"`, `"CONNECT"` or `"OPTIONS"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:58
+  def method; end
+
+  # @attribute [String] the request method, usually one of `"GET"`, `"HEAD"`, `"POST"`, `"PUT"`, `"DELETE"`, `"CONNECT"` or `"OPTIONS"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:58
+  def method=(_arg0); end
+
+  # Register a callback to be called when an interim response is received.
+  #
+  # @yields {|status, headers| ...} The callback to be called when an interim response is received.
+  # 	@parameter status [Integer] The HTTP status code, e.g. `100`, `101`, etc.
+  # 	@parameter headers [Hash] The headers, e.g. `{"link" => "</style.css>; rel=stylesheet"}`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:100
+  def on_interim_response(&block); end
+
+  # @attribute [String] the request path, usually a path and query string, e.g. `"/index.html"`, `"/search?q=hello"`, however it can be any [valid request target](https://www.rfc-editor.org/rfc/rfc9110#target.resource).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:61
+  def path; end
+
+  # @attribute [String] the request path, usually a path and query string, e.g. `"/index.html"`, `"/search?q=hello"`, however it can be any [valid request target](https://www.rfc-editor.org/rfc/rfc9110#target.resource).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:61
+  def path=(_arg0); end
+
+  # A request that is generated by a server, may choose to include the peer (address) associated with the request. It should be implemented by a sub-class.
+  #
+  # @returns [Peer | Nil] The peer (address) associated with the request.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:81
+  def peer; end
+
+  # @attribute [String | Array(String) | Nil] the request protocol, usually empty, but occasionally `"websocket"` or `"webtransport"`. In HTTP/1, it is used to request a connection upgrade, and in HTTP/2 it is used to indicate a specfic protocol for the stream.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:73
+  def protocol; end
+
+  # @attribute [String | Array(String) | Nil] the request protocol, usually empty, but occasionally `"websocket"` or `"webtransport"`. In HTTP/1, it is used to request a connection upgrade, and in HTTP/2 it is used to indicate a specfic protocol for the stream.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:73
+  def protocol=(_arg0); end
+
+  # Prepare the request body to be sent again, if it is safe to retry.
+  # @returns [Boolean] Whether the request was prepared for retry.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:169
+  def retry!; end
+
+  # Rewind the request body so it can be sent again.
+  # @returns [Boolean] Whether the request body was rewound.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:158
+  def rewind!; end
+
+  # @attribute [String] the request scheme, usually `"http"` or `"https"`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:52
+  def scheme; end
+
+  # @attribute [String] the request scheme, usually `"http"` or `"https"`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:52
+  def scheme=(_arg0); end
+
+  # Send an interim response back to the origin of this request, if possible.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:91
+  def send_interim_response(status, headers); end
+
+  # Convert the request to JSON.
+  #
+  # @returns [String] The request as JSON.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:197
+  def to_json(*, **, &); end
+
+  # Summarize the request as a string.
+  #
+  # @returns [String] The request as a string.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:204
+  def to_s; end
+
+  # @attribute [String] the request version, usually `"http/1.0"`, `"http/1.1"`, `"h2"`, or `"h3"`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:64
+  def version; end
+
+  # @attribute [String] the request version, usually `"http/1.0"`, `"http/1.1"`, `"h2"`, or `"h3"`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/request.rb:64
+  def version=(_arg0); end
+
+  class << self
+    # A short-cut method which exposes the main request variables that you'd typically care about.
+    #
+    # @parameter method [String] The HTTP method, e.g. `"GET"`, `"POST"`, etc.
+    # @parameter path [String] The path, e.g. `"/index.html"`, `"/search?q=hello"`, etc.
+    # @parameter headers [Hash] The headers, e.g. `{"accept" => "text/html"}`, etc.
+    # @parameter body [String | Array(String) | Body::Readable] The body, e.g. `"Hello, World!"`, etc. See {Body::Buffered.wrap} for more information about .
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/request.rb:127
+    def [](method, path = T.unsafe(nil), _headers = T.unsafe(nil), _body = T.unsafe(nil), scheme: T.unsafe(nil), authority: T.unsafe(nil), headers: T.unsafe(nil), body: T.unsafe(nil), protocol: T.unsafe(nil), interim_response: T.unsafe(nil)); end
+  end
+end
+
+# @deprecated Use {RefusedError} instead.
+#
+# pkg:gem/protocol-http#lib/protocol/http/error.rb:23
+Protocol::HTTP::RequestRefusedError = Protocol::HTTP::RefusedError
+
+# Represents an HTTP response which can be used both server and client-side.
+#
+# ~~~ ruby
+# require 'protocol/http'
+#
+# # Long form:
+# Protocol::HTTP::Response.new("http/1.1", 200, Protocol::HTTP::Headers[["content-type", "text/html"]], Protocol::HTTP::Body::Buffered.wrap("Hello, World!"))
+#
+# # Short form:
+# Protocol::HTTP::Response[200, {"content-type" => "text/html"}, ["Hello, World!"]]
+# ~~~
+#
+# pkg:gem/protocol-http#lib/protocol/http/response.rb:23
+class Protocol::HTTP::Response
+  include ::Protocol::HTTP::Body::Reader
+
+  # Create a new response.
+  #
+  # @parameter version [String | Nil] The HTTP version, e.g. `"HTTP/1.1"`. If `nil`, the version may be provided by the server sending the response.
+  # @parameter status [Integer] The HTTP status code, e.g. `200`, `404`, etc.
+  # @parameter headers [Hash] The headers, e.g. `{"content-type" => "text/html"}`, etc.
+  # @parameter body [Body::Readable] The body, e.g. `"Hello, World!"`, etc.
+  # @parameter protocol [String | Array(String)] The protocol, e.g. `"websocket"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:33
+  def initialize(version = T.unsafe(nil), status = T.unsafe(nil), headers = T.unsafe(nil), body = T.unsafe(nil), protocol = T.unsafe(nil)); end
+
+  # Convert the response to a hash suitable for serialization.
+  #
+  # @returns [Hash] The response as a hash.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:158
+  def as_json(*, **, &); end
+
+  # Whether the status is 400 (bad request).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:120
+  def bad_request?; end
+
+  # @attribute [Body::Readable] The body, e.g. `"Hello, World!"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:51
+  def body; end
+
+  # @attribute [Body::Readable] The body, e.g. `"Hello, World!"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:51
+  def body=(_arg0); end
+
+  # Whether the status is 100 (continue).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:69
+  def continue?; end
+
+  # Whether the status is considered a failure.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:115
+  def failure?; end
+
+  # Whether the status is considered final. Note that 101 is considered final.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:79
+  def final?; end
+
+  # @attribute [Hash] The headers, e.g. `{"content-type" => "text/html"}`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:48
+  def headers; end
+
+  # @attribute [Hash] The headers, e.g. `{"content-type" => "text/html"}`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:48
+  def headers=(_arg0); end
+
+  # Whether the response is considered a hijack: the connection has been taken over by the application and the server should not send any more data.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:64
+  def hijack?; end
+
+  # Whether the status is considered informational.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:74
+  def informational?; end
+
+  # Whether the status is 500 (internal server error).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:125
+  def internal_server_error?; end
+
+  # Whether the status is 304 (not modified).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:105
+  def not_modified?; end
+
+  # Whether the status is 200 (ok).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:85
+  def ok?; end
+
+  # Whether the status is 206 (partial content).
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:95
+  def partial?; end
+
+  # A response that is generated by a client, may choose to include the peer (address) associated with the response. It should be implemented by a sub-class.
+  #
+  # @returns [Peer | Nil] The peer (address) associated with the response.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:59
+  def peer; end
+
+  # Whether the status is 307 (temporary redirect) and should preserve the method of the request when following the redirect.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:110
+  def preserve_method?; end
+
+  # @attribute [String | Array(String) | Nil] The protocol, e.g. `"websocket"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:54
+  def protocol; end
+
+  # @attribute [String | Array(String) | Nil] The protocol, e.g. `"websocket"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:54
+  def protocol=(_arg0); end
+
+  # Whether the status is considered a redirection.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:100
+  def redirection?; end
+
+  # @deprecated Use {#internal_server_error?} instead.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:130
+  def server_failure?; end
+
+  # @attribute [Integer] The HTTP status code, e.g. `200`, `404`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:45
+  def status; end
+
+  # @attribute [Integer] The HTTP status code, e.g. `200`, `404`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:45
+  def status=(_arg0); end
+
+  # Whether the status is considered successful.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:90
+  def success?; end
+
+  # Implicit conversion to an array.
+  #
+  # @returns [Array] The response as an array, e.g. `[status, headers, body]`.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:185
+  def to_ary; end
+
+  # Convert the response to JSON.
+  #
+  # @returns [String] The response as JSON.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:171
+  def to_json(*, **, &); end
+
+  # Summarise the response as a string.
+  #
+  # @returns [String] The response as a string.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:178
+  def to_s; end
+
+  # @attribute [String | Nil] The HTTP version, usually one of `"HTTP/1.1"`, `"HTTP/2"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:42
+  def version; end
+
+  # @attribute [String | Nil] The HTTP version, usually one of `"HTTP/1.1"`, `"HTTP/2"`, etc.
+  #
+  # pkg:gem/protocol-http#lib/protocol/http/response.rb:42
+  def version=(_arg0); end
+
+  class << self
+    # A short-cut method which exposes the main response variables that you'd typically care about. It follows the same order as the `Rack` response tuple, but also includes the protocol.
+    #
+    # ~~~ ruby
+    # 	Response[200, {"content-type" => "text/html"}, ["Hello, World!"]]
+    # ~~~
+    #
+    # @parameter status [Integer] The HTTP status code, e.g. `200`, `404`, etc.
+    # @parameter headers [Hash] The headers, e.g. `{"content-type" => "text/html"}`, etc.
+    # @parameter body [String | Array(String) | Body::Readable] The body, e.g. `"Hello, World!"`, etc. See {Body::Buffered.wrap} for more information about .
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/response.rb:141
+    def [](status, _headers = T.unsafe(nil), _body = T.unsafe(nil), headers: T.unsafe(nil), body: T.unsafe(nil), protocol: T.unsafe(nil)); end
+
+    # Create a response for the given exception.
+    #
+    # @parameter exception [Exception] The exception to generate the response for.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/response.rb:151
+    def for_exception(exception); end
+  end
+end
+
+# HTTP status codes and their human-readable descriptions.
+#
+# pkg:gem/protocol-http#lib/protocol/http/status.rb:9
+module Protocol::HTTP::Status
+  class << self
+    # Look up the human-readable description for a status code.
+    # @parameter code [Integer] The HTTP status code.
+    # @returns [String | Nil] The standard description, if known.
+    #
+    # pkg:gem/protocol-http#lib/protocol/http/status.rb:84
+    def description(code); end
+  end
+end
+
+# Human-readable descriptions for registered and conventional HTTP status codes.
+#
+# pkg:gem/protocol-http#lib/protocol/http/status.rb:11
+Protocol::HTTP::Status::DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# According to https://tools.ietf.org/html/rfc7231#appendix-C
+#
+# pkg:gem/protocol-http#lib/protocol/http/quoted_string.rb:9
+Protocol::HTTP::TOKEN = T.let(T.unsafe(nil), Regexp)