e621stream 0.0.0

data/sorbet/rbi/gems/async-http@0.105.0.rbi

@@ -0,0 +1,1649 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `async-http` gem.
+# Please instead update this file by running `bin/tapioca gem async-http`.
+
+
+# @namespace
+# Released under the MIT License.
+# Copyright, 2025-2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+#
+# pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:6
+module Async; end
+
+# @namespace
+#
+# pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:7
+module Async::HTTP; end
+
+# @namespace
+#
+# pkg:gem/async-http#lib/async/http/body/writable.rb:11
+module Async::HTTP::Body; end
+
+# pkg:gem/async-http#lib/async/http/body/writable.rb:12
+Async::HTTP::Body::Writable = Protocol::HTTP::Body::Writable
+
+# An HTTP client that manages persistent connections to a specific endpoint, with automatic retries for idempotent requests.
+#
+# pkg:gem/async-http#lib/async/http/client.rb:22
+class Async::HTTP::Client < ::Protocol::HTTP::Methods
+  # Provides a robust interface to a server.
+  # * If there are no connections, it will create one.
+  # * If there are already connections, it will reuse it.
+  # * If a request fails, it will retry it up to N times if it was idempotent.
+  # The client object will never become unusable. It internally manages persistent connections (or non-persistent connections if that's required).
+  # @param endpoint [Endpoint] the endpoint to connnect to.
+  # @param protocol [Protocol::HTTP1 | Protocol::HTTP2 | Protocol::HTTPS] the protocol to use.
+  # @param scheme [String] The default scheme to set to requests.
+  # @param authority [String] The default authority to set to requests.
+  #
+  # pkg:gem/async-http#lib/async/http/client.rb:32
+  def initialize(endpoint, protocol: T.unsafe(nil), scheme: T.unsafe(nil), authority: T.unsafe(nil), retries: T.unsafe(nil), **options); end
+
+  # @returns [Hash] A JSON-compatible representation of this client.
+  #
+  # pkg:gem/async-http#lib/async/http/client.rb:44
+  def as_json(*, **, &); end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:66
+  def authority; end
+
+  # Send a request to the remote server, with automatic retries for idempotent requests.
+  # @parameter request [Protocol::HTTP::Request] The request to send.
+  # @returns [Protocol::HTTP::Response] The response from the server.
+  #
+  # pkg:gem/async-http#lib/async/http/client.rb:100
+  def call(request); end
+
+  # Close the client and all associated connections.
+  #
+  # pkg:gem/async-http#lib/async/http/client.rb:89
+  def close; end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:59
+  def endpoint; end
+
+  # @returns [String] A summary of this client.
+  #
+  # pkg:gem/async-http#lib/async/http/client.rb:149
+  def inspect; end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:63
+  def pool; end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:60
+  def protocol; end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:62
+  def retries; end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:65
+  def scheme; end
+
+  # @returns [Boolean] Whether the client uses a secure (TLS) connection.
+  #
+  # pkg:gem/async-http#lib/async/http/client.rb:69
+  def secure?; end
+
+  # @returns [String] A JSON string representation of this client.
+  #
+  # pkg:gem/async-http#lib/async/http/client.rb:55
+  def to_json(*, **, &); end
+
+  protected
+
+  # pkg:gem/async-http#lib/async/http/client.rb:163
+  def assign_default_tags(tags); end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:168
+  def make_pool(**options); end
+
+  # pkg:gem/async-http#lib/async/http/client.rb:155
+  def make_response(request, connection, attempt); end
+
+  class << self
+    # Open a client and optionally yield it, ensuring it is closed afterwards.
+    # @parameter arguments [Array] Arguments to pass to {initialize}.
+    # @parameter options [Hash] Options to pass to {initialize}.
+    #
+    # pkg:gem/async-http#lib/async/http/client.rb:76
+    def open(*arguments, **options, &block); end
+  end
+end
+
+# pkg:gem/async-http#lib/async/http/client.rb:19
+Async::HTTP::DEFAULT_RETRIES = T.let(T.unsafe(nil), Integer)
+
+# Represents a way to connect to a remote HTTP server.
+#
+# pkg:gem/async-http#lib/async/http/endpoint.rb:23
+class Async::HTTP::Endpoint < ::IO::Endpoint::Generic
+  # @option scheme [String] the scheme to use, overrides the URL scheme.
+  # @option hostname [String] the hostname to connect to (or bind to), overrides the URL hostname (used for SNI).
+  # @option port [Integer] the port to bind to, overrides the URL port.
+  # @option ssl_context [OpenSSL::SSL::SSLContext] the context to use for TLS.
+  # @option tls_configuration [IO::Endpoint::TLS::Configuration] the transport-neutral TLS configuration.
+  # @option alpn_protocols [Array(String)] the alpn protocols to negotiate.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:75
+  def initialize(url, endpoint = T.unsafe(nil), **options); end
+
+  # @returns [Addrinfo] The address of the underlying endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:113
+  def address; end
+
+  # @returns [Array(String)] The ALPN protocol names for TLS negotiation.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:179
+  def alpn_protocols; end
+
+  # @returns [String] The authority component (hostname and optional port).
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:159
+  def authority(ignore_default_port = T.unsafe(nil)); end
+
+  # Bind to the endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:246
+  def bind(*arguments, &block); end
+
+  # Build a suitable endpoint, optionally wrapping in TLS for secure connections.
+  # @parameter endpoint [IO::Endpoint::Generic | Nil] An optional underlying endpoint to wrap.
+  # @returns [IO::Endpoint::Generic] The constructed endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:218
+  def build_endpoint(endpoint = T.unsafe(nil)); end
+
+  # Connect to the endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:251
+  def connect(&block); end
+
+  # @returns [Integer] The default port for this endpoint's scheme.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:134
+  def default_port; end
+
+  # @returns [Boolean] Whether the endpoint's port is the default for its scheme.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:139
+  def default_port?; end
+
+  # Enumerate all resolved endpoints.
+  # @yields {|endpoint| ...} Each resolved endpoint.
+  # 	@parameter endpoint [Endpoint] The resolved endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:258
+  def each; end
+
+  # @returns [IO::Endpoint::Generic] The resolved endpoint, built on demand.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:235
+  def endpoint; end
+
+  # Set the underlying endpoint, wrapping it as needed.
+  # @parameter endpoint [IO::Endpoint::Generic] The endpoint to assign.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:241
+  def endpoint=(endpoint); end
+
+  # @returns [Boolean] Whether two endpoints are equal.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:272
+  def eql?(other); end
+
+  # @returns [Integer] The hash code for this endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:277
+  def hash; end
+
+  # The hostname is the server we are connecting to:
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:149
+  def hostname; end
+
+  # @returns [String] A detailed string representation of this endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:106
+  def inspect; end
+
+  # @returns [Array] A key suitable for identifying this endpoint in a hash.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:267
+  def key; end
+
+  # @returns [Boolean] Whether the endpoint refers to a localhost address.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:184
+  def localhost?; end
+
+  # Return the path and query components of the given URL.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:168
+  def path; end
+
+  # @returns [Integer] The port number for this endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:144
+  def port; end
+
+  # @returns [Protocol] The protocol to use for this endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:123
+  def protocol; end
+
+  # @returns [String] The URL scheme, e.g. `"http"` or `"https"`.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:154
+  def scheme; end
+
+  # @returns [Boolean] Whether this endpoint uses a secure protocol (HTTPS or WSS).
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:118
+  def secure?; end
+
+  # @returns [OpenSSL::SSL::SSLContext] The SSL context for TLS connections.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:198
+  def ssl_context; end
+
+  # We don't try to validate peer certificates when talking to localhost because they would always be self-signed.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:189
+  def ssl_verify_mode; end
+
+  # @returns [IO::Endpoint::TLS::Configuration | Nil] The transport-neutral TLS configuration.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:211
+  def tls_configuration; end
+
+  # @returns [String] A short string representation of this endpoint.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:101
+  def to_s; end
+
+  # @returns [URI] The URL representation of this endpoint, including port if non-default.
+  #
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:90
+  def to_url; end
+
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:110
+  def url; end
+
+  protected
+
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:297
+  def tcp_endpoint; end
+
+  # pkg:gem/async-http#lib/async/http/endpoint.rb:283
+  def tcp_options; end
+
+  class << self
+    # Coerce the given object into an endpoint.
+    # @parameter url [String | Endpoint] The URL or endpoint to convert.
+    #
+    # pkg:gem/async-http#lib/async/http/endpoint.rb:61
+    def [](url); end
+
+    # Construct an endpoint with a specified scheme, hostname, optional path, and options.
+    #
+    # @parameter scheme [String] The scheme to use, e.g. "http" or "https".
+    # @parameter hostname [String] The hostname to connect to (or bind to).
+    # @parameter *options [Hash] Additional options, passed to {initialize}.
+    #
+    # pkg:gem/async-http#lib/async/http/endpoint.rb:47
+    def for(scheme, hostname, path = T.unsafe(nil), **options); end
+
+    # Parse a URL string into an endpoint.
+    # @parameter string [String] The URL to parse.
+    # @parameter endpoint [IO::Endpoint::Generic | Nil] An optional underlying endpoint to use.
+    # @parameter options [Hash] Additional options to pass to {initialize}.
+    # @returns [Endpoint] The parsed endpoint.
+    #
+    # pkg:gem/async-http#lib/async/http/endpoint.rb:36
+    def parse(string, endpoint = T.unsafe(nil), **options); end
+  end
+end
+
+# pkg:gem/async-http#lib/async/http/endpoint.rb:24
+Async::HTTP::Endpoint::SCHEMES = T.let(T.unsafe(nil), Hash)
+
+# A protocol specifies a way in which to communicate with a remote peer.
+#
+# pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:8
+module Async::HTTP::Protocol; end
+
+# Provides a `new` method that creates a {Configured} wrapper, allowing protocols to be instantiated with custom options.
+#
+# pkg:gem/async-http#lib/async/http/protocol/configurable.rb:48
+module Async::HTTP::Protocol::Configurable
+  # Create a new {Configured} instance wrapping this protocol with the given options.
+  # @parameter options [Hash] Configuration options for client and server creation.
+  # @returns [Configured] A configured protocol instance.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/configurable.rb:52
+  def new(**options); end
+end
+
+# A protocol wrapper that forwards pre-configured options to client and server creation.
+#
+# pkg:gem/async-http#lib/async/http/protocol/configurable.rb:10
+class Async::HTTP::Protocol::Configured
+  # Initialize with a protocol and options.
+  # @parameter protocol [Protocol] The underlying protocol to configure.
+  # @parameter options [Hash] Options to forward to client and server creation.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/configurable.rb:14
+  def initialize(protocol, **options); end
+
+  # Create a client connection using the configured protocol options.
+  # @parameter peer [IO] The peer to communicate with.
+  # @parameter options [Hash] Additional options merged with the configured defaults.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/configurable.rb:28
+  def client(peer, **options); end
+
+  # @returns [Array(String)] The protocol names from the underlying protocol.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/configurable.rb:42
+  def names; end
+
+  # @attribute [Hash] The options to pass to the protocol.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/configurable.rb:23
+  def options; end
+
+  # @attribute [Protocol] The underlying protocol.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/configurable.rb:20
+  def protocol; end
+
+  # Create a server connection using the configured protocol options.
+  # @parameter peer [IO] The peer to communicate with.
+  # @parameter options [Hash] Additional options merged with the configured defaults.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/configurable.rb:36
+  def server(peer, **options); end
+end
+
+# This module provides a default instance of the protocol, which can be used to create clients and servers. The name is a play on "Default" + "Singleton".
+#
+# pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:10
+module Async::HTTP::Protocol::Defaulton
+  # Create a client for an outbound connection, using the default instance.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:18
+  def client(peer, **options); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:15
+  def default; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:15
+  def default=(_arg0); end
+
+  # @returns [Array] The names of the supported protocol, used for Application Layer Protocol Negotiation (ALPN), using the default instance.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:28
+  def names; end
+
+  # Create a server for an inbound connection, using the default instance.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:23
+  def server(peer, **options); end
+
+  class << self
+    # pkg:gem/async-http#lib/async/http/protocol/defaulton.rb:11
+    def extended(base); end
+  end
+end
+
+# HTTP is an http:// server that auto-selects HTTP/1.1 or HTTP/2 by detecting the HTTP/2 connection preface.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http.rb:16
+class Async::HTTP::Protocol::HTTP
+  extend ::Async::HTTP::Protocol::Defaulton
+
+  # Create a new HTTP protocol instance.
+  #
+  # @parameter http1 [HTTP1] The HTTP/1 protocol instance.
+  # @parameter http2 [HTTP2] The HTTP/2 protocol instance.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http.rb:24
+  def initialize(http1: T.unsafe(nil), http2: T.unsafe(nil)); end
+
+  # Create a client for an outbound connection. Defaults to HTTP/1 for plaintext connections.
+  #
+  # @parameter peer [IO] The peer to communicate with.
+  # @parameter options [Hash] Options to pass to the protocol, keyed by protocol class.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http.rb:62
+  def client(peer, **options); end
+
+  # The names of all supported protocols.
+  # @returns [Array(String)] The supported protocol names.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http.rb:31
+  def names; end
+
+  # Determine if the inbound connection is HTTP/1 or HTTP/2.
+  #
+  # @parameter stream [IO::Stream] The stream to detect the protocol for.
+  # @returns [Class] The protocol class to use.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http.rb:39
+  def protocol_for(stream); end
+
+  # Create a server for an inbound connection. Able to detect HTTP1 and HTTP2.
+  #
+  # @parameter peer [IO] The peer to communicate with.
+  # @parameter options [Hash] Options to pass to the protocol, keyed by protocol class.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http.rb:72
+  def server(peer, **options); end
+end
+
+# Provides HTTP/1.0 and HTTP/1.1 client and server implementations.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:11
+module Async::HTTP::Protocol::HTTP1
+  extend ::Async::HTTP::Protocol::Configurable
+
+  class << self
+    # @returns [Boolean] Whether the protocol supports bidirectional communication.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1.rb:24
+    def bidirectional?; end
+
+    # Create a client for an outbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the client instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1.rb:37
+    def client(peer, **options); end
+
+    # @returns [Array] The names of the supported protocol.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1.rb:54
+    def names; end
+
+    # Create a server for an inbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the server instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1.rb:47
+    def server(peer, **options); end
+
+    # @returns [Boolean] Whether the protocol supports trailers.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1.rb:29
+    def trailer?; end
+  end
+end
+
+# Provides an HTTP/1.0 client and server protocol implementation.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http10.rb:13
+module Async::HTTP::Protocol::HTTP10
+  extend ::Async::HTTP::Protocol::Configurable
+
+  class << self
+    # @returns [Boolean] Whether the protocol supports bidirectional communication.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http10.rb:19
+    def bidirectional?; end
+
+    # Create a client for an outbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the client instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http10.rb:32
+    def client(peer, **options); end
+
+    # @returns [Array] The names of the supported protocol.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http10.rb:49
+    def names; end
+
+    # Create a server for an inbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the server instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http10.rb:42
+    def server(peer, **options); end
+
+    # @returns [Boolean] Whether the protocol supports trailers.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http10.rb:24
+    def trailer?; end
+  end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http10.rb:16
+Async::HTTP::Protocol::HTTP10::VERSION = T.let(T.unsafe(nil), String)
+
+# Provides an HTTP/1.1 client and server protocol implementation.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http11.rb:14
+module Async::HTTP::Protocol::HTTP11
+  extend ::Async::HTTP::Protocol::Configurable
+
+  class << self
+    # @returns [Boolean] Whether the protocol supports bidirectional communication.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http11.rb:20
+    def bidirectional?; end
+
+    # Create a client for an outbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the client instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http11.rb:33
+    def client(peer, **options); end
+
+    # @returns [Array] The names of the supported protocol.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http11.rb:50
+    def names; end
+
+    # Create a server for an inbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the server instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http11.rb:43
+    def server(peer, **options); end
+
+    # @returns [Boolean] Whether the protocol supports trailers.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http11.rb:25
+    def trailer?; end
+  end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http11.rb:17
+Async::HTTP::Protocol::HTTP11::VERSION = T.let(T.unsafe(nil), String)
+
+# An HTTP/1 client connection that sends requests and reads responses.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http1/client.rb:13
+class Async::HTTP::Protocol::HTTP1::Client < ::Async::HTTP::Protocol::HTTP1::Connection
+  # Initialize the HTTP/1 client connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/client.rb:15
+  def initialize(*, **, &); end
+
+  # Used by the client to send requests to the remote server.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/client.rb:35
+  def call(request, task: T.unsafe(nil)); end
+
+  # Called when the connection is closed, releasing it back to the pool.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/client.rb:24
+  def closed(error = T.unsafe(nil)); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http1/client.rb:21
+  def pool; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http1/client.rb:21
+  def pool=(_arg0); end
+end
+
+# An HTTP/1 connection that wraps an IO stream with version and state tracking.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:17
+class Async::HTTP::Protocol::HTTP1::Connection < ::Protocol::HTTP1::Connection
+  # Initialize the connection with an IO stream and HTTP version.
+  # @parameter stream [IO::Stream] The underlying stream.
+  # @parameter version [String] The negotiated HTTP version string.
+  # @parameter options [Hash] Additional options for the connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:22
+  def initialize(stream, version, **options); end
+
+  # @returns [String] A JSON-compatible representation.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:35
+  def as_json(*, **, &); end
+
+  # @returns [Integer] The maximum number of concurrent requests (always 1 for HTTP/1).
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:64
+  def concurrency; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:61
+  def count; end
+
+  # @returns [Boolean] Whether this is an HTTP/1 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:47
+  def http1?; end
+
+  # @returns [Boolean] Whether this is an HTTP/2 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:52
+  def http2?; end
+
+  # @returns [Protocol::HTTP::Peer] The peer information for this connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:57
+  def peer; end
+
+  # @returns [Boolean] Whether the connection can be reused for another request.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:91
+  def reusable?; end
+
+  # @returns [String] A JSON string representation.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:40
+  def to_json(*, **, &); end
+
+  # @returns [String] A string representation of this connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:30
+  def to_s; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:44
+  def version; end
+
+  # Can we use this connection to make requests?
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/connection.rb:69
+  def viable?; end
+end
+
+# Keeps track of whether a body is being read, and if so, waits for it to be closed.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http1/finishable.rb:15
+class Async::HTTP::Protocol::HTTP1::Finishable < ::Protocol::HTTP::Body::Wrapper
+  # Initialize the finishable wrapper.
+  # @parameter body [Protocol::HTTP::Body::Readable] The body to wrap.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/finishable.rb:18
+  def initialize(body); end
+
+  # Close the body and signal any waiting tasks.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/finishable.rb:41
+  def close(error = T.unsafe(nil)); end
+
+  # @returns [String] A detailed representation of this finishable body.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/finishable.rb:65
+  def inspect; end
+
+  # Read the next chunk from the body.
+  # @returns [String | Nil] The next chunk of data.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/finishable.rb:34
+  def read; end
+
+  # @returns [Boolean] Whether the body has started reading.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/finishable.rb:28
+  def reading?; end
+
+  # Wait for the body to be fully consumed or discard it.
+  # @parameter persistent [Boolean] Whether the connection will be reused.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/finishable.rb:52
+  def wait(persistent = T.unsafe(nil)); end
+end
+
+# An incoming HTTP/1 request parsed from the connection.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:13
+class Async::HTTP::Protocol::HTTP1::Request < ::Async::HTTP::Protocol::Request
+  # Initialize the request from the parsed components.
+  # @parameter connection [Connection] The underlying connection.
+  # @parameter scheme [String | Nil] The request scheme.
+  # @parameter authority [String | Nil] The request authority.
+  # @parameter method [String] The HTTP method.
+  # @parameter path [String | Nil] The request path.
+  # @parameter version [String] The HTTP version.
+  # @parameter headers [Protocol::HTTP::Headers] The request headers.
+  # @parameter body [Protocol::HTTP::Body::Readable | Nil] The request body.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:61
+  def initialize(connection, scheme, authority, method, path, version, headers, body); end
+
+  # @returns [Connection] The underlying HTTP/1 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:71
+  def connection; end
+
+  # Hijack the underlying connection for bidirectional communication.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:81
+  def hijack!; end
+
+  # @returns [Boolean] Whether connection hijacking is supported.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:76
+  def hijack?; end
+
+  # Write an interim (1xx) response to the client.
+  # @parameter status [Integer] The interim HTTP status code.
+  # @parameter headers [Hash | Nil] Optional interim response headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:88
+  def write_interim_response(status, headers = T.unsafe(nil)); end
+
+  class << self
+    # Read and parse the next request from the connection.
+    # @parameter connection [Connection] The HTTP/1 connection to read from.
+    # @returns [Request | Nil] The parsed request, or `nil` if the connection is closed.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:32
+    def read(connection); end
+
+    # Check whether the given request target is a valid path.
+    # @parameter target [String] The request target to validate.
+    # @returns [Boolean] Whether the target is a valid path.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:17
+    def valid_path?(target); end
+  end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:50
+Async::HTTP::Protocol::HTTP1::Request::UPGRADE = T.let(T.unsafe(nil), String)
+
+# pkg:gem/async-http#lib/async/http/protocol/http1/request.rb:27
+Async::HTTP::Protocol::HTTP1::Request::URI_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# An HTTP/1 response received from a server.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:14
+class Async::HTTP::Protocol::HTTP1::Response < ::Async::HTTP::Protocol::Response
+  # @parameter reason [String] HTTP response line reason phrase.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:37
+  def initialize(connection, version, status, reason, headers, body); end
+
+  # @returns [Connection] The underlying HTTP/1 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:58
+  def connection; end
+
+  # Hijack the underlying connection for bidirectional communication.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:68
+  def hijack!; end
+
+  # @returns [Boolean] Whether connection hijacking is available (when the body is `nil`).
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:63
+  def hijack?; end
+
+  # Assign the connection pool, releasing the connection if it is already idle or closed.
+  # @parameter pool [Async::Pool::Controller] The connection pool.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:49
+  def pool=(pool); end
+
+  # @attribute [String] The HTTP response line reason.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:34
+  def reason; end
+
+  class << self
+    # Read the response from the connection, handling interim responses.
+    # @parameter connection [Connection] The HTTP/1 connection to read from.
+    # @parameter request [Request] The original request.
+    # @returns [Response | Nil] The final response.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:19
+    def read(connection, request); end
+  end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http1/response.rb:31
+Async::HTTP::Protocol::HTTP1::Response::UPGRADE = T.let(T.unsafe(nil), String)
+
+# An HTTP/1 server connection that receives requests and sends responses.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http1/server.rb:22
+class Async::HTTP::Protocol::HTTP1::Server < ::Async::HTTP::Protocol::HTTP1::Connection
+  # Initialize the HTTP/1 server connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/server.rb:24
+  def initialize(*, **, &); end
+
+  # Called when the connection is closed, signalling any waiting tasks.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/server.rb:31
+  def closed(error = T.unsafe(nil)); end
+
+  # Server loop.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/server.rb:75
+  def each(task: T.unsafe(nil)); end
+
+  # Write a failure response with the given status code and error class name.
+  # @parameter status [Integer] The HTTP status code to send.
+  # @parameter error [Exception] The error which caused the request to fail.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/server.rb:40
+  def fail_request(status, error); end
+
+  # Read the next incoming request from the connection.
+  # @returns [Request | Nil] The next request, or `nil` if the connection is closed.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http1/server.rb:53
+  def next_request; end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http1.rb:21
+Async::HTTP::Protocol::HTTP1::VERSION = T.let(T.unsafe(nil), String)
+
+# Provides an HTTP/2 client and server protocol implementation.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/input.rb:11
+module Async::HTTP::Protocol::HTTP2
+  extend ::Async::HTTP::Protocol::Configurable
+
+  class << self
+    # @returns [Boolean] Whether the protocol supports bidirectional communication.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http2.rb:24
+    def bidirectional?; end
+
+    # Create a client for an outbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the client instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http2.rb:55
+    def client(peer, settings: T.unsafe(nil)); end
+
+    # @returns [Array] The names of the supported protocol.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http2.rb:80
+    def names; end
+
+    # Create a server for an inbound connection.
+    #
+    # @parameter peer [IO] The peer to communicate with.
+    # @parameter options [Hash] Options to pass to the server instance.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http2.rb:69
+    def server(peer, settings: T.unsafe(nil)); end
+
+    # @returns [Boolean] Whether the protocol supports trailers.
+    #
+    # pkg:gem/async-http#lib/async/http/protocol/http2.rb:29
+    def trailer?; end
+  end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:22
+Async::HTTP::Protocol::HTTP2::AUTHORITY = T.let(T.unsafe(nil), String)
+
+# The default settings for the client.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2.rb:34
+Async::HTTP::Protocol::HTTP2::CLIENT_SETTINGS = T.let(T.unsafe(nil), Hash)
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:27
+Async::HTTP::Protocol::HTTP2::CONNECTION = T.let(T.unsafe(nil), String)
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:26
+Async::HTTP::Protocol::HTTP2::CONTENT_LENGTH = T.let(T.unsafe(nil), String)
+
+# An HTTP/2 client connection that sends requests and reads responses.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/client.rb:17
+class Async::HTTP::Protocol::HTTP2::Client < ::Protocol::HTTP2::Client
+  include ::Async::HTTP::Protocol::HTTP2::Connection
+
+  # Initialize the HTTP/2 client with an IO stream.
+  # @parameter stream [IO::Stream] The underlying stream.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/client.rb:22
+  def initialize(stream); end
+
+  # Used by the client to send requests to the remote server.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/client.rb:37
+  def call(request); end
+
+  # Create a new response stream for the next request.
+  # @returns [Response] The response object to be populated.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/client.rb:32
+  def create_response; end
+
+  # Wait for the response headers to arrive.
+  # @parameter response [Response] The response to wait on.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/client.rb:60
+  def read_response(response); end
+
+  # Write a request to the remote server via the given response stream.
+  # @parameter response [Response] The response stream to write through.
+  # @parameter request [Protocol::HTTP::Request] The request to send.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/client.rb:54
+  def write_request(response, request); end
+end
+
+# Provides shared connection behaviour for HTTP/2 client and server connections.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:31
+module Async::HTTP::Protocol::HTTP2::Connection
+  # Initialize the connection state.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:33
+  def initialize(*, **, &); end
+
+  # @returns [String] A JSON-compatible representation.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:64
+  def as_json(*, **, &); end
+
+  # Close the connection and stop the background reader.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:91
+  def close(error = T.unsafe(nil)); end
+
+  # The connection has finished draining the streams which the remote peer accepted before its graceful GOAWAY.
+  #
+  # The last of those streams can complete on the sending side, in a task other than the background reader - the response arrived first and the request body was still being written. The reader is then parked in a blocking read and will never notice that the connection is closed, so we stop it and let its `ensure` close the connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:105
+  def close_if_drained!; end
+
+  # @returns [Integer] The maximum number of concurrent streams allowed.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:151
+  def concurrency; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:148
+  def count; end
+
+  # @returns [Boolean] Whether this is an HTTP/1 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:76
+  def http1?; end
+
+  # @returns [Boolean] Whether this is an HTTP/2 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:81
+  def http2?; end
+
+  # @returns [Protocol::HTTP::Peer] The peer information for this connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:144
+  def peer; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:141
+  def promises; end
+
+  # Start a transient background task that reads frames from the connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:114
+  def read_in_background(parent: T.unsafe(nil)); end
+
+  # @returns [Boolean] Whether the connection can be reused.
+  #
+  # Once the remote peer has sent a GOAWAY frame, it will not process any new streams on this connection, so it must not be handed out for another request, even while the streams it accepted are still being drained.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:163
+  def reusable?; end
+
+  # Start the background reader task if it is not already running.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:86
+  def start_connection; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:73
+  def stream; end
+
+  # Synchronize write access to the connection.
+  # @yields {|...| ...} The block to execute while holding the write lock.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:44
+  def synchronize(&block); end
+
+  # @returns [String] A JSON string representation.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:69
+  def to_json(*, **, &); end
+
+  # @returns [String] A string representation of this connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:59
+  def to_s; end
+
+  # @returns [String] The HTTP version string.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:168
+  def version; end
+
+  # Can we use this connection to make requests?
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:156
+  def viable?; end
+
+  # Write a single frame, deferring stop until the frame is written.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:49
+  def write_frame(frame); end
+
+  # Write multiple frames, deferring stop until the frames are written.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:54
+  def write_frames; end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:18
+Async::HTTP::Protocol::HTTP2::HTTPS = T.let(T.unsafe(nil), String)
+
+# A writable body which requests window updates when data is read from it.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/input.rb:13
+class Async::HTTP::Protocol::HTTP2::Input < ::Protocol::HTTP::Body::Writable
+  # Initialize the input body.
+  # @parameter stream [Stream] The HTTP/2 stream to read from.
+  # @parameter length [Integer | Nil] The expected content length.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/input.rb:17
+  def initialize(stream, length); end
+
+  # Close the application-facing input body and notify the stream that incoming data is no longer being consumed. While local output is active, the HTTP/2 stream remains open. Once output also closes, the remaining wire stream is terminated without an error.
+  # @parameter error [Exception | Nil] The error that caused the input to be closed, if any.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/input.rb:48
+  def close(error = T.unsafe(nil)); end
+
+  # Read the next chunk of data, requesting window updates as needed.
+  # @returns [String | Nil] The next chunk, or `nil` if the body is complete.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/input.rb:26
+  def read; end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:20
+Async::HTTP::Protocol::HTTP2::METHOD = T.let(T.unsafe(nil), String)
+
+# Writes body data to an HTTP/2 stream, respecting flow control windows.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:13
+class Async::HTTP::Protocol::HTTP2::Output
+  # Initialize the output handler.
+  # @parameter stream [Stream] The HTTP/2 stream to write to.
+  # @parameter body [Protocol::HTTP::Body::Readable] The body to read from.
+  # @parameter trailer [Protocol::HTTP::Headers | Nil] Optional trailing headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:18
+  def initialize(stream, body, trailer = T.unsafe(nil)); end
+
+  # This method should only be called from within the context of the output task.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:88
+  def close(error = T.unsafe(nil)); end
+
+  # Close the wire output without cancelling a streamable body. This allows bidirectional bodies to observe an orderly input closure and finish normally. A non-streaming producer has no input side through which closure can propagate, so it is stopped directly.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:102
+  def close_stream; end
+
+  # Finish writing to the stream.
+  # @parameter error [Exception | Nil] An optional error that caused the close.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:80
+  def close_write(error = T.unsafe(nil)); end
+
+  # Start an asynchronous task to write the body to the stream.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:32
+  def start(parent: T.unsafe(nil)); end
+
+  # This method should only be called from within the context of the HTTP/2 stream.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:94
+  def stop(error); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:29
+  def trailer; end
+
+  # Signal that the flow control window has been updated.
+  # @parameter size [Integer] The new window size.
+  # @returns [Boolean] Always returns `true`.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:45
+  def window_updated(size); end
+
+  # Write a chunk of data to the HTTP/2 stream, respecting flow control.
+  # @parameter chunk [String] The data to write.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:55
+  def write(chunk); end
+
+  private
+
+  # Reads chunks from the given body and writes them to the stream as fast as possible.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:129
+  def passthrough(task); end
+
+  # Send `maximum_size` bytes of data using the specified `stream`. If the buffer has no more chunks, `END_STREAM` will be sent on the final chunk.
+  # @param maximum_size [Integer] send up to this many bytes of data.
+  # @param stream [Stream] the stream to use for sending data frames.
+  # @return [String, nil] any data that could not be written.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:155
+  def send_data(stream, chunk, maximum_size); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/output.rb:116
+  def stream(task); end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:21
+Async::HTTP::Protocol::HTTP2::PATH = T.let(T.unsafe(nil), String)
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:24
+Async::HTTP::Protocol::HTTP2::PROTOCOL = T.let(T.unsafe(nil), String)
+
+# Typically used on the server side to represent an incoming request, and write the response.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:14
+class Async::HTTP::Protocol::HTTP2::Request < ::Async::HTTP::Protocol::Request
+  # Initialize the request from an HTTP/2 stream.
+  # @parameter stream [Stream] The HTTP/2 stream for this request.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:125
+  def initialize(stream); end
+
+  # @returns [Connection] The underlying HTTP/2 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:134
+  def connection; end
+
+  # @returns [Boolean] Whether connection hijacking is supported (not available for HTTP/2).
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:144
+  def hijack?; end
+
+  # Send a response back to the client via the HTTP/2 stream.
+  # @parameter response [Protocol::HTTP::Response | Nil] The response to send.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:154
+  def send_response(response); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:131
+  def stream; end
+
+  # @returns [Boolean] Whether the request has the required pseudo-headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:139
+  def valid?; end
+
+  # Write an interim (1xx) response to the client.
+  # @parameter status [Integer] The interim HTTP status code.
+  # @parameter headers [Hash | Nil] Optional interim response headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:190
+  def write_interim_response(status, headers = T.unsafe(nil)); end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:148
+Async::HTTP::Protocol::HTTP2::Request::NO_RESPONSE = T.let(T.unsafe(nil), Array)
+
+# Represents the HTTP/2 stream associated with an incoming server-side request.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:16
+class Async::HTTP::Protocol::HTTP2::Request::Stream < ::Async::HTTP::Protocol::HTTP2::Stream
+  # Initialize the request stream.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:18
+  def initialize(*); end
+
+  # Called when the stream is closed.
+  # @parameter error [Exception | Nil] The error that caused the close, if any.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:116
+  def closed(error); end
+
+  # Write a failure response with the given status code and error class name.
+  # @parameter status [Integer] The HTTP status code to send.
+  # @parameter error [Exception] The error which caused the request to fail.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:30
+  def fail_request(status, error); end
+
+  # Process the initial headers received from the client and construct the request.
+  # @parameter headers [Array] The list of header key-value pairs.
+  # @parameter end_stream [Boolean] Whether the stream is complete after these headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:53
+  def receive_initial_headers(headers, end_stream); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/request.rb:25
+  def request; end
+end
+
+# Typically used on the client side for writing a request and reading the incoming response.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:16
+class Async::HTTP::Protocol::HTTP2::Response < ::Async::HTTP::Protocol::Response
+  # Initialize the response from an HTTP/2 stream.
+  # @parameter stream [Stream] The HTTP/2 stream for this response.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:141
+  def initialize(stream); end
+
+  # Build a request object from push promise headers.
+  # @parameter headers [Array] The push promise pseudo-headers and headers.
+  # @returns [Protocol::HTTP::Request] The constructed request.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:197
+  def build_request(headers); end
+
+  # Close this response as quickly as possible. If the response body is still active, cancel the HTTP/2 exchange rather than draining it.
+  # @parameter error [Exception | Nil] The error which closed the response.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:175
+  def close(error = T.unsafe(nil)); end
+
+  # @returns [Connection] The underlying HTTP/2 connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:164
+  def connection; end
+
+  # @returns [Boolean] Whether the original request was a HEAD request.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:185
+  def head?; end
+
+  # Assign the connection pool, releasing the connection when the stream is closed.
+  # @parameter pool [Async::Pool::Controller] The connection pool.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:153
+  def pool=(pool); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:149
+  def request; end
+
+  # Send a request and read it into this response.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:230
+  def send_request(request); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:148
+  def stream; end
+
+  # @returns [Boolean] Whether the response has a valid status.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:190
+  def valid?; end
+
+  # Wait for the response headers to be received.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:169
+  def wait; end
+end
+
+# Represents the HTTP/2 stream associated with an outgoing client-side response.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:18
+class Async::HTTP::Protocol::HTTP2::Response::Stream < ::Async::HTTP::Protocol::HTTP2::Stream
+  # Initialize the response stream.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:20
+  def initialize(*); end
+
+  # Handle a push promise stream from the server.
+  # @parameter promised_stream_id [Integer] The stream ID for the promised resource.
+  # @parameter headers [Array] The promise headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:45
+  def accept_push_promise_stream(promised_stream_id, headers); end
+
+  # Called when the stream is closed.
+  # @parameter error [Exception | Nil] The error that caused the close, if any.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:125
+  def closed(error); end
+
+  # This should be invoked from the background reader, and notifies the task waiting for the headers that we are done.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:50
+  def receive_initial_headers(headers, end_stream); end
+
+  # Process interim (1xx) response headers.
+  # @parameter status [Integer] The interim status code.
+  # @parameter headers [Array] The interim response headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:102
+  def receive_interim_headers(status, headers); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:28
+  def response; end
+
+  # Wait for the headers to be received or for stream reset.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:113
+  def wait; end
+
+  # Wait for the response headers and return the response body.
+  # @returns [Protocol::HTTP::Body::Readable | Nil] The response body.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/response.rb:32
+  def wait_for_input; end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:19
+Async::HTTP::Protocol::HTTP2::SCHEME = T.let(T.unsafe(nil), String)
+
+# The default settings for the server.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2.rb:42
+Async::HTTP::Protocol::HTTP2::SERVER_SETTINGS = T.let(T.unsafe(nil), Hash)
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:23
+Async::HTTP::Protocol::HTTP2::STATUS = T.let(T.unsafe(nil), String)
+
+# An HTTP/2 server connection that receives requests and sends responses.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/server.rb:17
+class Async::HTTP::Protocol::HTTP2::Server < ::Protocol::HTTP2::Server
+  include ::Async::HTTP::Protocol::HTTP2::Connection
+
+  # Initialize the HTTP/2 server with an IO stream.
+  # @parameter stream [IO::Stream] The underlying stream.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/server.rb:22
+  def initialize(stream); end
+
+  # Accept a new stream from a client.
+  # @parameter stream_id [Integer] The stream ID assigned by the client.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/server.rb:37
+  def accept_stream(stream_id); end
+
+  # Close the server connection and stop accepting requests.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/server.rb:44
+  def close(error = T.unsafe(nil)); end
+
+  # Enumerate incoming requests, yielding each one for processing.
+  # @yields {|request| ...} Each incoming request.
+  # 	@parameter request [Request] The incoming HTTP/2 request.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/server.rb:53
+  def each(task: T.unsafe(nil)); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/server.rb:33
+  def requests; end
+end
+
+# An HTTP/2 stream that manages headers, input data, and output data for a single request/response exchange.
+#
+# pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:18
+class Async::HTTP::Protocol::HTTP2::Stream < ::Protocol::HTTP2::Stream
+  # Initialize the stream state.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:20
+  def initialize(*); end
+
+  # Add a header to the stream, validating against HTTP/2 constraints.
+  # @parameter key [String] The header name.
+  # @parameter value [String] The header value.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:47
+  def add_header(key, value, trailer: T.unsafe(nil)); end
+
+  # When the stream transitions to the closed state, this method is called. There are roughly two ways this can happen:
+  # - A frame is received which causes this stream to enter the closed state. This method will be invoked from the background reader task.
+  # - A frame is sent which causes this stream to enter the closed state. This method will be invoked from that task.
+  # While the input stream is relatively straight forward, the output stream can trigger the second case above
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:212
+  def closed(error); end
+
+  # Close the application-facing receiving side of the stream. While local output remains active, incoming data is discarded with flow-control updates. Once local output is also closed, the remaining wire stream is terminated without an error.
+  # @parameter input [Input] The input body being closed.
+  # @parameter error [Exception | Nil] The error which closed the input.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:143
+  def finish_input(input, error = T.unsafe(nil)); end
+
+  # Called when the output terminates normally.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:164
+  def finish_output(error = T.unsafe(nil)); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:38
+  def headers; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:38
+  def headers=(_arg0); end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:42
+  def input; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:40
+  def pool; end
+
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:40
+  def pool=(_arg0); end
+
+  # Prepare the input stream which will be used for incoming data frames.
+  # @return [Input] the input body.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:97
+  def prepare_input(length); end
+
+  # Process an incoming DATA frame and write it to the input body.
+  # @parameter frame [Protocol::HTTP2::DataFrame] The data frame to process.
+  # @returns [String] The unpacked data.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:117
+  def process_data(frame); end
+
+  # Process an incoming HEADERS frame, dispatching to initial or trailing header handling.
+  # @parameter frame [Protocol::HTTP2::HeadersFrame] The headers frame to process.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:70
+  def process_headers(frame); end
+
+  # Process trailing headers received after the body.
+  # @parameter headers [Array] The trailing header key-value pairs.
+  # @parameter end_stream [Boolean] Whether the stream ends after these headers.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:62
+  def receive_trailing_headers(headers, end_stream); end
+
+  # Set the body and begin sending it.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:157
+  def send_body(body, trailer = T.unsafe(nil)); end
+
+  # Send data and apply any pending application-side closure.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:202
+  def send_data(*, **, &); end
+
+  # Send headers and apply any pending application-side closure.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:195
+  def send_headers(*, **, &); end
+
+  # Update the local flow control window after receiving data.
+  # @parameter frame [Protocol::HTTP2::DataFrame] The received data frame.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:107
+  def update_local_window(frame); end
+
+  # @returns [Input | Nil] The input body for this stream, if available.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:91
+  def wait_for_input; end
+
+  # Called when the flow control window is updated.
+  # @parameter size [Integer] The new window size.
+  # @returns [Boolean] Always returns `true`.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:186
+  def window_updated(size); end
+
+  private
+
+  # If both application-facing directions are closed but the peer has not finished, terminate the remaining wire stream without an error.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/http2/stream.rb:244
+  def close_if_finished; end
+end
+
+# pkg:gem/async-http#lib/async/http/protocol/http2/connection.rb:28
+Async::HTTP::Protocol::HTTP2::TRAILER = T.let(T.unsafe(nil), String)
+
+# pkg:gem/async-http#lib/async/http/protocol/http2.rb:21
+Async::HTTP::Protocol::HTTP2::VERSION = T.let(T.unsafe(nil), String)
+
+# pkg:gem/async-http#lib/async/http/protocol/http.rb:17
+Async::HTTP::Protocol::HTTP::HTTP2_PREFACE = T.let(T.unsafe(nil), String)
+
+# pkg:gem/async-http#lib/async/http/protocol/http.rb:18
+Async::HTTP::Protocol::HTTP::HTTP2_PREFACE_SIZE = T.let(T.unsafe(nil), Integer)
+
+# A server that supports both HTTP1.0 and HTTP1.1 semantics by detecting the version of the request.
+#
+# pkg:gem/async-http#lib/async/http/protocol/https.rb:17
+class Async::HTTP::Protocol::HTTPS
+  extend ::Async::HTTP::Protocol::Defaulton
+
+  # Initialize the HTTPS protocol negotiator.
+  # @parameter handlers [Hash] A mapping of ALPN protocol names to protocol classes.
+  # @parameter options [Hash] Per-protocol options keyed by protocol class.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/https.rb:29
+  def initialize(handlers = T.unsafe(nil), **options); end
+
+  # Register a protocol handler for a given ALPN protocol name.
+  # @parameter name [String] The ALPN protocol name.
+  # @parameter protocol [Class] The protocol class to handle connections.
+  # @parameter options [Hash] Options to pass when creating client or server instances.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/https.rb:38
+  def add(name, protocol, **options); end
+
+  # Create a client for an outbound connection.
+  #
+  # @parameter peer [IO] The peer to communicate with.
+  # @parameter options [Hash] Options to pass to the client instance.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/https.rb:66
+  def client(peer, **options); end
+
+  # @returns [Array] The names of the supported protocol, used for Application Layer Protocol Negotiation (ALPN).
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/https.rb:85
+  def names; end
+
+  # Determine the protocol of the peer and return the appropriate protocol class.
+  #
+  # Use TLS Application Layer Protocol Negotiation (ALPN) to determine the protocol.
+  #
+  # @parameter peer [IO] The peer to communicate with.
+  # @returns [Class] The protocol class to use.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/https.rb:49
+  def protocol_for(peer); end
+
+  # Create a server for an inbound connection.
+  #
+  # @parameter peer [IO] The peer to communicate with.
+  # @parameter options [Hash] Options to pass to the server instance.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/https.rb:77
+  def server(peer, **options); end
+end
+
+# The protocol classes for each supported protocol.
+#
+# pkg:gem/async-http#lib/async/http/protocol/https.rb:19
+Async::HTTP::Protocol::HTTPS::HANDLERS = T.let(T.unsafe(nil), Hash)
+
+# An incoming HTTP request generated by server protocol implementations.
+#
+# pkg:gem/async-http#lib/async/http/protocol/request.rb:15
+class Async::HTTP::Protocol::Request < ::Protocol::HTTP::Request
+  # @returns [Connection | Nil] The underlying protocol connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/request.rb:17
+  def connection; end
+
+  # @returns [Boolean] Whether this request supports connection hijacking.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/request.rb:22
+  def hijack?; end
+
+  # @returns [String] A string representation of the request.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/request.rb:43
+  def inspect; end
+
+  # @returns [Protocol::HTTP::Peer | Nil] The peer associated with this connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/request.rb:33
+  def peer; end
+
+  # @returns [Addrinfo | Nil] The remote address of the peer.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/request.rb:38
+  def remote_address; end
+
+  # Write an interim (1xx) response back to the client.
+  # @parameter status [Integer] The interim HTTP status code.
+  # @parameter headers [Hash | Nil] Optional headers to include.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/request.rb:29
+  def write_interim_response(status, headers = T.unsafe(nil)); end
+end
+
+# An HTTP response received from a server via client protocol implementations.
+#
+# pkg:gem/async-http#lib/async/http/protocol/response.rb:14
+class Async::HTTP::Protocol::Response < ::Protocol::HTTP::Response
+  # @returns [Connection | Nil] The underlying protocol connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/response.rb:16
+  def connection; end
+
+  # @returns [Boolean] Whether this response supports connection hijacking.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/response.rb:21
+  def hijack?; end
+
+  # @returns [String] A string representation of the response.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/response.rb:36
+  def inspect; end
+
+  # @returns [Protocol::HTTP::Peer | Nil] The peer associated with this connection.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/response.rb:26
+  def peer; end
+
+  # @returns [Addrinfo | Nil] The remote address of the peer.
+  #
+  # pkg:gem/async-http#lib/async/http/protocol/response.rb:31
+  def remote_address; end
+end
+
+# pkg:gem/async-http#lib/async/http/body/writable.rb:12
+class Protocol::HTTP::Body::Writable < ::Protocol::HTTP::Body::Readable; end