dear_inventory 0.2.0

data/sorbet/rbi/gems/hashdiff.rbi

@@ -0,0 +1,66 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/hashdiff/all/hashdiff.rbi
+#
+# hashdiff-1.0.0
+
+module Hashdiff
+  def self.any_hash_or_array?(obja, objb); end
+  def self.best_diff(obj1, obj2, options = nil, &block); end
+  def self.comparable?(obj1, obj2, strict = nil); end
+  def self.compare_values(obj1, obj2, options = nil); end
+  def self.count_diff(diffs); end
+  def self.count_nodes(obj); end
+  def self.custom_compare(method, key, obj1, obj2); end
+  def self.decode_property_path(path, delimiter = nil); end
+  def self.diff(obj1, obj2, options = nil, &block); end
+  def self.diff_array_lcs(arraya, arrayb, options = nil); end
+  def self.lcs(arraya, arrayb, options = nil); end
+  def self.node(hash, parts); end
+  def self.patch!(obj, changes, options = nil); end
+  def self.prefix_append_array_index(prefix, array_index, opts); end
+  def self.prefix_append_key(prefix, key, opts); end
+  def self.similar?(obja, objb, options = nil); end
+  def self.unpatch!(obj, changes, options = nil); end
+end
+class Hashdiff::CompareHashes
+  def self.call(obj1, obj2, opts = nil); end
+end
+class Hashdiff::LcsCompareArrays
+  def self.call(obj1, obj2, opts = nil); end
+end
+class Hashdiff::LinearCompareArray
+  def additions; end
+  def append_addition(item, index); end
+  def append_addititions_before_match(match_index); end
+  def append_deletion(item, index); end
+  def append_deletions_before_match(match_index); end
+  def append_differences(difference); end
+  def call; end
+  def changes; end
+  def compare_at_index; end
+  def deletions; end
+  def differences; end
+  def expected_additions; end
+  def expected_additions=(arg0); end
+  def extra_items_in_new_array?; end
+  def extra_items_in_old_array?; end
+  def index_of_match_after_additions; end
+  def index_of_match_after_deletions; end
+  def initialize(old_array, new_array, options); end
+  def item_difference(old_item, new_item, item_index); end
+  def iterated_through_both_arrays?; end
+  def new_array; end
+  def new_index; end
+  def new_index=(arg0); end
+  def old_array; end
+  def old_index; end
+  def old_index=(arg0); end
+  def options; end
+  def self.call(old_array, new_array, options = nil); end
+end

data/sorbet/rbi/gems/http-cookie.rbi

@@ -0,0 +1,93 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/http-cookie/all/http-cookie.rbi
+#
+# http-cookie-1.0.3
+
+module HTTP
+end
+class HTTP::Cookie
+  def <=>(other); end
+  def acceptable?; end
+  def acceptable_from_uri?(uri); end
+  def accessed_at; end
+  def accessed_at=(arg0); end
+  def cookie_value; end
+  def created_at; end
+  def created_at=(arg0); end
+  def domain; end
+  def domain=(domain); end
+  def domain_name; end
+  def dot_domain; end
+  def encode_with(coder); end
+  def expire!; end
+  def expired?(time = nil); end
+  def expires; end
+  def expires=(t); end
+  def expires_at; end
+  def expires_at=(t); end
+  def for_domain; end
+  def for_domain=(arg0); end
+  def for_domain?; end
+  def httponly; end
+  def httponly=(arg0); end
+  def httponly?; end
+  def init_with(coder); end
+  def initialize(*args); end
+  def inspect; end
+  def max_age; end
+  def max_age=(sec); end
+  def name; end
+  def name=(name); end
+  def origin; end
+  def origin=(origin); end
+  def path; end
+  def path=(path); end
+  def secure; end
+  def secure=(arg0); end
+  def secure?; end
+  def self.cookie_value(cookies); end
+  def self.cookie_value_to_hash(cookie_value); end
+  def self.parse(set_cookie, origin, options = nil, &block); end
+  def self.path_match?(base_path, target_path); end
+  def session; end
+  def session?; end
+  def set_cookie_value; end
+  def to_s; end
+  def to_yaml_properties; end
+  def valid_for_uri?(uri); end
+  def value; end
+  def value=(value); end
+  def yaml_initialize(tag, map); end
+  include Comparable
+end
+class Array
+end
+class Hash
+end
+class String
+end
+class HTTP::CookieJar
+  def <<(cookie); end
+  def add(cookie); end
+  def cleanup(session = nil); end
+  def clear; end
+  def cookies(url = nil); end
+  def delete(cookie); end
+  def each(uri = nil, &block); end
+  def empty?(url = nil); end
+  def get_impl(base, value, *args); end
+  def initialize(options = nil); end
+  def initialize_copy(other); end
+  def load(readable, *options); end
+  def parse(set_cookie, origin, options = nil); end
+  def save(writable, *options); end
+  def self.const_missing(name); end
+  def store; end
+  include Enumerable
+end

