JezK

Edit File: net-http.rbs

module Net
  class Protocol
    VERSION: String
  end

class ProtocolError < StandardError
  end

class ProtoSyntaxError < ProtocolError
  end

class ProtoFatalError < ProtocolError
  end

class ProtoUnknownError < ProtocolError
  end

class ProtoServerError < ProtocolError
  end

class ProtoAuthError < ProtocolError
  end

class ProtoCommandError < ProtocolError
  end

class ProtoRetriableError < ProtocolError
  end

class HTTPBadResponse < StandardError
  end

class HTTPHeaderSyntaxError < StandardError
  end

# 
  # ## An HTTP client API for Ruby.
  #
  # Net::HTTP provides a rich library which can be used to build HTTP user-agents.
  #  For more details about HTTP see
  # [RFC2616](http://www.ietf.org/rfc/rfc2616.txt).
  #
  # Net::HTTP is designed to work closely with URI.  URI::HTTP#host,
  # URI::HTTP#port and URI::HTTP#request_uri are designed to work with Net::HTTP.
  #
  # If you are only performing a few GET requests you should try OpenURI.
  #
  # ## Simple Examples
  #
  # All examples assume you have loaded Net::HTTP with:
  #
  #     require 'net/http'
  #
  # This will also require 'uri' so you don't need to require it separately.
  #
  # The Net::HTTP methods in the following section do not persist connections.
  # They are not recommended if you are performing many HTTP requests.
  #
  # ### GET
  #
  #     Net::HTTP.get('example.com', '/index.html') # => String
  #
  # ### GET by URI
  #
  #     uri = URI('http://example.com/index.html?count=10')
  #     Net::HTTP.get(uri) # => String
  #
  # ### GET with Dynamic Parameters
  #
  #     uri = URI('http://example.com/index.html')
  #     params = { :limit => 10, :page => 3 }
  #     uri.query = URI.encode_www_form(params)
  #
  #     res = Net::HTTP.get_response(uri)
  #     puts res.body if res.is_a?(Net::HTTPSuccess)
  #
  # ### POST
  #
  #     uri = URI('http://www.example.com/search.cgi')
  #     res = Net::HTTP.post_form(uri, 'q' => 'ruby', 'max' => '50')
  #     puts res.body
  #
  # ### POST with Multiple Values
  #
  #     uri = URI('http://www.example.com/search.cgi')
  #     res = Net::HTTP.post_form(uri, 'q' => ['ruby', 'perl'], 'max' => '50')
  #     puts res.body
  #
  # ## How to use Net::HTTP
  #
  # The following example code can be used as the basis of an HTTP user-agent
  # which can perform a variety of request types using persistent connections.
  #
  #     uri = URI('http://example.com/some_path?query=string')
  #
  #     Net::HTTP.start(uri.host, uri.port) do |http|
  #       request = Net::HTTP::Get.new uri
  #
  #       response = http.request request # Net::HTTPResponse object
  #     end
  #
  # Net::HTTP::start immediately creates a connection to an HTTP server which is
  # kept open for the duration of the block.  The connection will remain open for
  # multiple requests in the block if the server indicates it supports persistent
  # connections.
  #
  # If you wish to re-use a connection across multiple HTTP requests without
  # automatically closing it you can use ::new and then call #start and #finish
  # manually.
  #
  # The request types Net::HTTP supports are listed below in the section "HTTP
  # Request Classes".
  #
  # For all the Net::HTTP request objects and shortcut request methods you may
  # supply either a String for the request path or a URI from which Net::HTTP will
  # extract the request path.
  #
  # ### Response Data
  #
  #     uri = URI('http://example.com/index.html')
  #     res = Net::HTTP.get_response(uri)
  #
  #     # Headers
  #     res['Set-Cookie']            # => String
  #     res.get_fields('set-cookie') # => Array
  #     res.to_hash['set-cookie']    # => Array
  #     puts "Headers: #{res.to_hash.inspect}"
  #
  #     # Status
  #     puts res.code       # => '200'
  #     puts res.message    # => 'OK'
  #     puts res.class.name # => 'HTTPOK'
  #
  #     # Body
  #     puts res.body if res.response_body_permitted?
  #
  # ### Following Redirection
  #
  # Each Net::HTTPResponse object belongs to a class for its response code.
  #
  # For example, all 2XX responses are instances of a Net::HTTPSuccess subclass, a
  # 3XX response is an instance of a Net::HTTPRedirection subclass and a 200
  # response is an instance of the Net::HTTPOK class.  For details of response
  # classes, see the section "HTTP Response Classes" below.
  #
  # Using a case statement you can handle various types of responses properly:
  #
  #     def fetch(uri_str, limit = 10)
  #       # You should choose a better exception.
  #       raise ArgumentError, 'too many HTTP redirects' if limit == 0
  #
  #       response = Net::HTTP.get_response(URI(uri_str))
  #
  #       case response
  #       when Net::HTTPSuccess then
  #         response
  #       when Net::HTTPRedirection then
  #         location = response['location']
  #         warn "redirected to #{location}"
  #         fetch(location, limit - 1)
  #       else
  #         response.value
  #       end
  #     end
  #
  #     print fetch('http://www.ruby-lang.org')
  #
  # ### POST
  #
  # A POST can be made using the Net::HTTP::Post request class.  This example
  # creates a URL encoded POST body:
  #
  #     uri = URI('http://www.example.com/todo.cgi')
  #     req = Net::HTTP::Post.new(uri)
  #     req.set_form_data('from' => '2005-01-01', 'to' => '2005-03-31')
  #
  #     res = Net::HTTP.start(uri.hostname, uri.port) do |http|
  #       http.request(req)
  #     end
  #
  #     case res
  #     when Net::HTTPSuccess, Net::HTTPRedirection
  #       # OK
  #     else
  #       res.value
  #     end
  #
  # To send multipart/form-data use Net::HTTPHeader#set_form:
  #
  #     req = Net::HTTP::Post.new(uri)
  #     req.set_form([['upload', File.open('foo.bar')]], 'multipart/form-data')
  #
  # Other requests that can contain a body such as PUT can be created in the same
  # way using the corresponding request class (Net::HTTP::Put).
  #
  # ### Setting Headers
  #
  # The following example performs a conditional GET using the If-Modified-Since
  # header.  If the files has not been modified since the time in the header a Not
  # Modified response will be returned.  See RFC 2616 section 9.3 for further
  # details.
  #
  #     uri = URI('http://example.com/cached_response')
  #     file = File.stat 'cached_response'
  #
  #     req = Net::HTTP::Get.new(uri)
  #     req['If-Modified-Since'] = file.mtime.rfc2822
  #
  #     res = Net::HTTP.start(uri.hostname, uri.port) {|http|
  #       http.request(req)
  #     }
  #
  #     open 'cached_response', 'w' do |io|
  #       io.write res.body
  #     end if res.is_a?(Net::HTTPSuccess)
  #
  # ### Basic Authentication
  #
  # Basic authentication is performed according to
  # [RFC2617](http://www.ietf.org/rfc/rfc2617.txt).
  #
  #     uri = URI('http://example.com/index.html?key=value')
  #
  #     req = Net::HTTP::Get.new(uri)
  #     req.basic_auth 'user', 'pass'
  #
  #     res = Net::HTTP.start(uri.hostname, uri.port) {|http|
  #       http.request(req)
  #     }
  #     puts res.body
  #
  # ### Streaming Response Bodies
  #
  # By default Net::HTTP reads an entire response into memory.  If you are
  # handling large files or wish to implement a progress bar you can instead
  # stream the body directly to an IO.
  #
  #     uri = URI('http://example.com/large_file')
  #
  #     Net::HTTP.start(uri.host, uri.port) do |http|
  #       request = Net::HTTP::Get.new uri
  #
  #       http.request request do |response|
  #         open 'large_file', 'w' do |io|
  #           response.read_body do |chunk|
  #             io.write chunk
  #           end
  #         end
  #       end
  #     end
  #
  # ### HTTPS
  #
  # HTTPS is enabled for an HTTP connection by Net::HTTP#use_ssl=.
  #
  #     uri = URI('https://secure.example.com/some_path?query=string')
  #
  #     Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
  #       request = Net::HTTP::Get.new uri
  #       response = http.request request # Net::HTTPResponse object
  #     end
  #
  # Or if you simply want to make a GET request, you may pass in an URI object
  # that has an HTTPS URL. Net::HTTP automatically turns on TLS verification if
  # the URI object has a 'https' URI scheme.
  #
  #     uri = URI('https://example.com/')
  #     Net::HTTP.get(uri) # => String
  #
  # In previous versions of Ruby you would need to require 'net/https' to use
  # HTTPS. This is no longer true.
  #
  # ### Proxies
  #
  # Net::HTTP will automatically create a proxy from the `http_proxy` environment
  # variable if it is present.  To disable use of `http_proxy`, pass `nil` for the
  # proxy address.
  #
  # You may also create a custom proxy:
  #
  #     proxy_addr = 'your.proxy.host'
  #     proxy_port = 8080
  #
  #     Net::HTTP.new('example.com', nil, proxy_addr, proxy_port).start { |http|
  #       # always proxy via your.proxy.addr:8080
  #     }
  #
  # See Net::HTTP.new for further details and examples such as proxies that
  # require a username and password.
  #
  # ### Compression
  #
  # Net::HTTP automatically adds Accept-Encoding for compression of response
  # bodies and automatically decompresses gzip and deflate responses unless a
  # Range header was sent.
  #
  # Compression can be disabled through the Accept-Encoding: identity header.
  #
  # ## HTTP Request Classes
  #
  # Here is the HTTP request class hierarchy.
  #
  # *   Net::HTTPRequest
  #     *   Net::HTTP::Get
  #     *   Net::HTTP::Head
  #     *   Net::HTTP::Post
  #     *   Net::HTTP::Patch
  #     *   Net::HTTP::Put
  #     *   Net::HTTP::Proppatch
  #     *   Net::HTTP::Lock
  #     *   Net::HTTP::Unlock
  #     *   Net::HTTP::Options
  #     *   Net::HTTP::Propfind
  #     *   Net::HTTP::Delete
  #     *   Net::HTTP::Move
  #     *   Net::HTTP::Copy
  #     *   Net::HTTP::Mkcol
  #     *   Net::HTTP::Trace
  #
  #
  #
  # ## HTTP Response Classes
  #
  # Here is HTTP response class hierarchy.  All classes are defined in Net module
  # and are subclasses of Net::HTTPResponse.
  #
  # HTTPUnknownResponse
  # :   For unhandled HTTP extensions
  # HTTPInformation
  # :   1xx
  # HTTPContinue
  # :   100
  # HTTPSwitchProtocol
  # :   101
  # HTTPProcessing
  # :   102
  # HTTPEarlyHints
  # :   103
  # HTTPSuccess
  # :   2xx
  # HTTPOK
  # :   200
  # HTTPCreated
  # :   201
  # HTTPAccepted
  # :   202
  # HTTPNonAuthoritativeInformation
  # :   203
  # HTTPNoContent
  # :   204
  # HTTPResetContent
  # :   205
  # HTTPPartialContent
  # :   206
  # HTTPMultiStatus
  # :   207
  # HTTPAlreadyReported
  # :   208
  # HTTPIMUsed
  # :   226
  # HTTPRedirection
  # :   3xx
  # HTTPMultipleChoices
  # :   300
  # HTTPMovedPermanently
  # :   301
  # HTTPFound
  # :   302
  # HTTPSeeOther
  # :   303
  # HTTPNotModified
  # :   304
  # HTTPUseProxy
  # :   305
  # HTTPTemporaryRedirect
  # :   307
  # HTTPPermanentRedirect
  # :   308
  # HTTPClientError
  # :   4xx
  # HTTPBadRequest
  # :   400
  # HTTPUnauthorized
  # :   401
  # HTTPPaymentRequired
  # :   402
  # HTTPForbidden
  # :   403
  # HTTPNotFound
  # :   404
  # HTTPMethodNotAllowed
  # :   405
  # HTTPNotAcceptable
  # :   406
  # HTTPProxyAuthenticationRequired
  # :   407
  # HTTPRequestTimeOut
  # :   408
  # HTTPConflict
  # :   409
  # HTTPGone
  # :   410
  # HTTPLengthRequired
  # :   411
  # HTTPPreconditionFailed
  # :   412
  # HTTPRequestEntityTooLarge
  # :   413
  # HTTPRequestURITooLong
  # :   414
  # HTTPUnsupportedMediaType
  # :   415
  # HTTPRequestedRangeNotSatisfiable
  # :   416
  # HTTPExpectationFailed
  # :   417
  # HTTPMisdirectedRequest
  # :   421
  # HTTPUnprocessableEntity
  # :   422
  # HTTPLocked
  # :   423
  # HTTPFailedDependency
  # :   424
  # HTTPUpgradeRequired
  # :   426
  # HTTPPreconditionRequired
  # :   428
  # HTTPTooManyRequests
  # :   429
  # HTTPRequestHeaderFieldsTooLarge
  # :   431
  # HTTPUnavailableForLegalReasons
  # :   451
  # HTTPServerError
  # :   5xx
  # HTTPInternalServerError
  # :   500
  # HTTPNotImplemented
  # :   501
  # HTTPBadGateway
  # :   502
  # HTTPServiceUnavailable
  # :   503
  # HTTPGatewayTimeOut
  # :   504
  # HTTPVersionNotSupported
  # :   505
  # HTTPVariantAlsoNegotiates
  # :   506
  # HTTPInsufficientStorage
  # :   507
  # HTTPLoopDetected
  # :   508
  # HTTPNotExtended
  # :   510
  # HTTPNetworkAuthenticationRequired
  # :   511
  #
  #
  # There is also the Net::HTTPBadResponse exception which is raised when there is
  # a protocol error.
  #
  class HTTP < Protocol
    # :stopdoc:
    VERSION: String

