httpx 1.8.3 → 1.9.0

data/lib/httpx/response.rb

@@ -119,7 +119,6 @@ module HTTPX
     # marks the response as finished, freezes the headers.
     def finish!
       @finished = true
-      @headers.freeze
       @request.connection = nil
     end
 
@@ -176,8 +175,8 @@ module HTTPX
     #
     #   response.json #≈> { "foo" => "bar" } for "{\"foo\":\"bar\"}" payload
     #   response.json(symbolize_names: true) #≈> { foo: "bar" } for "{\"foo\":\"bar\"}" payload
-    def json(*args)
-      decode(Transcoder::JSON, *args)
+    def json(...)
+      decode(Transcoder::JSON, ...)
     end
 
     # decodes the response payload into a ruby object **if** the payload is valid
@@ -200,7 +199,7 @@ module HTTPX
     #
     # +transcoder+ must implement the internal transcoder API, i.e. respond to <tt>decode(HTTPX::Response response)</tt>,
     # which returns a decoder which responds to <tt>call(HTTPX::Response response, **kwargs)</tt>
-    def decode(transcoder, *args)
+    def decode(transcoder, ...)
       # TODO: check if content-type is a valid format, i.e. "application/json" for json parsing
 
       decoder = transcoder.decode(self)
@@ -209,14 +208,13 @@ module HTTPX
 
       @body.rewind
 
-      decoder.call(self, *args)
+      decoder.call(self, ...)
     end
   end
 
   # Helper class which decodes the HTTP "content-type" header.
   class ContentType
-    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}.freeze
-    CHARSET_RE   = /;\s*charset=([^;]+)/i.freeze
+    SPLIT_PATTERN = /[;,]/.freeze
 
     def initialize(header_value)
       @header_value = header_value
@@ -250,11 +248,21 @@ module HTTPX
     private
 
     def load
-      m = @header_value.to_s[MIME_TYPE_RE, 1]
-      m && @mime_type = m.strip.downcase
+      if @header_value && !@header_value.empty?
+        m, c = @header_value.split(SPLIT_PATTERN, 2)
 
-      c = @header_value.to_s[CHARSET_RE, 1]
-      c && @charset = c.strip.delete('"')
+        if m
+          @mime_type = m.strip
+          @mime_type.downcase
+        end
+
+        if c
+          c.strip!
+          c.delete_prefix!("charset=")
+          c = c[1..-2] if c.start_with?('"') && c.end_with?('"')
+          @charset = c
+        end
+      end
 
       @initialized = true
     end

data/lib/httpx/selector.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "io/wait"
+require "io/wait" if RUBY_VERSION < "3.2.0"
 
 module HTTPX
   #
@@ -68,9 +68,9 @@ module HTTPX
       end
     end
 
-    def terminate
+    def terminate(selectables = nil)
       # array may change during iteration
-      selectables = @selectables.reject(&:inflight?)
+      selectables ||= @selectables.reject(&:inflight?)
 
       selectables.delete_if do |sel|
         sel.terminate

data/lib/httpx/session.rb

@@ -46,7 +46,7 @@ module HTTPX
       ensure
         unless prev_wrapped
           if @persistent
-            deactivate(current_selector)
+            deactivate(current_selector, $ERROR_INFO)
           else
             close(current_selector)
           end
@@ -143,7 +143,7 @@ module HTTPX
       # do not check-in connections only created for Happy Eyeballs
       return if cloned
 
-      return if @closing && connection.state == :closed && !connection.used?
+      return unless can_checkin?(connection)
 
       connection.log(level: 2) { "check-in connection##{connection.object_id}(#{connection.state}) in pool##{@pool.object_id}" }
       @pool.checkin_connection(connection)
@@ -211,18 +211,33 @@ module HTTPX
 
     private
 
-    def selector_close(selector)
+    def can_checkin?(connection)
+      !@closing || connection.state != :closed || connection.used?
+    end
+
+    def selector_close(selector, ...)
       begin
         @closing = true
-        selector.terminate
+        selector.terminate(...)
       ensure
         @closing = false
       end
     end
 
     # tries deactivating connections in the +selector+, deregistering the ones that have been deactivated.