data/sorbet/rbi/gems/http-form_data.rbi

@@ -0,0 +1,76 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/http-form_data/all/http-form_data.rbi
+#
+# http-form_data-2.2.0
+
+module HTTP
+end
+module HTTP::FormData
+  def self.create(data); end
+  def self.ensure_hash(obj); end
+  def self.multipart?(data); end
+end
+module HTTP::FormData::Readable
+  def read(length = nil, outbuf = nil); end
+  def rewind; end
+  def size; end
+  def to_s; end
+end
+class HTTP::FormData::Part
+  def content_type; end
+  def filename; end
+  def initialize(body, content_type: nil, filename: nil); end
+  include HTTP::FormData::Readable
+end
+class HTTP::FormData::File < HTTP::FormData::Part
+  def filename_for(io); end
+  def initialize(path_or_io, opts = nil); end
+  def make_io(path_or_io); end
+  def mime_type; end
+end
+class HTTP::FormData::CompositeIO
+  def advance_io; end
+  def current_io; end
+  def initialize(ios); end
+  def read(length = nil, outbuf = nil); end
+  def read_chunks(length = nil); end
+  def readpartial(max_length = nil); end
+  def rewind; end
+  def size; end
+end
+class HTTP::FormData::Multipart
+  def boundary; end
+  def content_length; end
+  def content_type; end
+  def glue; end
+  def initialize(data, boundary: nil); end
+  def self.generate_boundary; end
+  def tail; end
+  include HTTP::FormData::Readable
+end
+class HTTP::FormData::Multipart::Param
+  def content_type; end
+  def filename; end
+  def footer; end
+  def header; end
+  def initialize(name, value); end
+  def parameters; end
+  def self.coerce(data); end
+  include HTTP::FormData::Readable
+end
+class HTTP::FormData::Urlencoded
+  def content_length; end
+  def content_type; end
+  def initialize(data); end
+  def self.encoder; end
+  def self.encoder=(implementation); end
+  include HTTP::FormData::Readable
+end
+class HTTP::FormData::Error < StandardError
+end

data/sorbet/rbi/gems/http-parser.rbi