Revision: untyped

HTTPVersion: String

HAVE_ZLIB: bool

# 
    # Turns on net/http 1.2 (Ruby 1.8) features. Defaults to ON in Ruby 1.8 or
    # later.
    #
    def self.version_1_2: () -> ::TrueClass

# 
    # Returns true if net/http is in version 1.2 mode. Defaults to true.
    #
    def self.version_1_2?: () -> ::TrueClass

def self.version_1_1?: () -> ::FalseClass

alias self.is_version_1_1? self.version_1_1?

# 
    #
    alias self.is_version_1_2? self.version_1_2?

# 
    # Gets the body text from the target and outputs it to $stdout.  The target can
    # either be specified as (`uri`, `headers`), or as (`host`, `path`, `port` =
    # 80); so:
    #
    #     Net::HTTP.get_print URI('http://www.example.com/index.html')
    #
    # or:
    #
    #     Net::HTTP.get_print 'www.example.com', '/index.html'
    #
    # you can also specify request headers:
    #
    #     Net::HTTP.get_print URI('http://www.example.com/index.html'), { 'Accept' => 'text/html' }
    #
    def self.get_print: (URI::Generic uri, ?Hash[String, untyped] header) -> void
                      | (String host, String path, ?Integer port) -> void

# 
    # Sends a GET request to the target and returns the HTTP response as a string.
    # The target can either be specified as (`uri`, `headers`), or as (`host`,
    # `path`, `port` = 80); so:
    #
    #     print Net::HTTP.get(URI('http://www.example.com/index.html'))
    #
    # or:
    #
    #     print Net::HTTP.get('www.example.com', '/index.html')
    #
    # you can also specify request headers:
    #
    #     Net::HTTP.get(URI('http://www.example.com/index.html'), { 'Accept' => 'text/html' })
    #
    def self.get: (URI::Generic uri, ?Hash[String, untyped] header) -> String
                | (String host, String path, ?Integer port) -> String