-    def deactivate(selector)
-      selector.each_connection.to_a.each(&:deactivate)
+    def deactivate(selector, error = nil)
+      selector.each_connection.to_a.each do |connection|
+        if (pending_count = connection.pending_count).positive?
+          warn "connection deactivated with pending requests, " \
+               "please report this https://gitlab.com/os85/httpx/-/work_items " \
+               "along with debug logs\n(" \
+               "state:#{connection.state},pending:#{pending_count}," \
+               "connection-pending:#{connection.pending.size}," \
+               "deactivate-on-error:#{error&.detailed_message}," \
+               ")"
+        end
+        connection.deactivate
+      end
     end
 
     # callback executed when an HTTP/2 promise frame has been received.
@@ -242,13 +257,18 @@ module HTTPX
       response
     end
 
-    # sends the +request+ to the corresponding HTTPX::Connection
-    def send_request(request, selector, options = request.options)
+    # sends the +request+ to a suitable HTTPX::Connection, which gets yielded if a block is passed.
+    def send_request(request, selector, options = request.options, &blk)
       error = begin
         catch(:resolve_error) do
           log(level: 2) { "finding connection for request##{request.object_id}..." }
           connection = find_connection(request.uri, selector, options)
-          connection.send(request)
+          yield(connection) if blk
+          do_request(
+            request,
+            connection,
+            selector
+          )
         end
       rescue StandardError => e
         e
@@ -262,6 +282,10 @@ module HTTPX
       request.emit_response(response)
     end
 
+    def do_request(request, connection, _)
+      connection.send(request)
+    end
+
     # returns a set of HTTPX::Request objects built from the given +args+ and +options+.
     def build_requests(*args, params)
       requests = if args.size == 1
@@ -269,6 +293,7 @@ module HTTPX
         reqs.map do |verb, uri, ps = EMPTY_HASH|
           request_params = params
           request_params = request_params.merge(ps) unless ps.empty?
+          request_params = request_params.dup unless request_params.empty? && reqs.size == 1
           build_request(verb, uri, request_params)
         end
       else
@@ -277,6 +302,7 @@ module HTTPX
           uris.enum_for(:each).map do |uri, ps = EMPTY_HASH|
             request_params = params
             request_params = request_params.merge(ps) unless ps.empty?
+            request_params = request_params.dup unless request_params.empty? && uris.size == 1
             build_request(verb, uri, request_params)
           end
         else
@@ -304,7 +330,7 @@ module HTTPX
       ensure
         unless @wrapped
           if @persistent
-            deactivate(selector)
+            deactivate(selector, $ERROR_INFO)
           else
             close(selector)
           end
@@ -355,7 +381,8 @@ module HTTPX
           # making the next loop cheaper (because we're dropping).
           next unless response
 
-          request.complete!(response)
+          next unless request.complete!(response)
+
           responses[idx] = response
           request.on_response_arrived = nil
           pending -= 1

data/lib/httpx/transcoder/chunker.rb

@@ -24,8 +24,8 @@ module HTTPX::Transcoder
         yield "0#{CRLF}"
       end
 
-      def respond_to_missing?(meth, *args)
-        @raw.respond_to?(meth, *args) || super
+      def respond_to_missing?(...)
+        @raw.respond_to?(...) || super
       end
     end
 

data/lib/httpx/transcoder/json.rb

@@ -53,18 +53,18 @@ module HTTPX::Transcoder
 
     # rubocop:disable-next Style/SingleLineMethods
     if defined?(MultiJson)
-      def json_load(*args); MultiJson.load(*args); end
-      def json_dump(*args); MultiJson.dump(*args); end
+      def json_load(...); MultiJson.load(...); end
+      def json_dump(...); MultiJson.dump(...); end
     elsif defined?(Oj)
-      def json_load(response, *args); Oj.load(response.to_s, *args); end
+      def json_load(response, ...); Oj.load(response.to_s, ...); end
       def json_dump(obj, options = {}); Oj.dump(obj, { mode: :compat }.merge(options)); end
     elsif defined?(Yajl)
-      def json_load(response, *args); Yajl::Parser.new(*args).parse(response.to_s); end
-      def json_dump(*args); Yajl::Encoder.encode(*args); end
+      def json_load(response, ...); Yajl::Parser.new(...).parse(response.to_s); end
+      def json_dump(...); Yajl::Encoder.encode(...); end
     else
       require "json"