@@ -0,0 +1,121 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/http-parser/all/http-parser.rbi
+#
+# http-parser-1.2.1
+
+module HttpParser
+  def err_desc(*arg0); end
+  def err_name(*arg0); end
+  def http_body_is_final(*arg0); end
+  def http_parser_execute(*arg0); end
+  def http_parser_init(*arg0); end
+  def http_should_keep_alive(*arg0); end
+  def self.err_desc(*arg0); end
+  def self.err_name(*arg0); end
+  def self.http_body_is_final(*arg0); end
+  def self.http_parser_execute(*arg0); end
+  def self.http_parser_init(*arg0); end
+  def self.http_should_keep_alive(*arg0); end
+  extend FFI::Library
+end
+class HttpParser::Error < StandardError
+end
+class HttpParser::Error::OK < HttpParser::Error
+end
+class HttpParser::Error::CALLBACK < HttpParser::Error
+end
+class HttpParser::Error::INVALID_EOF_STATE < HttpParser::Error
+end
+class HttpParser::Error::HEADER_OVERFLOW < HttpParser::Error
+end
+class HttpParser::Error::CLOSED_CONNECTION < HttpParser::Error
+end
+class HttpParser::Error::INVALID_VERSION < HttpParser::Error
+end
+class HttpParser::Error::INVALID_STATUS < HttpParser::Error
+end
+class HttpParser::Error::INVALID_METHOD < HttpParser::Error
+end
+class HttpParser::Error::INVALID_URL < HttpParser::Error
+end
+class HttpParser::Error::INVALID_HOST < HttpParser::Error
+end
+class HttpParser::Error::INVALID_PORT < HttpParser::Error
+end
+class HttpParser::Error::INVALID_PATH < HttpParser::Error
+end
+class HttpParser::Error::INVALID_QUERY_STRING < HttpParser::Error
+end
+class HttpParser::Error::INVALID_FRAGMENT < HttpParser::Error
+end
+class HttpParser::Error::LF_EXPECTED < HttpParser::Error
+end
+class HttpParser::Error::INVALID_HEADER_TOKEN < HttpParser::Error
+end
+class HttpParser::Error::INVALID_CONTENT_LENGTH < HttpParser::Error
+end
+class HttpParser::Error::INVALID_CHUNK_SIZE < HttpParser::Error
+end
+class HttpParser::Error::INVALID_CONSTANT < HttpParser::Error
+end
+class HttpParser::Error::INVALID_INTERNAL_STATE < HttpParser::Error
+end
+class HttpParser::Error::STRICT < HttpParser::Error
+end
+class HttpParser::Error::PAUSED < HttpParser::Error
+end
+class HttpParser::Error::UNKNOWN < HttpParser::Error
+end
+class HttpParser::Instance < FFI::Struct
+  def data; end
+  def error!; end
+  def error; end
+  def error?; end
+  def final_chunk?; end
+  def flags; end
+  def http_major; end
+  def http_method; end
+  def http_minor; end
+  def http_status; end
+  def http_version; end
+  def initialize(ptr = nil); end
+  def keep_alive?; end
+  def reset!(new_type = nil); end
+  def stop!; end
+  def type; end
+  def type=(new_type); end
+  def upgrade?; end
+end
+class HttpParser::FieldData < FFI::Struct
+end
+class HttpParser::HttpParserUrl < FFI::Struct
+end
+class HttpParser::Settings < FFI::Struct
+end
+class HttpParser::Parser
+  def initialize(callback_obj = nil); end
+  def on_body(&block); end
+  def on_chunk_complete(&block); end
+  def on_chunk_header(&block); end
+  def on_header_field(&block); end
+  def on_header_value(&block); end
+  def on_headers_complete(&block); end
+  def on_message_begin(&block); end
+  def on_message_complete(&block); end
+  def on_status(&block); end
+  def on_url(&block); end
+  def parse(inst, data); end
+  def self.new_instance(&block); end
+end
+class HttpParser::Parser::Callback < FFI::Function
+  def self.new(&block); end
+end
+class HttpParser::Parser::DataCallback < FFI::Function
+  def self.new(&block); end
+end

data/sorbet/rbi/gems/http.rbi