# 
    # Sends a GET request to the target and returns the HTTP response as a
    # Net::HTTPResponse object.  The target can either be specified as (`uri`,
    # `headers`), or as (`host`, `path`, `port` = 80); so:
    #
    #     res = Net::HTTP.get_response(URI('http://www.example.com/index.html'))
    #     print res.body
    #
    # or:
    #
    #     res = Net::HTTP.get_response('www.example.com', '/index.html')
    #     print res.body
    #
    # you can also specify request headers:
    #
    #     Net::HTTP.get_response(URI('http://www.example.com/index.html'), { 'Accept' => 'text/html' })
    #
    def self.get_response: (URI::Generic uri, ?Hash[String, untyped] header) ?{ (Net::HTTPResponse) -> void } -> Net::HTTPResponse
                         | (String host, String path, ?Integer port) -> Net::HTTPResponse

# 
    # Posts data to the specified URI object.
    #
    # Example:
    #
    #     require 'net/http'
    #     require 'uri'
    #
    #     Net::HTTP.post URI('http://www.example.com/api/search'),
    #                    { "q" => "ruby", "max" => "50" }.to_json,
    #                    "Content-Type" => "application/json"
    #
    def self.post: (URI::Generic url, String data, ?Hash[String, untyped] header) -> Net::HTTPResponse

# 
    # Posts HTML form data to the specified URI object. The form data must be
    # provided as a Hash mapping from String to String. Example:
    #
    #     { "cmd" => "search", "q" => "ruby", "max" => "50" }
    #
    # This method also does Basic Authentication if and only if `url`.user exists.
    # But userinfo for authentication is deprecated (RFC3986). So this feature will
    # be removed.
    #
    # Example:
    #
    #     require 'net/http'
    #
    #     Net::HTTP.post_form URI('http://www.example.com/search.cgi'),
    #                         { "q" => "ruby", "max" => "50" }
    #
    def self.post_form: (URI::Generic url, Hash[String, untyped] params) -> Net::HTTPResponse

# 
    # The default port to use for HTTP requests; defaults to 80.
    #
    def self.default_port: () -> Integer

# 
    # The default port to use for HTTP requests; defaults to 80.
    #
    def self.http_default_port: () -> Integer

# 
    # The default port to use for HTTPS requests; defaults to 443.
    #
    def self.https_default_port: () -> Integer

# 
    # Creates a new Net::HTTP object, then additionally opens the TCP connection and
    # HTTP session.
    #
    # Arguments are the following:
    # *address*
    # :   hostname or IP address of the server
    # *port*
    # :   port of the server
    # *p_addr*
    # :   address of proxy
    # *p_port*
    # :   port of proxy
    # *p_user*
    # :   user of proxy
    # *p_pass*
    # :   pass of proxy
    # *opt*
    # :   optional hash
    #
    #
    # *opt* sets following values by its accessor. The keys are ipaddr, ca_file,
    # ca_path, cert, cert_store, ciphers, keep_alive_timeout,
    # close_on_empty_response, key, open_timeout, read_timeout, write_timeout,
    # ssl_timeout, ssl_version, use_ssl, verify_callback, verify_depth and
    # verify_mode. If you set :use_ssl as true, you can use https and default value
    # of verify_mode is set as OpenSSL::SSL::VERIFY_PEER.
    #
    # If the optional block is given, the newly created Net::HTTP object is passed
    # to it and closed when the block finishes.  In this case, the return value of
    # this method is the return value of the block.  If no block is given, the
    # return value of this method is the newly created Net::HTTP object itself, and
    # the caller is responsible for closing it upon completion using the finish()
    # method.
    #
    def self.start: (String address, ?Integer? port, ?String | :ENV | nil p_addr, ?Integer? p_port, ?String? p_user, ?String? p_pass, ?Hash[Symbol, untyped]? opt) -> Net::HTTP
                  | [T] (String address, ?Integer? port, ?String | :ENV | nil p_addr, ?Integer? p_port, ?String? p_user, ?String? p_pass, ?Hash[Symbol, untyped]? opt) { (Net::HTTP) -> T } -> T

# 
    #
    alias self.newobj self.new

# 
    # Creates a new Net::HTTP object for the specified server address, without
    # opening the TCP connection or initializing the HTTP session. The `address`
    # should be a DNS hostname or IP address.
    #
    def self.new: (String address, ?Integer? port, ?String | :ENV | nil p_addr, ?Integer? p_port, ?String? p_user, ?String? p_pass, ?untyped? p_no_proxy) -> Net::HTTP

# 
    #
    def inspect: () -> String

# 
    # **WARNING** This method opens a serious security hole. Never use this method
    # in production code.
    #
    # Sets an output stream for debugging.
    #
    #     http = Net::HTTP.new(hostname)
    #     http.set_debug_output $stderr
    #     http.start { .... }
    #
    def set_debug_output: (IO output) -> void

# 
    # The DNS host name or IP address to connect to.
    #
    attr_reader address: String

# 
    # The port number to connect to.
    #
    attr_reader port: Integer

# 
    # The local host used to establish the connection.
    #
    attr_accessor local_host: String

# 
    # The local port used to establish the connection.
    #
    attr_accessor local_port: Integer

attr_writer proxy_from_env: untyped

# 
    #
    attr_accessor proxy_address: String?

# 
    #
    attr_accessor proxy_port: Integer?

# 
    #
    attr_accessor proxy_user: String?

# 
    #
    attr_accessor proxy_pass: String?

# 
    # The IP address to connect to/used to connect to
    # ----
    # 
    # Set the IP address to connect to
    #
    attr_accessor ipaddr: String?

# 
    # Number of seconds to wait for the connection to open. Any number may be used,
    # including Floats for fractional seconds. If the HTTP object cannot open a
    # connection in this many seconds, it raises a Net::OpenTimeout exception. The
    # default value is 60 seconds.
    #
    attr_accessor open_timeout: Float | Integer

# 
    # Number of seconds to wait for one block to be read (via one read(2) call). Any
    # number may be used, including Floats for fractional seconds. If the HTTP
    # object cannot read data in this many seconds, it raises a Net::ReadTimeout
    # exception. The default value is 60 seconds.
    # ----
    # 
    # Setter for the read_timeout attribute.
    #
    attr_accessor read_timeout: Float | Integer

# 
    # Number of seconds to wait for one block to be written (via one write(2) call).
    # Any number may be used, including Floats for fractional seconds. If the HTTP
    # object cannot write data in this many seconds, it raises a Net::WriteTimeout
    # exception. The default value is 60 seconds. Net::WriteTimeout is not raised on
    # Windows.
    # ----
    # 
    # Setter for the write_timeout attribute.
    #
    attr_accessor write_timeout: Float | Integer