-      def json_load(*args); ::JSON.parse(*args); end
-      def json_dump(*args); ::JSON.generate(*args); end
+      def json_load(...); ::JSON.parse(...); end
+      def json_dump(...); ::JSON.generate(...); end
     end
   end
 end

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "1.8.3"
+  VERSION = "1.9.0"
 end

data/sig/altsvc.rbs

@@ -31,11 +31,11 @@ module HTTPX
 
     def self?.emit: (Request request, response response) { (http_uri alt_origin, String origin, altsvc_params alt_params) -> void } -> void
 
-    def self?.parse: (String altsvc) { (http_uri alt_origin, altsvc_params alt_params) -> void } -> void
-                   | (String altsvc) -> Enumerable[[http_uri, altsvc_params]]
+    def self?.parse: (String altsvc, ?host: String?) { (http_uri alt_origin, altsvc_params alt_params) -> void } -> void
+                   | (String altsvc, ?host: String?) -> Enumerable[[http_uri, altsvc_params]]
 
     def self?.parse_altsvc_scheme: (String alt_proto) -> String?
 
-    def self.parse_altsvc_origin: (string alt_proto, String alt_origin) -> http_uri?
+    def self.parse_altsvc_origin: (string alt_proto, String alt_origin, ?host: String?) -> http_uri?
   end
 end

data/sig/callbacks.rbs

@@ -4,6 +4,7 @@ module HTTPX
   end
 
   module Callbacks
+    @callbacks: Hash[Symbol, Array[_Callable]]?
     def on: (Symbol) { (*untyped) -> void } -> ^(*untyped) -> void
     def once: (Symbol) { (*untyped) -> void } -> ^(*untyped) -> void
     def emit: (Symbol, *untyped) -> void

data/sig/chainable.rbs

@@ -47,6 +47,7 @@ module HTTPX
               | (:xml, ?options) -> Plugins::sessionXML
               | (:query, ?options) -> Plugins::sessionQuery
               | (:tracing, ?options) -> Plugins::sessionTracing
+              | (:hedging, ?options) -> Plugins::sessionHedging
               | (Symbol | Module, ?options) { (Class) -> void } -> Session
               | (Symbol | Module, ?options) -> Session
 

data/sig/connection/http1.rbs

@@ -36,7 +36,7 @@ module HTTPX
 
     def <<: (string) -> void
 
-    def send: (Request) -> void
+    def send: (Request request, ?bool head) -> void
 
     def consume: () -> void
 

data/sig/connection/http2.rbs

@@ -5,7 +5,7 @@ module HTTPX
 
     MAX_CONCURRENT_REQUESTS: Integer
 
-    attr_reader streams: Hash[Request, ::HTTP2::Stream]
+    attr_reader streams: Hash[Request, HTTP2::Stream]
 
     attr_reader pending: Array[Request]
 
@@ -14,7 +14,7 @@ module HTTPX
     @settings: Hash[Symbol, Integer | bool]
     @max_concurrent_requests: Integer
     @max_requests: Integer
-    @drains: Hash[Request, String]
+    @drains: Hash[HTTP2::Stream, String]
     @pings: Array[String]
     @streams_to_close_after_receive: Array[[HTTP2::Stream, Request, HTTPX::Error]]
     @buffer: Buffer
@@ -57,35 +57,35 @@ module HTTPX
 
     def set_protocol_headers: (Request) -> _Each[[String, String]]
 
-    def handle: (Request request, ::HTTP2::Stream stream) -> void
+    def handle: (Request request, HTTP2::Stream stream) -> void
 
     def init_connection: () -> void
 
-    def handle_stream: (::HTTP2::Stream stream, Request request) -> void
+    def handle_stream: (HTTP2::Stream stream, Request request) -> void
 
     def join_headline: (Request request) -> String
 
-    def join_headers: (::HTTP2::Stream stream, Request request) -> void
+    def join_headers: (HTTP2::Stream stream, Request request) -> void
 
-    def join_trailers: (::HTTP2::Stream stream, Request request) -> void
+    def join_trailers: (HTTP2::Stream stream, Request request) -> void
 
-    def join_body: (::HTTP2::Stream stream, Request request) -> void
+    def join_body: (HTTP2::Stream stream, Request request) -> void
 