@@ -0,0 +1,616 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/http/all/http.rbi
+#
+# http-4.3.0
+
+module HTTP
+  def self.[](headers); end
+  extend HTTP::Chainable
+end
+class HTTP::Error < StandardError
+end
+class HTTP::ConnectionError < HTTP::Error
+end
+class HTTP::RequestError < HTTP::Error
+end
+class HTTP::ResponseError < HTTP::Error
+end
+class HTTP::StateError < HTTP::ResponseError
+end
+class HTTP::TimeoutError < HTTP::Error
+end
+class HTTP::HeaderError < HTTP::Error
+end
+module HTTP::Timeout
+end
+class HTTP::Timeout::Null
+  def <<(data); end
+  def close(*args, &block); end
+  def closed?(*args, &block); end
+  def connect(socket_class, host, port, nodelay = nil); end
+  def connect_ssl; end
+  def initialize(options = nil); end
+  def options; end
+  def readpartial(size, buffer = nil); end
+  def rescue_readable(timeout = nil); end
+  def rescue_writable(timeout = nil); end
+  def socket; end
+  def start_tls(host, ssl_socket_class, ssl_context); end
+  def write(data); end
+  extend Forwardable
+end
+class HTTP::Timeout::PerOperation < HTTP::Timeout::Null
+  def connect(socket_class, host, port, nodelay = nil); end
+  def connect_ssl; end
+  def initialize(*args); end
+  def readpartial(size, buffer = nil); end
+  def write(data); end
+end
+class HTTP::Timeout::Global < HTTP::Timeout::Null
+  def <<(data); end
+  def connect(socket_class, host, port, nodelay = nil); end
+  def connect_ssl; end
+  def initialize(*args); end
+  def log_time; end
+  def perform_io; end
+  def read_nonblock(size, buffer = nil); end
+  def readpartial(size, buffer = nil); end
+  def reset_counter; end
+  def reset_timer; end
+  def wait_readable_or_timeout; end
+  def wait_writable_or_timeout; end
+  def write(data); end
+  def write_nonblock(data); end
+end
+class HTTP::Headers
+  def ==(other); end
+  def [](name); end
+  def []=(name, value); end
+  def add(name, value); end
+  def delete(name); end
+  def each; end
+  def empty?(*args, &block); end
+  def get(name); end
+  def hash(*args, &block); end
+  def include?(name); end
+  def initialize; end
+  def initialize_copy(orig); end
+  def inspect; end
+  def keys; end
+  def merge!(other); end
+  def merge(other); end
+  def normalize_header(name); end
+  def self.[](object); end
+  def self.coerce(object); end
+  def set(name, value); end
+  def to_a; end
+  def to_h; end
+  def to_hash; end
+  extend Forwardable
+  include Enumerable
+end
+module HTTP::Headers::Mixin
+  def [](*args, &block); end
+  def []=(*args, &block); end
+  def headers; end
+  extend Forwardable
+end
+module HTTP::Chainable
+  def accept(type); end
+  def auth(value); end
+  def basic_auth(opts); end
+  def branch(options); end
+  def build_request(*args); end
+  def connect(uri, options = nil); end
+  def cookies(cookies); end
+  def default_options; end
+  def default_options=(opts); end
+  def delete(uri, options = nil); end
+  def encoding(encoding); end
+  def follow(options = nil); end
+  def get(uri, options = nil); end
+  def head(uri, options = nil); end
+  def headers(headers); end
+  def nodelay; end
+  def options(uri, options = nil); end
+  def patch(uri, options = nil); end
+  def persistent(host, timeout: nil); end
+  def post(uri, options = nil); end
+  def put(uri, options = nil); end
+  def request(*args); end
+  def through(*proxy); end
+  def timeout(options); end
+  def trace(uri, options = nil); end
+  def use(*features); end
+  def via(*proxy); end
+end
+class HTTP::URI
+  def ==(other); end
+  def authority(*args, &block); end
+  def authority=(*args, &block); end
+  def dup; end
+  def eql?(other); end
+  def fragment(*args, &block); end
+  def fragment=(*args, &block); end
+  def hash; end
+  def host(*args, &block); end
+  def host=(*args, &block); end
+  def http?; end
+  def https?; end
+  def initialize(options_or_uri = nil); end
+  def inspect; end
+  def join(*args, &block); end
+  def normalize(*args, &block); end
+  def normalized_authority(*args, &block); end
+  def normalized_fragment(*args, &block); end
+  def normalized_host(*args, &block); end
+  def normalized_password(*args, &block); end
+  def normalized_path(*args, &block); end
+  def normalized_port(*args, &block); end
+  def normalized_query(*args, &block); end
+  def normalized_scheme(*args, &block); end
+  def normalized_user(*args, &block); end
+  def omit(*args, &block); end
+  def origin(*args, &block); end
+  def origin=(*args, &block); end
+  def password(*args, &block); end
+  def password=(*args, &block); end
+  def path(*args, &block); end
+  def path=(*args, &block); end
+  def port; end
+  def port=(*args, &block); end
+  def query(*args, &block); end
+  def query=(*args, &block); end
+  def query_values(*args, &block); end
+  def query_values=(*args, &block); end
+  def request_uri(*args, &block); end
+  def request_uri=(*args, &block); end
+  def scheme(*args, &block); end
+  def scheme=(*args, &block); end
+  def self.form_encode(form_values, sort = nil); end
+  def self.parse(uri); end
+  def to_s; end
+  def to_str; end
+  def user(*args, &block); end
+  def user=(*args, &block); end
+  extend Forwardable
+end
+class HTTP::Options
+  def []=(option, val); end
+  def argument_error!(message); end
+  def body; end
+  def body=(arg0); end
+  def cookies; end
+  def cookies=(arg0); end
+  def dup; end
+  def encoding; end
+  def encoding=(arg0); end
+  def feature(name); end
+  def features; end
+  def features=(features); end
+  def follow; end
+  def follow=(value); end
+  def form; end
+  def form=(arg0); end
+  def headers; end
+  def headers=(arg0); end
+  def initialize(options = nil); end
+  def json; end
+  def json=(arg0); end
+  def keep_alive_timeout; end
+  def keep_alive_timeout=(arg0); end
+  def merge(other); end
+  def nodelay; end
+  def nodelay=(arg0); end
+  def params; end
+  def params=(arg0); end
+  def persistent; end
+  def persistent=(value); end
+  def persistent?; end
+  def proxy; end
+  def proxy=(arg0); end
+  def response; end
+  def response=(arg0); end
+  def self.available_features; end
+  def self.def_option(name, reader_only: nil, &interpreter); end
+  def self.default_socket_class; end
+  def self.default_socket_class=(arg0); end
+  def self.default_ssl_socket_class; end
+  def self.default_ssl_socket_class=(arg0); end
+  def self.default_timeout_class; end
+  def self.default_timeout_class=(arg0); end
+  def self.defined_options; end
+  def self.new(options = nil); end
+  def self.register_feature(name, impl); end
+  def socket_class; end
+  def socket_class=(arg0); end
+  def ssl; end
+  def ssl=(arg0); end
+  def ssl_context; end
+  def ssl_context=(arg0); end
+  def ssl_socket_class; end
+  def ssl_socket_class=(arg0); end
+  def timeout_class; end
+  def timeout_class=(arg0); end
+  def timeout_options; end
+  def timeout_options=(arg0); end
+  def to_hash; end
+  def with_body(value); end
+  def with_cookies(value); end
+  def with_encoding(value); end
+  def with_features(value); end
+  def with_follow(value); end
+  def with_form(value); end
+  def with_headers(value); end
+  def with_json(value); end
+  def with_keep_alive_timeout(value); end
+  def with_nodelay(value); end
+  def with_params(value); end
+  def with_persistent(value); end
+  def with_proxy(value); end
+  def with_response(value); end
+  def with_socket_class(value); end
+  def with_ssl(value); end
+  def with_ssl_context(value); end
+  def with_ssl_socket_class(value); end
+  def with_timeout_class(value); end
+  def with_timeout_options(value); end
+end
+module HTTP::Features
+end
+class HTTP::Features::AutoInflate < HTTP::Feature
+  def stream_for(connection); end
+  def supported_encoding?(response); end
+  def wrap_response(response); end
+end
+class HTTP::Request
+  def body; end
+  def connect_using_proxy(socket); end
+  def default_host_header_value; end
+  def headline; end
+  def host(*args, &block); end
+  def include_proxy_authorization_header; end
+  def include_proxy_headers; end
+  def initialize(opts); end
+  def inspect; end
+  def port; end
+  def prepare_body(body); end
+  def prepare_headers(headers); end
+  def proxy; end
+  def proxy_authorization_header; end
+  def proxy_connect_header; end
+  def proxy_connect_headers; end
+  def redirect(uri, verb = nil); end
+  def scheme; end
+  def socket_host; end
+  def socket_port; end
+  def stream(socket); end
+  def uri; end
+  def uri_normalizer; end
+  def using_authenticated_proxy?; end
+  def using_proxy?; end
+  def verb; end
+  def version; end
+  extend Forwardable
+  include HTTP::Headers::Mixin
+end
+class HTTP::Request::Body
+  def ==(other); end
+  def each(&block); end
+  def initialize(source); end
+  def rewind(io); end
+  def size; end
+  def source; end
+  def validate_source_type!; end
+end
+class HTTP::Request::Body::ProcIO
+  def initialize(block); end
+  def write(data); end
+end
+class HTTP::Features::AutoDeflate < HTTP::Feature
+  def deflated_body(body); end
+  def initialize(**arg0); end
+  def method; end
+  def wrap_request(request); end
+end
+class HTTP::Features::AutoDeflate::CompressedBody < HTTP::Request::Body
+  def compress_all!; end
+  def compressed_each; end
+  def each(&block); end
+  def initialize(uncompressed_body); end
+  def size; end
+end
+class HTTP::Features::AutoDeflate::GzippedBody < HTTP::Features::AutoDeflate::CompressedBody
+  def compress(&block); end
+end
+class HTTP::Features::AutoDeflate::GzippedBody::BlockIO
+  def initialize(block); end
+  def write(data); end
+end
+class HTTP::Features::AutoDeflate::DeflatedBody < HTTP::Features::AutoDeflate::CompressedBody
+  def compress; end
+end
+class HTTP::Features::Logging < HTTP::Feature
+  def initialize(logger: nil); end
+  def logger; end
+  def wrap_request(request); end
+  def wrap_response(response); end
+end
+class HTTP::Features::Logging::NullLogger
+  def debug(*_args); end
+  def debug?; end
+  def error(*_args); end
+  def error?; end
+  def fatal(*_args); end
+  def fatal?; end
+  def info(*_args); end
+  def info?; end
+  def warn(*_args); end
+  def warn?; end
+end
+class HTTP::Features::Instrumentation < HTTP::Feature
+  def initialize(instrumenter: nil, namespace: nil); end
+  def instrumenter; end
+  def name; end
+  def wrap_request(request); end
+  def wrap_response(response); end
+end
+class HTTP::Features::Instrumentation::NullInstrumenter
+  def finish(_name, _payload); end
+  def instrument(name, payload = nil); end
+  def start(_name, _payload); end
+end
+class HTTP::Features::NormalizeUri < HTTP::Feature
+  def initialize(normalizer: nil); end
+  def normalizer; end
+end
+class HTTP::Feature
+  def initialize(opts = nil); end
+  def wrap_request(request); end
+  def wrap_response(response); end
+end
+class HTTP::Response
+  def body; end
+  def charset(*args, &block); end
+  def chunked?; end
+  def code(*args, &block); end
+  def connection(*args, &block); end
+  def content_length; end
+  def content_type; end
+  def cookies; end
+  def flush; end
+  def initialize(opts); end
+  def inspect; end
+  def mime_type(*args, &block); end
+  def parse(as = nil); end
+  def proxy_headers; end
+  def readpartial(*args, &block); end
+  def reason(*args, &block); end
+  def status; end
+  def to_a; end
+  def to_s(*args, &block); end
+  def to_str(*args, &block); end
+  def uri; end
+  def version; end
+  extend Forwardable
+  include HTTP::Headers::Mixin
+end
+class HTTP::Response::Parser
+  def <<(data); end
+  def add(data); end
+  def finished?; end
+  def headers; end
+  def headers?; end
+  def http_version; end
+  def initialize; end
+  def on_body(_response, chunk); end
+  def on_header_field(_response, field); end
+  def on_header_value(_response, value); end
+  def on_headers_complete(_reposse); end
+  def on_message_complete(_response); end
+  def read(size); end
+  def reset; end
+  def status_code; end
+end
+class HTTP::Connection
+  def close; end
+  def expired?; end
+  def failed_proxy_connect?; end
+  def finish_response; end
+  def headers(*args, &block); end
+  def http_version(*args, &block); end
+  def initialize(req, options); end
+  def keep_alive?; end
+  def proxy_response_headers; end
+  def read_headers!; end
+  def read_more(size); end
+  def readpartial(size = nil); end
+  def reset_timer; end
+  def send_proxy_connect_request(req); end
+  def send_request(req); end
+  def set_keep_alive; end
+  def start_tls(req, options); end
+  def status_code(*args, &block); end
+  extend Forwardable
+end
+class HTTP::Redirector
+  def endless_loop?; end
+  def initialize(opts = nil); end
+  def max_hops; end
+  def perform(request, response); end
+  def redirect_to(uri); end
+  def strict; end
+  def too_many_hops?; end
+end
+class HTTP::Redirector::TooManyRedirectsError < HTTP::ResponseError
+end
+class HTTP::Redirector::EndlessRedirectError < HTTP::Redirector::TooManyRedirectsError
+end
+class HTTP::Client
+  def build_request(verb, uri, opts = nil); end
+  def close; end
+  def initialize(default_options = nil); end
+  def make_request_body(opts, headers); end
+  def make_request_headers(opts); end
+  def make_request_uri(uri, opts); end
+  def perform(request, options); end
+  def persistent?(*args, &block); end
+  def request(verb, uri, opts = nil); end
+  def verify_connection!(uri); end
+  extend Forwardable
+  include HTTP::Chainable
+end
+class HTTP::Request::Writer
+  def add_body_type_headers; end
+  def add_headers; end
+  def chunked?; end
+  def connect_through_proxy; end
+  def each_chunk; end
+  def encode_chunk(chunk); end
+  def initialize(socket, body, headers, headline); end
+  def join_headers; end
+  def send_request; end
+  def stream; end
+  def write(data); end
+end
+class HTTP::Request::UnsupportedMethodError < HTTP::RequestError
+end
+class HTTP::Request::UnsupportedSchemeError < HTTP::RequestError
+end
+class HTTP::ContentType < Struct
+  def charset; end
+  def charset=(_); end
+  def mime_type; end
+  def mime_type=(_); end
+  def self.[](*arg0); end
+  def self.charset(str); end
+  def self.inspect; end
+  def self.members; end
+  def self.mime_type(str); end
+  def self.new(*arg0); end
+  def self.parse(str); end
+end
+module HTTP::MimeType
+  def self.[](type); end
+  def self.adapters; end
+  def self.aliases; end
+  def self.normalize(type); end
+  def self.register_adapter(type, adapter); end
+  def self.register_alias(type, shortcut); end
+end
+class HTTP::MimeType::Adapter
+  def decode(*arg0); end
+  def encode(*arg0); end
+  def self.allocate; end
+  def self.decode(*args, &block); end
+  def self.encode(*args, &block); end
+  def self.new(*arg0); end
+  extend Singleton::SingletonClassMethods
+  include Singleton
+end
+class HTTP::MimeType::JSON < HTTP::MimeType::Adapter
+  def decode(str); end
+  def encode(obj); end
+end
+class HTTP::Response::Status < Delegator
+  def __getobj__; end
+  def __setobj__(obj); end
+  def accepted?; end
+  def already_reported?; end
+  def bad_gateway?; end
+  def bad_request?; end
+  def client_error?; end
+  def code; end
+  def conflict?; end
+  def continue?; end
+  def created?; end
+  def expectation_failed?; end
+  def failed_dependency?; end
+  def forbidden?; end
+  def found?; end
+  def gateway_timeout?; end
+  def gone?; end
+  def http_version_not_supported?; end
+  def im_used?; end
+  def informational?; end
+  def inspect; end
+  def insufficient_storage?; end
+  def internal_server_error?; end
+  def length_required?; end
+  def locked?; end
+  def loop_detected?; end
+  def method_not_allowed?; end
+  def misdirected_request?; end
+  def moved_permanently?; end
+  def multi_status?; end
+  def multiple_choices?; end
+  def network_authentication_required?; end
+  def no_content?; end
+  def non_authoritative_information?; end
+  def not_acceptable?; end
+  def not_extended?; end
+  def not_found?; end
+  def not_implemented?; end
+  def not_modified?; end
+  def ok?; end
+  def partial_content?; end
+  def payload_too_large?; end
+  def payment_required?; end
+  def permanent_redirect?; end
+  def precondition_failed?; end
+  def precondition_required?; end
+  def processing?; end
+  def proxy_authentication_required?; end
+  def range_not_satisfiable?; end
+  def reason; end
+  def redirect?; end
+  def request_header_fields_too_large?; end
+  def request_timeout?; end
+  def reset_content?; end
+  def see_other?; end
+  def self.[](object); end
+  def self.coerce(object); end
+  def self.symbolize(str); end
+  def server_error?; end
+  def service_unavailable?; end
+  def success?; end
+  def switching_protocols?; end
+  def temporary_redirect?; end
+  def to_s; end
+  def to_sym; end
+  def too_many_requests?; end
+  def unauthorized?; end
+  def unavailable_for_legal_reasons?; end
+  def unprocessable_entity?; end
+  def unsupported_media_type?; end
+  def upgrade_required?; end
+  def uri_too_long?; end
+  def use_proxy?; end
+  def variant_also_negotiates?; end
+end
+class HTTP::Response::Inflater
+  def connection; end
+  def initialize(connection); end
+  def readpartial(*args); end
+  def zstream; end
+end
+class HTTP::Response::Body
+  def connection; end
+  def each; end
+  def empty?(*args, &block); end
+  def find_encoding(encoding); end
+  def initialize(stream, encoding: nil); end
+  def inspect; end
+  def readpartial(*args); end
+  def stream!; end
+  def to_s; end
+  def to_str; end
+  extend Forwardable
+  include Enumerable
+end