# 
    # Maximum number of times to retry an idempotent request in case of
    # Net::ReadTimeout, IOError, EOFError, Errno::ECONNRESET, Errno::ECONNABORTED,
    # Errno::EPIPE, OpenSSL::SSL::SSLError, Timeout::Error. Should be a non-negative
    # integer number. Zero means no retries. The default value is 1.
    #
    attr_accessor max_retries: Integer

# 
    # Seconds to wait for 100 Continue response. If the HTTP object does not receive
    # a response in this many seconds it sends the request body. The default value
    # is `nil`.
    # ----
    # 
    # Setter for the continue_timeout attribute.
    #
    attr_accessor continue_timeout: Float | Integer | nil

# 
    # Seconds to reuse the connection of the previous request. If the idle time is
    # less than this Keep-Alive Timeout, Net::HTTP reuses the TCP/IP socket used by
    # the previous communication. The default value is 2 seconds.
    #
    attr_accessor keep_alive_timeout: Float | Integer

# 
    # Returns true if the HTTP session has been started.
    #
    def started?: () -> bool

# 
    #
    alias active? started?

attr_accessor close_on_empty_response: untyped

# 
    # Returns true if SSL/TLS is being used with HTTP.
    #
    def use_ssl?: () -> bool

# 
    # Turn on/off SSL. This flag must be set before starting session. If you change
    # use_ssl value after session started, a Net::HTTP object raises IOError.
    #
    def use_ssl=: (boolish flag) -> void

SSL_IVNAMES: Array[untyped]

SSL_ATTRIBUTES: Array[Symbol]

# 
    # Sets path of a CA certification file in PEM format.
    #
    # The file can contain several CA certificates.
    #
    attr_accessor ca_file: untyped

# 
    # Sets path of a CA certification directory containing certifications in PEM
    # format.
    #
    attr_accessor ca_path: untyped

# 
    # Sets an OpenSSL::X509::Certificate object as client certificate. (This method
    # is appeared in Michal Rokos's OpenSSL extension).
    #
    attr_accessor cert: untyped

# 
    # Sets the X509::Store to verify peer certificate.
    #
    attr_accessor cert_store: untyped

# 
    # Sets the available ciphers.  See OpenSSL::SSL::SSLContext#ciphers=
    #
    attr_accessor ciphers: untyped

# 
    # Sets the extra X509 certificates to be added to the certificate chain. See
    # OpenSSL::SSL::SSLContext#extra_chain_cert=
    #
    attr_accessor extra_chain_cert: untyped

# 
    # Sets an OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object. (This method is
    # appeared in Michal Rokos's OpenSSL extension.)
    #
    attr_accessor key: untyped

# 
    # Sets the SSL timeout seconds.
    #
    attr_accessor ssl_timeout: untyped

# 
    # Sets the SSL version.  See OpenSSL::SSL::SSLContext#ssl_version=
    #
    attr_accessor ssl_version: untyped

# 
    # Sets the minimum SSL version.  See OpenSSL::SSL::SSLContext#min_version=
    #
    attr_accessor min_version: untyped

# 
    # Sets the maximum SSL version.  See OpenSSL::SSL::SSLContext#max_version=
    #
    attr_accessor max_version: untyped

# 
    # Sets the verify callback for the server certification verification.
    #
    attr_accessor verify_callback: untyped

# 
    # Sets the maximum depth for the certificate chain verification.
    #
    attr_accessor verify_depth: untyped

# 
    # Sets the flags for server the certification verification at beginning of
    # SSL/TLS session.
    #
    # OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER are acceptable.
    #
    attr_accessor verify_mode: untyped

# 
    # Sets to check the server certificate is valid for the hostname. See
    # OpenSSL::SSL::SSLContext#verify_hostname=
    #
    attr_accessor verify_hostname: untyped

# 
    # Returns the X.509 certificates the server presented.
    #
    def peer_cert: () -> (nil | untyped)

# 
    # Opens a TCP connection and HTTP session.
    #
    # When this method is called with a block, it passes the Net::HTTP object to the
    # block, and closes the TCP connection and HTTP session after the block has been
    # executed.
    #
    # When called with a block, it returns the return value of the block; otherwise,
    # it returns self.
    #
    def start: [T] () { (Net::HTTP) -> T } -> T
             | () -> Net::HTTP

public

# 
    # Finishes the HTTP session and closes the TCP connection. Raises IOError if the
    # session has not been started.
    #
    def finish: () -> void

public

# 
    # Creates an HTTP proxy class which behaves like Net::HTTP, but performs all
    # access via the specified proxy.
    #
    # This class is obsolete.  You may pass these same parameters directly to
    # Net::HTTP.new.  See Net::HTTP.new for details of the arguments.
    #
    def self.Proxy: (?Symbol | String p_addr, ?Integer? p_port, ?String? p_user, ?String? p_pass) -> untyped

# 
    # returns true if self is a class which was created by HTTP::Proxy.
    #
    def self.proxy_class?: () -> bool

# 
    # Address of proxy host. If Net::HTTP does not use a proxy, nil.
    #
    attr_reader self.proxy_address: String?

# 
    # Port number of proxy host. If Net::HTTP does not use a proxy, nil.
    #
    attr_reader self.proxy_port: Integer?

# 
    # User name for accessing proxy. If Net::HTTP does not use a proxy, nil.
    #
    attr_reader self.proxy_user: String?

# 
    # User password for accessing proxy. If Net::HTTP does not use a proxy, nil.
    #
    attr_reader self.proxy_pass: String?

# 
    # True if requests for this connection will be proxied
    #
    def proxy?: () -> bool

# 
    # True if the proxy for this connection is determined from the environment
    #
    def proxy_from_env?: () -> bool

def proxy_uri: () -> (nil | URI::Generic)

# 
    #
    alias proxyaddr proxy_address

# 
    #
    alias proxyport proxy_port

public

# 
    # Retrieves data from `path` on the connected-to host which may be an absolute
    # path String or a URI to extract the path from.
    #
    # `initheader` must be a Hash like { 'Accept' => '**/**', ... }, and it defaults
    # to an empty hash. If `initheader` doesn't have the key 'accept-encoding', then
    # a value of "gzip;q=1.0,deflate;q=0.6,identity;q=0.3" is used, so that gzip
    # compression is used in preference to deflate compression, which is used in
    # preference to no compression. Ruby doesn't have libraries to support the
    # compress (Lempel-Ziv) compression, so that is not supported.  The intent of
    # this is to reduce bandwidth by default.   If this routine sets up compression,
    # then it does the decompression also, removing the header as well to prevent
    # confusion.  Otherwise it leaves the body as it found it.
    #
    # This method returns a Net::HTTPResponse object.
    #
    # If called with a block, yields each fragment of the entity body in turn as a
    # string as it is read from the socket.  Note that in this case, the returned
    # response object will **not** contain a (meaningful) body.
    #
    # `dest` argument is obsolete. It still works but you must not use it.
    #
    # This method never raises an exception.
    #
    #     response = http.get('/index.html')
    #
    #     # using block
    #     File.open('result.txt', 'w') {|f|
    #       http.get('/~foo/') do |str|
    #         f.write str
    #       end
    #     }
    #
    def get: (String path, ?Hash[String, untyped] initheader, ?bot dest) ?{ (String body_segment) -> void } -> Net::HTTPResponse