-    def send_chunk: (Request request, ::HTTP2::Stream stream, String chunk, String? next_chunk) -> void
+    def send_chunk: (Request request, HTTP2::Stream stream, String chunk, String? next_chunk) -> void
 
     def end_stream?: (Request request, String? next_chunk) -> void
 
-    def on_stream_headers: (::HTTP2::Stream stream, Request request, Array[[String, String]] headers) -> void
+    def on_stream_headers: (HTTP2::Stream stream, Request request, Array[[String, String]] headers) -> void
 
-    def on_stream_trailers: (::HTTP2::Stream stream, Request request, Response response, Array[[String, String]] headers) -> void
+    def on_stream_trailers: (HTTP2::Stream stream, Request request, Response response, Array[[String, String]] headers) -> void
 
-    def on_stream_data: (::HTTP2::Stream stream, Request request, String data) -> void
+    def on_stream_data: (HTTP2::Stream stream, Request request, String data) -> void
 
-    def on_stream_refuse: (::HTTP2::Stream stream, Request request, StandardError error) -> void
+    def on_stream_refuse: (HTTP2::Stream stream, Request request, StandardError error) -> void
 
-    def on_stream_half_close: (::HTTP2::Stream stream, Request request) -> void
+    def on_stream_half_close: (HTTP2::Stream stream, Request request) -> void
 
-    def on_stream_close: (::HTTP2::Stream stream, Request request, (Symbol | StandardError)? error) -> void
+    def on_stream_close: (HTTP2::Stream stream, Request request, (Symbol | StandardError)? error) -> void
 
     def on_frame: (string bytes) -> void
 
@@ -101,7 +101,7 @@ module HTTPX
 
     def on_altsvc: (String origin, ::HTTP2::frame frame) -> void
 
-    def on_promise: (::HTTP2::Stream stream) -> void
+    def on_promise: (HTTP2::Stream stream) -> void
 
     def on_origin: (String) -> void
 
@@ -116,11 +116,25 @@ module HTTPX
     end
 
     class GoawayError < Error
-      def initialize: (?Symbol code) -> void
+      UNRECOVERABLE_ERRORS: Array[Symbol]
+
+      @code: Symbol
+
+      def initialize: (Symbol code, Integer last_stream_id) -> void
+
+      def last_stream_id: () -> Numeric
+
+      def unrecoverable?: () -> bool
     end
 
     class PingError < Error
       def initialize: () -> void
     end
+
+    class RstStreamError < Error
+    end
+
+    class RefusedStreamError < Error
+    end
   end
 end

data/sig/connection.rbs

@@ -47,6 +47,8 @@ module HTTPX
     @response_received_at: Float
     @exhausted: bool
     @cloned: bool
+    @reset_timeout_on_call: bool
+    @previously_exhausted_with_error: bool
     @coalesced_connection: instance?
     @altsvc_connection: instance?
     @sibling: instance?
@@ -77,6 +79,8 @@ module HTTPX
 
     def merge: (Connection connection) -> void
 
+    def pending_count: () -> Integer
+
     def purge_pending: () { (Request request) -> void } -> void
 
     def connecting?: () -> bool
@@ -135,6 +139,8 @@ module HTTPX
 
     def initialize_type: (http_uri uri, Options options) -> io_type
 
+    def try_connect: () -> void
+
     def connect: () -> void
 
     def exhausted?: () -> boolish
@@ -165,6 +171,8 @@ module HTTPX
 
     def pong: () -> void
 
+    def no_more_selector_check: () -> void
+
     def no_more_requests_loop_check: () -> void
 
     def no_more_requests?: () -> bool
@@ -173,12 +181,16 @@ module HTTPX
 
     def force_purge: () -> void
 
+    def reset_ping_timer: () -> void
+
     def close_sibling: () -> void
 
     def purge_after_closed: () -> void
 
     def set_request_timeouts: (Request request) -> void
 
+    def set_connection_timeouts: (Request request) -> void
+
     def set_request_read_timeout: (Request request) -> void
 
     def set_request_write_timeout: (Request request) -> void
@@ -187,12 +199,18 @@ module HTTPX
 
     def set_request_total_request_timeout: (Request request) -> void
 
