cybrid_api_organization_ruby 0.129.1294 → 0.129.1296

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/lib/httpx/version.rb

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

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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
 

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/sig/connection.rbs

@@ -47,6 +47,7 @@ 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?
@@ -78,6 +79,8 @@ module HTTPX
 
     def merge: (Connection connection) -> void
 
+    def pending_count: () -> Integer
+
     def purge_pending: () { (Request request) -> void } -> void
 
     def connecting?: () -> bool
@@ -136,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
@@ -166,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
@@ -174,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
@@ -188,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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/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

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.9.0/sig/plugins/hedging.rbs

@@ -0,0 +1,44 @@
+module HTTPX
+  module Plugins
+    module Hedging
+      interface _HedgingOptions
+        def hedge_after: () -> (^(requestHedging request, Response response) -> interval | interval)?
+      end
+
+      module InstanceMethods
+        private
+
+        def hedge_connection: (connectionHedging connection) -> connectionHedging
+
+        def hedge_request!: (requestHedging request, connectionHedging connection, Selector selector) -> void
+
+        def when_to_hedge: (requestHedging request) -> interval?
+      end
+
+      module RequestMethods
+        attr_reader hedge_request: requestHedging?
+
+        @is_hedge_request: bool
+
+        def hedge_request=: (requestHedging? request) -> void
+      end
+
+      module ConnectionMethods
+        attr_reader hedge_connection: connectionHedging?
+
+        attr_accessor is_hedge_connection: bool
+
+        def hedge_connection=: (connectionHedging? connection) -> void
+
+        def try_yield_connection: [T] () { (connectionHedging) -> T } -> T
+      end
+    end
+    type optionsHedging = Options & Hedging::_HedgingOptions
+
+    type sessionHedging = Session & Hedging::InstanceMethods
+
+    type requestHedging = Request & Hedging::RequestMethods
+
+    type connectionHedging = Connection & Hedging::ConnectionMethods
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/sig/plugins/proxy/http.rbs

@@ -2,6 +2,11 @@ module HTTPX
   module Plugins
     module Proxy
       module HTTP
+        module OptionsMethods
+          def proxy_headers: () -> Headers?
+
+          def enable_proxy_tunnel: () -> bool?
+        end
 
         module InstanceMethods
           def with_proxy_basic_auth: (Hash[Symbol, untyped] opts) -> instance
@@ -14,7 +19,7 @@ module HTTPX
         module ConnectionMethods
           @tunnel_parser: Connection::HTTP1 | Connection::HTTP2
 
-          def __http_proxy_connect: (Connection::_Parser parser) ->  void
+          def __http_proxy_connect: () ->  void
           def __http_on_connect: (top, Response) ->  void
         end
 

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/sig/plugins/proxy.rbs

@@ -26,6 +26,7 @@ module HTTPX
 
         @ns: Integer
         @uris: Array[URI::Generic | String]
+        @initial_credentials: boolish
         @authenticator: _Authenticator
 
         def shift: () -> void
@@ -38,7 +39,7 @@ module HTTPX
 
         private
 
-        def initialize: (?uri: generic_uri | Array[generic_uri], ?scheme: String, ?username: String, ?password: String, ?no_proxy: Array[generic_uri] | generic_uri, **untyped) -> void
+        def initialize: (?uri: generic_uri | Array[generic_uri], ?ns: Integer, ?scheme: String?, ?username: String?, ?password: String?, ?no_proxy: Array[generic_uri] | generic_uri | nil, **untyped) -> void
 
         def infer_default_auth_scheme: (URI::Generic uri) -> String?
 
@@ -58,7 +59,7 @@ module HTTPX
       end
 
       module InstanceMethods
-        @__proxy_uris: Array[generic_uri]
+        @proxy_parameters: Parameters?
 
         private
 

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/sig/plugins/retries.rbs

@@ -45,11 +45,11 @@ module HTTPX
 
         def try_partial_retry: (retriesRequest request, retriesResponse response) -> void
 
-        def prepare_to_retry: (retriesRequest request, retriesResponse response) -> void
+        def prepare_to_retry: (retriesRequest request, retriesResponse response, interval? retry_after) -> void
 
         def can_reconnect?: (retriesRequest request, retriesResponse response) -> bool
 
-        def when_to_retry: (retriesRequest request, retriesResponse response, retriesOptions options) -> Numeric?
+        def when_to_retry: (retriesRequest request, retriesResponse response, retriesOptions options) -> interval?
       end
 
       module RequestMethods

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/sig/plugins/tracing.rbs

@@ -2,13 +2,13 @@ module HTTPX
   module Plugins
     module Tracing
       interface _Tracer
-        def enabled?: (retriesRequest request) -> boolish
+        def enabled?: (tracingRequest request) -> boolish
 
-        def start: (retriesRequest request) -> void
+        def start: (tracingRequest request) -> void
 
-        def reset: (retriesRequest request) -> void
+        def reset: (tracingRequest request) -> void
 
-        def finish: (retriesRequest request, response response) -> void
+        def finish: (tracingRequest request, response response) -> void
       end
 
       class Wrapper
@@ -27,13 +27,22 @@ module HTTPX
 
       module RequestMethods
         attr_accessor init_time: Time?
+
+        attr_accessor handshake_time: Float?
       end
 
       module ConnectionMethods
         @init_time: Time?
       end
 
-      type retriesRequest = Request & RequestMethods
+      module HTTP2Methods
+        @handshake_time: Float?
+        @handshake_init_time: Time
+
+        def send: (tracingRequest request, ?bool head) -> bool
+      end
+
+      type tracingRequest = Request & RequestMethods
     end
 
     type sessionTracing = Session

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/sig/request/body.rbs

@@ -4,7 +4,7 @@ module HTTPX
 
     @headers: Headers
     @body: body_encoder?
-    @unbounded_body: bool
+    @unbounded_body: bool?
 
     def initialize: (Headers h, Options options, **untyped) -> void