# 
    # Gets only the header from `path` on the connected-to host. `header` is a Hash
    # like { 'Accept' => '**/**', ... }.
    #
    # This method returns a Net::HTTPResponse object.
    #
    # This method never raises an exception.
    #
    #     response = nil
    #     Net::HTTP.start('some.www.server', 80) {|http|
    #       response = http.head('/index.html')
    #     }
    #     p response['content-type']
    #
    def head: (String path, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Posts `data` (must be a String) to `path`. `header` must be a Hash like {
    # 'Accept' => '**/**', ... }.
    #
    # This method returns a Net::HTTPResponse object.
    #
    # If called with a block, yields each fragment of the entity body in turn as a
    # string as it is read from the socket.  Note that in this case, the returned
    # response object will **not** contain a (meaningful) body.
    #
    # `dest` argument is obsolete. It still works but you must not use it.
    #
    # This method never raises exception.
    #
    #     response = http.post('/cgi-bin/search.rb', 'query=foo')
    #
    #     # using block
    #     File.open('result.txt', 'w') {|f|
    #       http.post('/cgi-bin/search.rb', 'query=foo') do |str|
    #         f.write str
    #       end
    #     }
    #
    # You should set Content-Type: header field for POST. If no Content-Type: field
    # given, this method uses "application/x-www-form-urlencoded" by default.
    #
    def post: (String path, String data, ?Hash[String, untyped] initheader, ?bot dest) ?{ (String body_segment) -> void } -> Net::HTTPResponse

# 
    # Sends a PATCH request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def patch: (String path, String data, ?Hash[String, untyped] initheader, ?bot dest) ?{ (String body_segment) -> void } -> Net::HTTPResponse

def put: (String path, String data, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a PROPPATCH request to the `path` and gets a response, as an
    # HTTPResponse object.
    #
    def proppatch: (String path, String body, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a LOCK request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def lock: (String path, String body, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a UNLOCK request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def unlock: (String path, String body, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a OPTIONS request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def options: (String path, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a PROPFIND request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def propfind: (String path, ?untyped? body, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a DELETE request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def delete: (String path, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a MOVE request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def move: (String path, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a COPY request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def copy: (String path, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a MKCOL request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def mkcol: (String path, ?untyped? body, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a TRACE request to the `path` and gets a response, as an HTTPResponse
    # object.
    #
    def trace: (String path, ?Hash[String, untyped] initheader) -> Net::HTTPResponse

# 
    # Sends a GET request to the `path`. Returns the response as a Net::HTTPResponse
    # object.
    #
    # When called with a block, passes an HTTPResponse object to the block. The body
    # of the response will not have been read yet; the block can process it using
    # HTTPResponse#read_body, if desired.
    #
    # Returns the response.
    #
    # This method never raises Net::* exceptions.
    #
    #     response = http.request_get('/index.html')
    #     # The entity body is already read in this case.
    #     p response['content-type']
    #     puts response.body
    #
    #     # Using a block
    #     http.request_get('/index.html') {|response|
    #       p response['content-type']
    #       response.read_body do |str|   # read body now
    #         print str
    #       end
    #     }
    #
    def request_get: (String path, ?Hash[String, untyped] initheader) ?{ (Net::HTTPResponse response) -> void } -> Net::HTTPResponse

# 
    # Sends a HEAD request to the `path` and returns the response as a
    # Net::HTTPResponse object.
    #
    # Returns the response.
    #
    # This method never raises Net::* exceptions.
    #
    #     response = http.request_head('/index.html')
    #     p response['content-type']
    #
    def request_head: (String path, ?Hash[String, untyped] initheader) ?{ (Net::HTTPResponse response) -> void } -> Net::HTTPResponse

# 
    # Sends a POST request to the `path`.
    #
    # Returns the response as a Net::HTTPResponse object.
    #
    # When called with a block, the block is passed an HTTPResponse object.  The
    # body of that response will not have been read yet; the block can process it
    # using HTTPResponse#read_body, if desired.
    #
    # Returns the response.
    #
    # This method never raises Net::* exceptions.
    #
    #     # example
    #     response = http.request_post('/cgi-bin/nice.rb', 'datadatadata...')
    #     p response.status
    #     puts response.body          # body is already read in this case
    #
    #     # using block
    #     http.request_post('/cgi-bin/nice.rb', 'datadatadata...') {|response|
    #       p response.status
    #       p response['content-type']
    #       response.read_body do |str|   # read body now
    #         print str
    #       end
    #     }
    #
    def request_post: (String path, String data, ?Hash[String, untyped] initheader) ?{ (Net::HTTPResponse response) -> void } -> Net::HTTPResponse

def request_put: (String path, String data, ?Hash[String, untyped] initheader) ?{ (Net::HTTPResponse response) -> void } -> Net::HTTPResponse

# 
    #
    alias get2 request_get

# 
    #
    alias head2 request_head

# 
    #
    alias post2 request_post

alias put2 request_put

# 
    # Sends an HTTP request to the HTTP server. Also sends a DATA string if `data`
    # is given.
    #
    # Returns a Net::HTTPResponse object.
    #
    # This method never raises Net::* exceptions.
    #
    #     response = http.send_request('GET', '/index.html')
    #     puts response.body
    #
    def send_request: (String name, String path, ?String? data, ?Hash[String, untyped]? header) -> Net::HTTPResponse

# 
    # Sends an HTTPRequest object `req` to the HTTP server.
    #
    # If `req` is a Net::HTTP::Post or Net::HTTP::Put request containing data, the
    # data is also sent. Providing data for a Net::HTTP::Head or Net::HTTP::Get
    # request results in an ArgumentError.
    #
    # Returns an HTTPResponse object.
    #
    # When called with a block, passes an HTTPResponse object to the block. The body
    # of the response will not have been read yet; the block can process it using
    # HTTPResponse#read_body, if desired.
    #
    # This method never raises Net::* exceptions.
    #
    def request: (Net::HTTPRequest req, ?String? body) ?{ (Net::HTTPResponse response) -> void } -> Net::HTTPResponse
  end

# 
  # HTTPGenericRequest is the parent of the Net::HTTPRequest class. Do not use
  # this directly; use a subclass of Net::HTTPRequest.
  #
  # Mixes in the Net::HTTPHeader module to provide easier access to HTTP headers.
  #
  class HTTPGenericRequest
    include Net::HTTPHeader

# 
    #
    def initialize: (String m, boolish reqbody, boolish resbody, URI::Generic | String uri_or_path, ?Hash[String, untyped] initheader) -> Net::HTTP

attr_reader method: String

attr_reader path: String

attr_reader uri: URI::Generic

# 
    # Automatically set to false if the user sets the Accept-Encoding header. This
    # indicates they wish to handle Content-encoding in responses themselves.
    #
    attr_reader decode_content: bool

# 
    #
    def inspect: () -> String

def []=: (untyped key, untyped val) -> void

# 
    #
    def request_body_permitted?: () -> bool

# 
    #
    def response_body_permitted?: () -> bool

# 
    #
    def body_exist?: () -> bool

# 
    #
    attr_accessor body: String?

# 
    #
    attr_accessor body_stream: untyped
  end

# 
  # The HTTPHeader module defines methods for reading and writing HTTP headers.
  #
  # It is used as a mixin by other classes, to provide hash-like access to HTTP
  # header values. Unlike raw hash access, HTTPHeader provides access via
  # case-insensitive keys. It also provides methods for accessing commonly-used
  # HTTP header values in more convenient formats.
  #
  module HTTPHeader
    # 
    #
    def initialize_http_header: (Hash[untyped, untyped] initheader) -> void

def size: () -> Integer

alias length size

type key = String | Symbol

# 
    # Returns the header field corresponding to the case-insensitive key. For
    # example, a key of "Content-Type" might return "text/html"
    #
    def []: (key key) -> (nil | String)

# 
    # Sets the header field corresponding to the case-insensitive key.
    #
    def []=: (key key, untyped val) -> void

# 
    # Ruby 1.8.3
    # :   Adds a value to a named header field, instead of replacing its value.
    #     Second argument `val` must be a String. See also #[]=, #[] and
    #     #get_fields.
    #
    #         request.add_field 'X-My-Header', 'a'
    #         p request['X-My-Header']              #=> "a"
    #         p request.get_fields('X-My-Header')   #=> ["a"]
    #         request.add_field 'X-My-Header', 'b'
    #         p request['X-My-Header']              #=> "a, b"
    #         p request.get_fields('X-My-Header')   #=> ["a", "b"]
    #         request.add_field 'X-My-Header', 'c'
    #         p request['X-My-Header']              #=> "a, b, c"
    #         p request.get_fields('X-My-Header')   #=> ["a", "b", "c"]
    #
    def add_field: (key key, untyped val) -> void

private

# 
    #
    def set_field: (key key, untyped val) -> void

# 
    #
    def append_field_value: (untyped ary, untyped val) -> void

public

# 
    # Ruby 1.8.3
    # :   Returns an array of header field strings corresponding to the
    #     case-insensitive `key`.  This method allows you to get duplicated header
    #     fields without any processing.  See also #[].
    #
    #         p response.get_fields('Set-Cookie')
    #           #=> ["session=al98axx; expires=Fri, 31-Dec-1999 23:58:23",
    #                "query=rubyscript; expires=Fri, 31-Dec-1999 23:58:23"]
    #         p response['Set-Cookie']
    #           #=> "session=al98axx; expires=Fri, 31-Dec-1999 23:58:23, query=rubyscript; expires=Fri, 31-Dec-1999 23:58:23"
    #
    def get_fields: (key key) -> (nil | Array[String])

# 
    # Returns the header field corresponding to the case-insensitive key. Returns
    # the default value `args`, or the result of the block, or raises an IndexError
    # if there's no header field named `key` See Hash#fetch
    #
    def fetch: (key key) -> String
             | (key key, untyped) -> untyped
             | (key key) { (String) -> untyped } -> untyped

# 
    # Iterates through the header names and values, passing in the name and value to
    # the code block supplied.
    #
    # Returns an enumerator if no block is given.
    #
    # Example:
    #
    #     response.header.each_header {|key,value| puts "#{key} = #{value}" }
    #
    def each_header: () { (String, String) -> untyped } -> Hash[String, Array[String]]
                   | () -> Enumerator[[ String, String ], Hash[String, Array[String]]]

# 
    #
    alias each each_header

# 
    # Iterates through the header names in the header, passing each header name to
    # the code block.
    #
    # Returns an enumerator if no block is given.
    #
    def each_name: () { (String) -> untyped } -> Hash[String, Array[String]]
                 | () -> Enumerator[String, Hash[String, Array[String]]]

# 
    #
    alias each_key each_name

# 
    # Iterates through the header names in the header, passing capitalized header
    # names to the code block.
    #
    # Note that header names are capitalized systematically; capitalization may not
    # match that used by the remote HTTP server in its response.
    #
    # Returns an enumerator if no block is given.
    #
    def each_capitalized_name: () { (String) -> untyped } -> Hash[String, Array[String]]
                             | () -> Enumerator[String, Hash[String, Array[String]]]

# 
    # Iterates through header values, passing each value to the code block.
    #
    # Returns an enumerator if no block is given.
    #
    def each_value: () { (String) -> untyped } -> Hash[String, Array[String]]
                  | () -> Enumerator[String, Hash[String, Array[String]]]

# 
    # Removes a header field, specified by case-insensitive key.
    #
    def delete: (key key) -> (Array[String] | nil)

# 
    # true if `key` header exists.
    #
    def key?: (key key) -> bool

# 
    # Returns a Hash consisting of header names and array of values. e.g.
    # {"cache-control" => ["private"],
    #     "content-type" => ["text/html"],
    #     "date" => ["Wed, 22 Jun 2005 22:11:50 GMT"]}
    #
    def to_hash: () -> Hash[String, Array[String]]

# 
    # As for #each_header, except the keys are provided in capitalized form.
    #
    # Note that header names are capitalized systematically; capitalization may not
    # match that used by the remote HTTP server in its response.
    #
    # Returns an enumerator if no block is given.
    #
    def each_capitalized: () { (String, String) -> untyped } -> Hash[String, Array[String]]
                        | () -> Enumerator[[ String, String ], Hash[String, Array[String]]]

# 
    #
    alias canonical_each each_capitalized

private

# 
    #
    def capitalize: (key name) -> String

public

# 
    # Returns an Array of Range objects which represent the Range: HTTP header
    # field, or `nil` if there is no such header.
    #
    def range: () -> (nil | Array[Range[Integer]])

# 
    # Sets the HTTP Range: header. Accepts either a Range object as a single
    # argument, or a beginning index and a length from that index. Example:
    #
    #     req.range = (0..1023)
    #     req.set_range 0, 1023
    #
    def set_range: (Range[Integer] | Numeric r, ?Integer? e) -> Range[Integer]

# 
    #
    alias range= set_range

# 
    # Returns an Integer object which represents the HTTP Content-Length: header
    # field, or `nil` if that field was not provided.
    #
    def content_length: () -> (nil | Integer)

# 
    #
    def content_length=: (Integer len) -> void

# 
    # Returns "true" if the "transfer-encoding" header is present and set to
    # "chunked".  This is an HTTP/1.1 feature, allowing the content to be sent in
    # "chunks" without at the outset stating the entire content length.
    #
    def chunked?: () -> bool

# 
    # Returns a Range object which represents the value of the Content-Range: header
    # field. For a partial entity body, this indicates where this fragment fits
    # inside the full entity body, as range of byte offsets.
    #
    def content_range: () -> (Range[Integer] | nil)

# 
    # The length of the range represented in Content-Range: header.
    #
    def range_length: () -> (nil | Integer)

# 
    # Returns a content type string such as "text/html". This method returns nil if
    # Content-Type: header field does not exist.
    #
    def content_type: () -> (nil | String)

# 
    # Returns a content type string such as "text". This method returns nil if
    # Content-Type: header field does not exist.
    #
    def main_type: () -> (nil | String)

# 
    # Returns a content type string such as "html". This method returns nil if
    # Content-Type: header field does not exist or sub-type is not given (e.g.
    # "Content-Type: text").
    #
    def sub_type: () -> (nil | String)

# 
    # Any parameters specified for the content type, returned as a Hash. For
    # example, a header of Content-Type: text/html; charset=EUC-JP would result in
    # type_params returning {'charset' => 'EUC-JP'}
    #
    def type_params: () -> Hash[untyped, untyped]

# 
    # Sets the content type in an HTTP header. The `type` should be a full HTTP
    # content type, e.g. "text/html". The `params` are an optional Hash of
    # parameters to add after the content type, e.g. {'charset' => 'iso-8859-1'}
    #
    def set_content_type: (key `type`, ?Hash[untyped, untyped] params) -> void

# 
    #
    alias content_type= set_content_type

# 
    # Set header fields and a body from HTML form data. `params` should be an Array
    # of Arrays or a Hash containing HTML form data. Optional argument `sep` means
    # data record separator.
    #
    # Values are URL encoded as necessary and the content-type is set to
    # application/x-www-form-urlencoded
    #
    # Example:
    #     http.form_data = {"q" => "ruby", "lang" => "en"}
    #     http.form_data = {"q" => ["ruby", "perl"], "lang" => "en"}
    #     http.set_form_data({"q" => "ruby", "lang" => "en"}, ';')
    #
    def set_form_data: (Hash[untyped, untyped] params, ?String sep) -> void

# 
    #
    alias form_data= set_form_data

# 
    # Set an HTML form data set.
    # `params`
    # :   The form data to set, which should be an enumerable. See below for more
    #     details.
    # `enctype`
    # :   The content type to use to encode the form submission, which should be
    #     application/x-www-form-urlencoded or multipart/form-data.
    # `formopt`
    # :   An options hash, supporting the following options:
    #     :boundary
    # :       The boundary of the multipart message. If not given, a random boundary
    #         will be used.
    #     :charset
    # :       The charset of the form submission. All field names and values of
    #         non-file fields should be encoded with this charset.
    #
    #
    #
    # Each item of params should respond to `each` and yield 2-3 arguments, or an
    # array of 2-3 elements. The arguments yielded should be:
    #     * The name of the field.
    #     * The value of the field, it should be a String or a File or IO-like.
    #     * An options hash, supporting the following options, only
    #       used for file uploads:
    #       :filename :: The name of the file to use.
    #       :content_type :: The content type of the uploaded file.
    #
    # Each item is a file field or a normal field. If `value` is a File object or
    # the `opt` hash has a :filename key, the item is treated as a file field.
    #
    # If Transfer-Encoding is set as chunked, this sends the request using chunked
    # encoding. Because chunked encoding is HTTP/1.1 feature, you should confirm
    # that the server supports HTTP/1.1 before using chunked encoding.
    #
    # Example:
    #     req.set_form([["q", "ruby"], ["lang", "en"]])
    #
    #     req.set_form({"f"=>File.open('/path/to/filename')},
    #                  "multipart/form-data",
    #                  charset: "UTF-8",
    #     )
    #
    #     req.set_form([["f",
    #                    File.open('/path/to/filename.bar'),
    #                    {filename: "other-filename.foo"}
    #                  ]],
    #                  "multipart/form-data",
    #     )
    #
    # See also RFC 2388, RFC 2616, HTML 4.01, and HTML5
    #
    def set_form: (Hash[untyped, untyped] params, ?String enctype, ?Hash[untyped, untyped] formopt) -> void

# 
    # Set the Authorization: header for "Basic" authorization.
    #
    def basic_auth: (String account, String password) -> void

# 
    # Set Proxy-Authorization: header for "Basic" authorization.
    #
    def proxy_basic_auth: (String account, String password) -> void

private

# 
    #
    def basic_encode: (String account, String password) -> String

public

# 
    #
    def connection_close?: () -> bool

# 
    #
    def connection_keep_alive?: () -> bool
  end

# 
  # HTTP request class. This class wraps together the request header and the
  # request path. You cannot use this class directly. Instead, you should use one
  # of its subclasses: Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Head.
  #
  class HTTPRequest < HTTPGenericRequest
    # 
    # Creates an HTTP request object for `path`.
    #
    # `initheader` are the default headers to use.  Net::HTTP adds Accept-Encoding
    # to enable compression of the response body unless Accept-Encoding or Range are
    # supplied in `initheader`.
    #
    def initialize: (String path, ?Hash[String, untyped] initheader) -> void
                  | (URI::Generic uri, ?Hash[String, untyped] initheader) -> void
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for
  # usage examples.
  #
  class HTTP::Get < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for
  # usage examples.
  #
  class HTTP::Head < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for
  # usage examples.
  #
  class HTTP::Post < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for
  # usage examples.
  #
  class HTTP::Put < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for
  # usage examples.
  #
  class HTTP::Delete < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Options < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Trace < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Patch < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Propfind < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Proppatch < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Mkcol < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Copy < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Move < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Lock < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # See Net::HTTPGenericRequest for attributes and methods.
  #
  class HTTP::Unlock < HTTPRequest
    METHOD: String

REQUEST_HAS_BODY: bool

RESPONSE_HAS_BODY: bool
  end

# 
  # HTTP response class.
  #
  # This class wraps together the response header and the response body (the
  # entity requested).
  #
  # It mixes in the HTTPHeader module, which provides access to response header
  # values both via hash-like methods and via individual readers.
  #
  # Note that each possible HTTP response code defines its own HTTPResponse
  # subclass. All classes are defined under the Net module. Indentation indicates
  # inheritance.  For a list of the classes see Net::HTTP.
  #
  # Correspondence `HTTP code => class` is stored in CODE_TO_OBJ constant:
  #
  #     Net::HTTPResponse::CODE_TO_OBJ['404'] #=> Net::HTTPNotFound
  #
  class HTTPResponse
    # 
    # true if the response has a body.
    #
    def self.body_permitted?: () -> bool

public

include Net::HTTPHeader

# 
    # The HTTP version supported by the server.
    #
    attr_reader http_version: String

# 
    # The HTTP result code string. For example, '302'.  You can also determine the
    # response type by examining which response subclass the response object is an
    # instance of.
    #
    attr_reader code: String

# 
    # The HTTP result message sent by the server. For example, 'Not Found'.
    #
    attr_reader message: String

# 
    # The HTTP result message sent by the server. For example, 'Not Found'.
    #
    alias msg message

# 
    # The URI used to fetch this response.  The response URI is only available if a
    # URI was used to create the request.
    #
    attr_reader uri: URI::Generic | nil

# 
    # Set to true automatically when the request did not contain an Accept-Encoding
    # header from the user.
    #
    attr_accessor decode_content: bool

# 
    #
    def inspect: () -> String

def code_type: () -> untyped

def error!: () -> untyped

def error_type: () -> (Net::HTTPError | Net::HTTPServerException | Net::HTTPRetriableError | Net::HTTPFatalError)

# 
    # Raises an HTTP error if the response is not 2xx (success).
    #
    def value: () -> (nil | untyped)

def uri=: (URI::Generic uri) -> void

interface _Dest
      def <<: (String) -> void
    end

# 
    # Gets the entity body returned by the remote HTTP server.
    #
    # If a block is given, the body is passed to the block, and the body is provided
    # in fragments, as it is read in from the socket.
    #
    # If `dest` argument is given, response is read into that variable, with
    # `dest#<<` method (it could be String or IO, or any other object responding to
    # `<<`).
    #
    # Calling this method a second or subsequent time for the same HTTPResponse
    # object will return the value already read.
    #
    #     http.request_get('/index.html') {|res|
    #       puts res.read_body
    #     }
    #
    #     http.request_get('/index.html') {|res|
    #       p res.read_body.object_id   # 538149362
    #       p res.read_body.object_id   # 538149362
    #     }
    #
    #     # using iterator
    #     http.request_get('/index.html') {|res|
    #       res.read_body do |segment|
    #         print segment
    #       end
    #     }
    #
    def read_body: () -> String
                 | (_Dest dest) -> String
                 | () { (String) -> void } -> String

# 
    # Returns the full entity body.
    #
    # Calling this method a second or subsequent time will return the string already
    # read.
    #
    #     http.request_get('/index.html') {|res|
    #       puts res.body
    #     }
    #
    #     http.request_get('/index.html') {|res|
    #       p res.body.object_id   # 538149362
    #       p res.body.object_id   # 538149362
    #     }
    #
    def body: () -> String

# 
    # Because it may be necessary to modify the body, Eg, decompression this method
    # facilitates that.
    #
    def body=: (untyped value) -> void

# 
    #
    alias entity body
  end

# 
  # https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
  #
  class HTTPUnknownResponse < HTTPResponse
    HAS_BODY: bool

EXCEPTION_TYPE: Net::HTTPError
  end

class HTTPInformation < HTTPResponse
    HAS_BODY: bool

EXCEPTION_TYPE: Net::HTTPError
  end

class HTTPSuccess < HTTPResponse
    HAS_BODY: bool

EXCEPTION_TYPE: Net::HTTPError
  end

class HTTPRedirection < HTTPResponse
    HAS_BODY: bool

EXCEPTION_TYPE: Net::HTTPRetriableError
  end

class HTTPClientError < HTTPResponse
    HAS_BODY: bool

EXCEPTION_TYPE: untyped
  end

class HTTPServerError < HTTPResponse
    HAS_BODY: bool

EXCEPTION_TYPE: Net::HTTPFatalError
  end

class HTTPContinue < HTTPInformation
    HAS_BODY: bool
  end

class HTTPSwitchProtocol < HTTPInformation
    HAS_BODY: bool
  end

class HTTPProcessing < HTTPInformation
    HAS_BODY: bool
  end

class HTTPEarlyHints < HTTPInformation
    HAS_BODY: bool
  end

class HTTPOK < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPCreated < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPAccepted < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPNonAuthoritativeInformation < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPNoContent < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPResetContent < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPPartialContent < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPMultiStatus < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPAlreadyReported < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPIMUsed < HTTPSuccess
    HAS_BODY: bool
  end

class HTTPMultipleChoices < HTTPRedirection
    HAS_BODY: bool
  end

HTTPMultipleChoice: HTTPMultipleChoices

class HTTPMovedPermanently < HTTPRedirection
    HAS_BODY: bool
  end

class HTTPFound < HTTPRedirection
    HAS_BODY: bool
  end

class HTTPSeeOther < HTTPRedirection
    HAS_BODY: bool
  end

class HTTPNotModified < HTTPRedirection
    HAS_BODY: bool
  end

class HTTPUseProxy < HTTPRedirection
    HAS_BODY: bool
  end

# 
  # 306 Switch Proxy - no longer unused
  #
  class HTTPTemporaryRedirect < HTTPRedirection
    HAS_BODY: bool
  end

class HTTPPermanentRedirect < HTTPRedirection
    HAS_BODY: bool
  end

class HTTPBadRequest < HTTPClientError
    HAS_BODY: bool
  end

class HTTPUnauthorized < HTTPClientError
    HAS_BODY: bool
  end

class HTTPPaymentRequired < HTTPClientError
    HAS_BODY: bool
  end

class HTTPForbidden < HTTPClientError
    HAS_BODY: bool
  end

class HTTPNotFound < HTTPClientError
    HAS_BODY: bool
  end

class HTTPMethodNotAllowed < HTTPClientError
    HAS_BODY: bool
  end

class HTTPNotAcceptable < HTTPClientError
    HAS_BODY: bool
  end

class HTTPProxyAuthenticationRequired < HTTPClientError
    HAS_BODY: bool
  end

class HTTPRequestTimeout < HTTPClientError
    HAS_BODY: bool
  end

class HTTPConflict < HTTPClientError
    HAS_BODY: bool
  end

class HTTPGone < HTTPClientError
    HAS_BODY: bool
  end

class HTTPLengthRequired < HTTPClientError
    HAS_BODY: bool
  end

class HTTPPreconditionFailed < HTTPClientError
    HAS_BODY: bool
  end

class HTTPPayloadTooLarge < HTTPClientError
    HAS_BODY: bool
  end

class HTTPURITooLong < HTTPClientError
    HAS_BODY: bool
  end

class HTTPUnsupportedMediaType < HTTPClientError
    HAS_BODY: bool
  end

class HTTPRangeNotSatisfiable < HTTPClientError
    HAS_BODY: bool
  end

class HTTPExpectationFailed < HTTPClientError
    HAS_BODY: bool
  end

# 
  # 418 I'm a teapot - RFC 2324; a joke RFC 420 Enhance Your Calm - Twitter
  #
  class HTTPMisdirectedRequest < HTTPClientError
    HAS_BODY: bool
  end

class HTTPUnprocessableEntity < HTTPClientError
    HAS_BODY: bool
  end

class HTTPLocked < HTTPClientError
    HAS_BODY: bool
  end

class HTTPFailedDependency < HTTPClientError
    HAS_BODY: bool
  end

# 
  # 425 Unordered Collection - existed only in draft
  #
  class HTTPUpgradeRequired < HTTPClientError
    HAS_BODY: bool
  end

class HTTPPreconditionRequired < HTTPClientError
    HAS_BODY: bool
  end

class HTTPTooManyRequests < HTTPClientError
    HAS_BODY: bool
  end

class HTTPRequestHeaderFieldsTooLarge < HTTPClientError
    HAS_BODY: bool
  end

class HTTPUnavailableForLegalReasons < HTTPClientError
    HAS_BODY: bool
  end

# 
  # 444 No Response - Nginx 449 Retry With - Microsoft 450 Blocked by Windows
  # Parental Controls - Microsoft 499 Client Closed Request - Nginx
  #
  class HTTPInternalServerError < HTTPServerError
    HAS_BODY: bool
  end

class HTTPNotImplemented < HTTPServerError
    HAS_BODY: bool
  end

class HTTPBadGateway < HTTPServerError
    HAS_BODY: bool
  end

class HTTPServiceUnavailable < HTTPServerError
    HAS_BODY: bool
  end

class HTTPGatewayTimeout < HTTPServerError
    HAS_BODY: bool
  end

class HTTPVersionNotSupported < HTTPServerError
    HAS_BODY: bool
  end

class HTTPVariantAlsoNegotiates < HTTPServerError
    HAS_BODY: bool
  end

class HTTPInsufficientStorage < HTTPServerError
    HAS_BODY: bool
  end

class HTTPLoopDetected < HTTPServerError
    HAS_BODY: bool
  end

# 
  # 509 Bandwidth Limit Exceeded - Apache bw/limited extension
  #
  class HTTPNotExtended < HTTPServerError
    HAS_BODY: bool
  end

class HTTPNetworkAuthenticationRequired < HTTPServerError
    HAS_BODY: bool
  end

CODE_TO_OBJ: Hash[untyped, untyped]
  end

HTTP::STATUS_CODES: Hash[Integer, String]

# 
  # Net::HTTP exception class. You cannot use Net::HTTPExceptions directly;
  # instead, you must use its subclasses.
  #
  module HTTPExceptions
    def initialize: (untyped msg, untyped res) -> untyped

attr_reader response: untyped

alias data response
  end

class HTTPError < ProtocolError
    include Net::HTTPExceptions
  end

class HTTPRetriableError < ProtoRetriableError
    include Net::HTTPExceptions
  end

class HTTPServerException < ProtoServerError
    # We cannot use the name "HTTPServerError", it is the name of the response.
    include Net::HTTPExceptions
  end

class HTTPFatalError < ProtoFatalError
    include Net::HTTPExceptions
  end
end

Veranstaltungen | Fairnetzt-Hochrhein

Keine Veranstaltung gefunden!