-    def write_timeout_callback: (Request request, Numeric timeout) -> void
+    def write_timeout_callback: (Request request, interval timeout) -> void
 
     def read_timeout_callback: (Request request, interval timeout, ?singleton(RequestTimeoutError) error_type) -> void
 
     def set_request_timeout: (Symbol label, Request request, interval timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
 
+    def set_connecting_request_timeout: (Request request) -> void
+
+    def set_connecting_total_request_timeout: (Request request) -> void
+
+    def set_connection_timeout: (Symbol label, Request request, interval timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
+
     def parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
   end
 end

data/sig/headers.rbs

@@ -17,7 +17,7 @@ module HTTPX
     def each: (?_Each[[String, String]]? extra_headers) { (String k, String v) -> void } -> void
             | (?_Each[[String, String]]? extra_headers) -> Enumerable[[String, String]]
 
-    def get: (String field) -> Array[_ToS]
+    def get: (String downcased_key) -> Array[_ToS]
     def key?: (String downcased_key) -> bool
 
     def merge: (_Each[[String, headers_value]] other) -> Headers

data/sig/httpx.rbs

@@ -18,6 +18,8 @@ module HTTPX
 
   type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
 
+  type resolver = Resolver::Multi | Resolver::Resolver
+
   module Plugins
     self.@plugins: Hash[Symbol, Module]
     self.@plugins_mutex: Thread::Mutex

data/sig/options.rbs

@@ -10,9 +10,6 @@ module HTTPX
     CONNECT_TIMEOUT: Integer
     READ_TIMEOUT: Integer
     WRITE_TIMEOUT: Integer
-    REQUEST_TIMEOUT: Integer
-    TOTAL_REQUEST_TIMEOUT: Integer
-    OPERATION_TIMEOUT: Integer
     KEEP_ALIVE_TIMEOUT: Integer
     PING_TIMEOUT: Integer
     SETTINGS_TIMEOUT: Integer
@@ -26,22 +23,21 @@ module HTTPX
     USER_AGENT: String
 
     type timeout_type = :connect_timeout | :settings_timeout | :close_handshake_timeout | :operation_timeout | :keep_alive_timeout | :read_timeout | :write_timeout | :total_request_timeout | :request_timeout | :ping_timeout
-    type timeout = Hash[timeout_type, interval?]
     type redact_value = :headers | :body | bool
     type resolver_cache_option = :memory | :file | (Object & Resolver::_Cache)
 
     def self.new: (?options) -> instance
 
-    attr_reader self.options_names: Array[Symbol]
+    attr_reader self.options_names: Set[Symbol]
 
     # headers
     attr_reader uri: URI?
 
     # headers
-    attr_reader headers: headers?
+    attr_reader headers: headers
 
     # timeout
-    attr_reader timeout: timeout
+    attr_reader timeout: Timeouts
 
     # http2_settings
     attr_reader http2_settings: Hash[Symbol, Integer | bool]
@@ -74,7 +70,7 @@ module HTTPX
     attr_reader transport: io_type | nil
 
     # addresses
-    attr_reader addresses: Array[Resolver::Entry]?
+    attr_reader addresses: (Hash[String, Array[Resolver::Entry]] | Array[Resolver::Entry])?
 
     # supported_compression_formats
     attr_reader supported_compression_formats: Array[String]
@@ -174,8 +170,6 @@ module HTTPX
 
     def do_initialize: () -> void
 
-    def access_option: (Hash[Symbol, untyped] | Object | nil obj, Symbol k, Hash[Symbol, Symbol]? ivar_map) -> untyped
-
     # integer
     def option_max_concurrent_requests: (int value) -> maybe_unbounded
     def option_max_requests: (int value) -> maybe_unbounded
@@ -217,15 +211,52 @@ module HTTPX
 
     def option_headers: (headers_input | Headers value) -> Headers
 
-    def option_timeout: (_ToHash[timeout_type, interval?]) -> timeout
+    def option_timeout: (Timeouts | _ToHash[timeout_type, interval?]) -> Timeouts
 
     def option_supported_compression_formats: (_ToS | _ToAry[_ToS] value) -> Array[String]
 
     def option_transport: (_ToS value) -> String
 
-    def option_addresses: (ipaddr | _ToAry[ipaddr] value) -> Array[ipaddr]
+    def option_addresses: (ipaddr | _ToAry[ipaddr] value) -> Array[Resolver::Entry]
+                        | (Hash[String,  _ToAry[ipaddr]] value) -> Hash[String, Array[Resolver::Entry]]
 
     def option_ip_families: (ip_family | _ToAry[ip_family] value) -> Array[ip_family]
+
+    class Timeouts
+      attr_reader connect_timeout: interval?
+      attr_reader settings_timeout: interval?
+      attr_reader read_timeout: interval?
+      attr_reader write_timeout: interval?
+      attr_reader request_timeout: interval?
+      attr_reader total_request_timeout: interval?
+      attr_reader operation_timeout: interval?
+      attr_reader close_handshake_timeout: interval
+      attr_reader keep_alive_timeout: interval
+      attr_reader ping_timeout: interval
+
+      def initialize: (
+        ?connect_timeout: interval?,
+        ?settings_timeout: interval?,
+        ?read_timeout: interval?,
+        ?write_timeout: interval?,
+        ?request_timeout: interval?,
+        ?total_request_timeout: interval?,
+        ?operation_timeout: interval?,
+        ?close_handshake_timeout: interval?,
+        ?keep_alive_timeout: interval?,
+        ?ping_timeout: interval?
+      ) -> void
+
+      def merge: (Timeouts | Hash[Symbol, interval?]) -> Timeouts
+
+      def []: (Symbol) -> interval?
+
+      def to_h: () -> Hash[Symbol, interval?]
+
+      private
+
+      def deadline_timeouts?: () -> boolish
+    end
   end
 
   type options = Options | Hash[Symbol, untyped]

data/sig/parser/http1.rbs

@@ -18,7 +18,7 @@ module HTTPX
       VERSIONS: Array[String]
 
       attr_reader status_code: Integer
-      attr_reader http_version: [Integer, Integer]
+      attr_reader http_version: String
       attr_reader headers: parsed_headers
 
       @observer: _HTTP1Events

data/sig/plugins/auth/digest.rbs

@@ -8,7 +8,6 @@ module HTTPX
         @user: String
         @password: String
         @hashed: bool
-        @nonce: Integer
 
         def can_authenticate?: (String? authenticate) -> boolish
 

data/sig/plugins/auth.rbs

@@ -1,14 +1,14 @@
 module HTTPX
   module Plugins
     module Auth
-      type auth_header_value_type = String | ^(?Request request, ?bool should_regenerate) -> string
+      type auth_header_value_type = String | ^(?requestAuth request, ?bool should_regenerate) -> string
 
       interface _AuthOptions
         def auth_header_value: () -> auth_header_value_type?
 
         def auth_header_type: () -> String?
 
-        def auth_header_expires_at: () -> (^(Request request) -> _ToF?)?
+        def auth_header_expires_at: () -> (^(requestAuth request) -> _ToF?)?
 
         def auth_header_expires_in: () -> Float?
       end
@@ -17,10 +17,11 @@ module HTTPX
         @auth_header_value: String?
         @auth_header_value_mtx: Thread::Mutex
         @skip_auth_header_value: bool
+        @auth_header_expires_at: interval?
 
-        def authorization: (?string token, ?auth_header_type: string) ?{ (?Request, ?bool) -> string } -> instance
+        def authorization: (?string token, ?auth_header_type: string) ?{ (?requestAuth, ?bool) -> string } -> instance
 
-        def bearer_auth: (?string token) ?{ (Request) -> string } -> instance
+        def bearer_auth: (?string token) ?{ (requestAuth) -> string } -> instance
 
         def skip_auth_header: [T] { () -> T } -> T
 
@@ -28,7 +29,11 @@ module HTTPX
 
         private
 
-        def generate_auth_token: (Request & RequestMethods request, bool should_regenerate) -> String?
+        def generate_auth_token: (requestAuth request, bool should_regenerate) -> String?
+
+        def try_invalidate_auth_header_value: () -> void
+
+        def set_auth_header_expires_at: (requestAuth request) -> void
 
         def dynamic_auth_token?: (auth_header_value_type auth_header_value) -> boolish
       end
@@ -52,6 +57,8 @@ module HTTPX
           def auth_error?: (response response, Options options) -> boolish
         end
       end
+
+      type requestAuth = Request & RequestMethods
     end
 
     type sessionAuth = Session & Auth::InstanceMethods