brew/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.13.10.rbi

# typed: true

# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `nokogiri` gem.
# Please instead update this file by running `bin/tapioca gem nokogiri`.

module Nokogiri
  class << self
    def HTML(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
    def HTML4(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
    def HTML5(input, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
    def Slop(*args, &block); end
    def XML(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
    def XSLT(stylesheet, modules = T.unsafe(nil)); end
    def install_default_aliases; end
    def jruby?; end
    def libxml2_patches; end
    def make(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
    def parse(string, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
    def uses_gumbo?; end
    def uses_libxml?(requirement = T.unsafe(nil)); end
  end
end

module Nokogiri::CSS
  class << self
    def parse(selector); end
    def xpath_for(selector, options = T.unsafe(nil)); end
  end
end

class Nokogiri::CSS::Node
  def initialize(type, value); end

  def accept(visitor); end
  def find_by_type(types); end
  def to_a; end
  def to_type; end
  def to_xpath(prefix, visitor); end
  def type; end
  def type=(_arg0); end
  def value; end
  def value=(_arg0); end
end

Nokogiri::CSS::Node::ALLOW_COMBINATOR_ON_SELF = T.let(T.unsafe(nil), Array)

class Nokogiri::CSS::Parser < ::Racc::Parser
  def initialize(namespaces = T.unsafe(nil)); end

  def _reduce_1(val, _values, result); end
  def _reduce_10(val, _values, result); end
  def _reduce_11(val, _values, result); end
  def _reduce_13(val, _values, result); end
  def _reduce_14(val, _values, result); end
  def _reduce_15(val, _values, result); end
  def _reduce_17(val, _values, result); end
  def _reduce_18(val, _values, result); end
  def _reduce_19(val, _values, result); end
  def _reduce_2(val, _values, result); end
  def _reduce_21(val, _values, result); end
  def _reduce_23(val, _values, result); end
  def _reduce_24(val, _values, result); end
  def _reduce_25(val, _values, result); end
  def _reduce_26(val, _values, result); end
  def _reduce_28(val, _values, result); end
  def _reduce_29(val, _values, result); end
  def _reduce_3(val, _values, result); end
  def _reduce_30(val, _values, result); end
  def _reduce_31(val, _values, result); end
  def _reduce_32(val, _values, result); end
  def _reduce_34(val, _values, result); end
  def _reduce_35(val, _values, result); end
  def _reduce_36(val, _values, result); end
  def _reduce_37(val, _values, result); end
  def _reduce_38(val, _values, result); end
  def _reduce_39(val, _values, result); end
  def _reduce_4(val, _values, result); end
  def _reduce_40(val, _values, result); end
  def _reduce_41(val, _values, result); end
  def _reduce_42(val, _values, result); end
  def _reduce_45(val, _values, result); end
  def _reduce_47(val, _values, result); end
  def _reduce_48(val, _values, result); end
  def _reduce_49(val, _values, result); end
  def _reduce_5(val, _values, result); end
  def _reduce_50(val, _values, result); end
  def _reduce_51(val, _values, result); end
  def _reduce_54(val, _values, result); end
  def _reduce_55(val, _values, result); end
  def _reduce_56(val, _values, result); end
  def _reduce_57(val, _values, result); end
  def _reduce_58(val, _values, result); end
  def _reduce_6(val, _values, result); end
  def _reduce_64(val, _values, result); end
  def _reduce_65(val, _values, result); end
  def _reduce_66(val, _values, result); end
  def _reduce_67(val, _values, result); end
  def _reduce_69(val, _values, result); end
  def _reduce_7(val, _values, result); end
  def _reduce_70(val, _values, result); end
  def _reduce_71(val, _values, result); end
  def _reduce_72(val, _values, result); end
  def _reduce_73(val, _values, result); end
  def _reduce_74(val, _values, result); end
  def _reduce_75(val, _values, result); end
  def _reduce_76(val, _values, result); end
  def _reduce_8(val, _values, result); end
  def _reduce_9(val, _values, result); end
  def _reduce_none(val, _values, result); end
  def cache_key(query, prefix, visitor); end
  def next_token; end
  def on_error(error_token_id, error_value, value_stack); end
  def parse(string); end
  def unescape_css_identifier(identifier); end
  def unescape_css_string(str); end
  def xpath_for(string, prefix, visitor); end

  class << self
    def [](string); end
    def []=(string, value); end
    def cache_on?; end
    def clear_cache(create_new_object = T.unsafe(nil)); end
    def set_cache(value); end
    def without_cache(&block); end
  end
end

Nokogiri::CSS::Parser::CACHE_SWITCH_NAME = T.let(T.unsafe(nil), Symbol)
Nokogiri::CSS::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
Nokogiri::CSS::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
class Nokogiri::CSS::SyntaxError < ::Nokogiri::SyntaxError; end

class Nokogiri::CSS::Tokenizer
  def _next_token; end
  def action; end
  def filename; end
  def lineno; end
  def load_file(filename); end
  def next_token; end
  def scan(str); end
  def scan_file(filename); end
  def scan_setup(str); end
  def scan_str(str); end
  def state; end
  def state=(_arg0); end
end

class Nokogiri::CSS::Tokenizer::ScanError < ::StandardError; end

class Nokogiri::CSS::XPathVisitor
  def initialize(builtins: T.unsafe(nil), doctype: T.unsafe(nil)); end

  def accept(node); end
  def config; end
  def visit_attrib_name(node); end
  def visit_attribute_condition(node); end
  def visit_child_selector(node); end
  def visit_class_condition(node); end
  def visit_combinator(node); end
  def visit_conditional_selector(node); end
  def visit_descendant_selector(node); end
  def visit_direct_adjacent_selector(node); end
  def visit_element_name(node); end
  def visit_following_selector(node); end
  def visit_function(node); end
  def visit_id(node); end
  def visit_not(node); end
  def visit_pseudo_class(node); end

  private

  def css_class(hay, needle); end
  def html5_element_name_needs_namespace_handling(node); end
  def is_of_type_pseudo_class?(node); end
  def nth(node, options = T.unsafe(nil)); end
  def read_a_and_positive_b(values); end
end

module Nokogiri::CSS::XPathVisitor::BuiltinsConfig; end
Nokogiri::CSS::XPathVisitor::BuiltinsConfig::ALWAYS = T.let(T.unsafe(nil), Symbol)
Nokogiri::CSS::XPathVisitor::BuiltinsConfig::NEVER = T.let(T.unsafe(nil), Symbol)
Nokogiri::CSS::XPathVisitor::BuiltinsConfig::OPTIMAL = T.let(T.unsafe(nil), Symbol)
Nokogiri::CSS::XPathVisitor::BuiltinsConfig::VALUES = T.let(T.unsafe(nil), Array)
module Nokogiri::CSS::XPathVisitor::DoctypeConfig; end
Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML4 = T.let(T.unsafe(nil), Symbol)
Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML5 = T.let(T.unsafe(nil), Symbol)
Nokogiri::CSS::XPathVisitor::DoctypeConfig::VALUES = T.let(T.unsafe(nil), Array)
Nokogiri::CSS::XPathVisitor::DoctypeConfig::XML = T.let(T.unsafe(nil), Symbol)
Nokogiri::CSS::XPathVisitor::WILDCARD_NAMESPACES = T.let(T.unsafe(nil), TrueClass)

module Nokogiri::CSS::XPathVisitorAlwaysUseBuiltins
  class << self
    def new; end
  end
end

module Nokogiri::CSS::XPathVisitorOptimallyUseBuiltins
  class << self
    def new; end
  end
end

module Nokogiri::ClassResolver
  def related_class(class_name); end
end

Nokogiri::ClassResolver::VALID_NAMESPACES = T.let(T.unsafe(nil), Set)
module Nokogiri::Decorators; end

module Nokogiri::Decorators::Slop
  def method_missing(name, *args, &block); end

  private

  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
end

Nokogiri::Decorators::Slop::XPATH_PREFIX = T.let(T.unsafe(nil), String)

class Nokogiri::EncodingHandler
  def name; end

  class << self
    def [](_arg0); end
    def alias(_arg0, _arg1); end
    def clear_aliases!; end
    def delete(_arg0); end
  end
end

module Nokogiri::Gumbo
  class << self
    def fragment(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5); end
    def parse(_arg0, _arg1, _arg2, _arg3, _arg4); end
  end
end

Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES = T.let(T.unsafe(nil), Integer)
Nokogiri::Gumbo::DEFAULT_MAX_ERRORS = T.let(T.unsafe(nil), Integer)
Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH = T.let(T.unsafe(nil), Integer)
Nokogiri::HTML = Nokogiri::HTML4

module Nokogiri::HTML4
  class << self
    def fragment(string, encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
    def parse(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
  end
end

class Nokogiri::HTML4::Builder < ::Nokogiri::XML::Builder
  def to_html; end
end

class Nokogiri::HTML4::Document < ::Nokogiri::XML::Document
  def fragment(tags = T.unsafe(nil)); end
  def meta_encoding; end
  def meta_encoding=(encoding); end
  def meta_robots(custom_name = T.unsafe(nil)); end
  def nofollow?(custom_name = T.unsafe(nil)); end
  def noindex?(custom_name = T.unsafe(nil)); end
  def serialize(options = T.unsafe(nil)); end
  def title; end
  def title=(text); end
  def type; end
  def xpath_doctype; end

  private

  def meta_content_type; end
  def parse_meta_robots(custom_name); end
  def set_metadata_element(element); end

  class << self
    def new(*_arg0); end
    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
    def read_io(_arg0, _arg1, _arg2, _arg3); end
    def read_memory(_arg0, _arg1, _arg2, _arg3); end
  end
end

class Nokogiri::HTML4::Document::EncodingFound < ::StandardError
  def initialize(encoding); end

  def found_encoding; end
end

class Nokogiri::HTML4::Document::EncodingReader
  def initialize(io); end

  def encoding_found; end
  def read(len); end

  class << self
    def detect_encoding(chunk); end
  end
end

class Nokogiri::HTML4::Document::EncodingReader::JumpSAXHandler < ::Nokogiri::HTML4::Document::EncodingReader::SAXHandler
  def initialize(jumptag); end

  def start_element(name, attrs = T.unsafe(nil)); end
end

class Nokogiri::HTML4::Document::EncodingReader::SAXHandler < ::Nokogiri::XML::SAX::Document
  def initialize; end

  def encoding; end
  def start_element(name, attrs = T.unsafe(nil)); end
end

class Nokogiri::HTML4::DocumentFragment < ::Nokogiri::XML::DocumentFragment
  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end

  class << self
    def parse(tags, encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
  end
end

class Nokogiri::HTML4::ElementDescription
  def block?; end
  def default_sub_element; end
  def deprecated?; end
  def deprecated_attributes; end
  def description; end
  def empty?; end
  def implied_end_tag?; end
  def implied_start_tag?; end
  def inline?; end
  def inspect; end
  def name; end
  def optional_attributes; end
  def required_attributes; end
  def save_end_tag?; end
  def sub_elements; end
  def to_s; end

  private

  def default_desc; end

  class << self
    def [](_arg0); end
  end
end

Nokogiri::HTML4::ElementDescription::ACTION_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::ALIGN_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::ALT_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::APPLET_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::AREA_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::A_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BASEFONT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BGCOLOR_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BLOCK = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BLOCKLI_ELT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BODY_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BODY_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BODY_DEPR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::BUTTON_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::CELLHALIGN = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::CELLVALIGN = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::CLEAR_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::COL_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::COL_ELT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::COMPACT_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::COMPACT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::CONTENT_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::COREATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::CORE_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::CORE_I18N_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::DIR_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::DL_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::DefaultDescriptions = T.let(T.unsafe(nil), Hash)
Nokogiri::HTML4::ElementDescription::Desc = Struct
Nokogiri::HTML4::ElementDescription::EDIT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::EMBED_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::EMPTY = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::EVENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FIELDSET_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FLOW = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FLOW_PARAM = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FONTSTYLE = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FONT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FORMCTRL = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FORM_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FORM_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FRAMESET_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FRAMESET_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::FRAME_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HEADING = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HEAD_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HEAD_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HREF_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HR_DEPR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HTML_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HTML_CDATA = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HTML_CONTENT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HTML_FLOW = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HTML_INLINE = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::HTML_PCDATA = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::I18N = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::I18N_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::IFRAME_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::IMG_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::INLINE = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::INLINE_P = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::INPUT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::LABEL_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::LABEL_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::LANGUAGE_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::LEGEND_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::LINK_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::LIST = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::LI_ELT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::MAP_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::META_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::MODIFIER = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::NAME_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::NOFRAMES_CONTENT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::OBJECT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::OBJECT_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::OBJECT_DEPR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::OL_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::OPTGROUP_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::OPTION_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::OPTION_ELT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::PARAM_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::PCDATA = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::PHRASE = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::PRE_CONTENT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::PROMPT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::QUOTE_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::ROWS_COLS_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::SCRIPT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::SELECT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::SELECT_CONTENT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::SPECIAL = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::SRC_ALT_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::STYLE_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TABLE_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TABLE_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TABLE_DEPR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TALIGN_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TARGET_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TEXTAREA_ATTRS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TH_TD_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TH_TD_DEPR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TR_CONTENTS = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TR_ELT = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::TYPE_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::UL_DEPR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::VERSION_ATTR = T.let(T.unsafe(nil), Array)
Nokogiri::HTML4::ElementDescription::WIDTH_ATTR = T.let(T.unsafe(nil), Array)
class Nokogiri::HTML4::EntityDescription < ::Struct; end

class Nokogiri::HTML4::EntityLookup
  def [](name); end
  def get(_arg0); end
end

Nokogiri::HTML4::NamedCharacters = T.let(T.unsafe(nil), Nokogiri::HTML4::EntityLookup)
module Nokogiri::HTML4::SAX; end

class Nokogiri::HTML4::SAX::Parser < ::Nokogiri::XML::SAX::Parser
  def parse_file(filename, encoding = T.unsafe(nil)); end
  def parse_io(io, encoding = T.unsafe(nil)); end
  def parse_memory(data, encoding = T.unsafe(nil)); end
end

class Nokogiri::HTML4::SAX::ParserContext < ::Nokogiri::XML::SAX::ParserContext
  def parse_with(_arg0); end

  class << self
    def file(_arg0, _arg1); end
    def memory(_arg0, _arg1); end
    def new(thing, encoding = T.unsafe(nil)); end
  end
end

class Nokogiri::HTML4::SAX::PushParser < ::Nokogiri::XML::SAX::PushParser
  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end

  def <<(chunk, last_chunk = T.unsafe(nil)); end
  def document; end
  def document=(_arg0); end
  def finish; end
  def write(chunk, last_chunk = T.unsafe(nil)); end

  private

  def initialize_native(_arg0, _arg1, _arg2); end
  def native_write(_arg0, _arg1); end
end

module Nokogiri::HTML5
  class << self
    def escape_text(text, encoding, attribute_mode); end
    def fragment(string, encoding = T.unsafe(nil), **options); end
    def get(uri, options = T.unsafe(nil)); end
    def get_impl(uri, options = T.unsafe(nil)); end
    def parse(string, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
    def prepend_newline?(node); end
    def read_and_encode(string, encoding); end
    def reencode(body, content_type = T.unsafe(nil)); end
    def serialize_node_internal(current_node, io, encoding, options); end
  end
end

class Nokogiri::HTML5::Document < ::Nokogiri::HTML4::Document
  def fragment(tags = T.unsafe(nil)); end
  def to_xml(options = T.unsafe(nil), &block); end
  def xpath_doctype; end

  class << self
    def do_parse(string_or_io, url, encoding, options); end
    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
    def read_io(io, url = T.unsafe(nil), encoding = T.unsafe(nil), **options); end
    def read_memory(string, url = T.unsafe(nil), encoding = T.unsafe(nil), **options); end
  end
end

class Nokogiri::HTML5::DocumentFragment < ::Nokogiri::HTML4::DocumentFragment
  def initialize(doc, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end

  def document; end
  def document=(_arg0); end
  def errors; end
  def errors=(_arg0); end
  def extract_params(params); end
  def serialize(options = T.unsafe(nil), &block); end

  class << self
    def parse(tags, encoding = T.unsafe(nil), options = T.unsafe(nil)); end
  end
end

Nokogiri::HTML5::HTML_NAMESPACE = T.let(T.unsafe(nil), String)
Nokogiri::HTML5::MATHML_NAMESPACE = T.let(T.unsafe(nil), String)

module Nokogiri::HTML5::Node
  def fragment(tags); end
  def inner_html(options = T.unsafe(nil)); end
  def write_to(io, *options); end

  private

  def add_child_node_and_reparent_attrs(node); end
end

Nokogiri::HTML5::SVG_NAMESPACE = T.let(T.unsafe(nil), String)
Nokogiri::HTML5::XLINK_NAMESPACE = T.let(T.unsafe(nil), String)
Nokogiri::HTML5::XMLNS_NAMESPACE = T.let(T.unsafe(nil), String)
Nokogiri::HTML5::XML_NAMESPACE = T.let(T.unsafe(nil), String)
Nokogiri::LIBXML2_PATCHES = T.let(T.unsafe(nil), Array)
Nokogiri::LIBXML_COMPILED_VERSION = T.let(T.unsafe(nil), String)
Nokogiri::LIBXML_ICONV_ENABLED = T.let(T.unsafe(nil), TrueClass)
Nokogiri::LIBXML_LOADED_VERSION = T.let(T.unsafe(nil), String)
Nokogiri::LIBXML_MEMORY_MANAGEMENT = T.let(T.unsafe(nil), String)
Nokogiri::LIBXSLT_COMPILED_VERSION = T.let(T.unsafe(nil), String)
Nokogiri::LIBXSLT_DATETIME_ENABLED = T.let(T.unsafe(nil), TrueClass)
Nokogiri::LIBXSLT_LOADED_VERSION = T.let(T.unsafe(nil), String)
Nokogiri::LIBXSLT_PATCHES = T.let(T.unsafe(nil), Array)
Nokogiri::OTHER_LIBRARY_VERSIONS = T.let(T.unsafe(nil), String)
Nokogiri::PACKAGED_LIBRARIES = T.let(T.unsafe(nil), TrueClass)
Nokogiri::PRECOMPILED_LIBRARIES = T.let(T.unsafe(nil), TrueClass)
class Nokogiri::SyntaxError < ::StandardError; end

module Nokogiri::Test
  class << self
    def __foreign_error_handler; end
  end
end

Nokogiri::VERSION = T.let(T.unsafe(nil), String)
Nokogiri::VERSION_INFO = T.let(T.unsafe(nil), Hash)

class Nokogiri::VersionInfo
  include ::Singleton
  extend ::Singleton::SingletonClassMethods

  def compiled_libxml_version; end
  def compiled_libxslt_version; end
  def engine; end
  def jruby?; end
  def libxml2?; end
  def libxml2_has_iconv?; end
  def libxml2_precompiled?; end
  def libxml2_using_packaged?; end
  def libxml2_using_system?; end
  def libxslt_has_datetime?; end
  def loaded_libxml_version; end
  def loaded_libxslt_version; end
  def ruby_minor; end
  def to_hash; end
  def to_markdown; end
  def warnings; end
  def windows?; end

  class << self
    def instance; end
  end
end

module Nokogiri::XML
  class << self
    def Reader(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
    def RelaxNG(string_or_io, options = T.unsafe(nil)); end
    def Schema(string_or_io, options = T.unsafe(nil)); end
    def fragment(string, options = T.unsafe(nil), &block); end
    def parse(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
  end
end

class Nokogiri::XML::Attr < ::Nokogiri::XML::Node
  def content=(_arg0); end
  def to_s; end
  def value; end
  def value=(_arg0); end

  private

  def inspect_attributes; end

  class << self
    def new(*_arg0); end
  end
end

class Nokogiri::XML::AttributeDecl < ::Nokogiri::XML::Node
  def attribute_type; end
  def default; end
  def enumeration; end
  def inspect; end
end

class Nokogiri::XML::Builder
  include ::Nokogiri::ClassResolver

  def initialize(options = T.unsafe(nil), root = T.unsafe(nil), &block); end

  def <<(string); end
  def [](ns); end
  def arity; end
  def arity=(_arg0); end
  def cdata(string); end
  def comment(string); end
  def context; end
  def context=(_arg0); end
  def doc; end
  def doc=(_arg0); end
  def method_missing(method, *args, &block); end
  def parent; end
  def parent=(_arg0); end
  def text(string); end
  def to_xml(*args); end

  private

  def insert(node, &block); end

  class << self
    def with(root, &block); end
  end
end

Nokogiri::XML::Builder::DEFAULT_DOCUMENT_OPTIONS = T.let(T.unsafe(nil), Hash)

class Nokogiri::XML::Builder::NodeBuilder
  def initialize(node, doc_builder); end

  def [](k); end
  def []=(k, v); end
  def method_missing(method, *args, &block); end
end

class Nokogiri::XML::CDATA < ::Nokogiri::XML::Text
  def name; end

  class << self
    def new(*_arg0); end
  end
end

class Nokogiri::XML::CharacterData < ::Nokogiri::XML::Node
  include ::Nokogiri::XML::PP::CharacterData
end

class Nokogiri::XML::Comment < ::Nokogiri::XML::CharacterData
  class << self
    def new(*_arg0); end
  end
end

class Nokogiri::XML::DTD < ::Nokogiri::XML::Node
  def attributes; end
  def each; end
  def elements; end
  def entities; end
  def external_id; end
  def html5_dtd?; end
  def html_dtd?; end
  def keys; end
  def notations; end
  def system_id; end
  def validate(_arg0); end
end

class Nokogiri::XML::Document < ::Nokogiri::XML::Node
  def initialize(*args); end

  def <<(node_or_tags); end
  def add_child(node_or_tags); end
  def canonicalize(*_arg0); end
  def clone(*_arg0); end
  def collect_namespaces; end
  def create_cdata(string, &block); end
  def create_comment(string, &block); end
  def create_element(name, *contents_or_attrs, &block); end
  def create_entity(*_arg0); end
  def create_text_node(string, &block); end
  def decorate(node); end
  def decorators(key); end
  def document; end
  def dup(*_arg0); end
  def encoding; end
  def encoding=(_arg0); end
  def errors; end
  def errors=(_arg0); end
  def fragment(tags = T.unsafe(nil)); end
  def name; end
  def namespace_inheritance; end
  def namespace_inheritance=(_arg0); end
  def namespaces; end
  def remove_namespaces!; end
  def root; end
  def root=(_arg0); end
  def slop!; end
  def to_xml(*args, &block); end
  def url; end
  def validate; end
  def version; end
  def xpath_doctype; end

  private

  def inspect_attributes; end

  class << self
    def empty_doc?(string_or_io); end
    def new(*_arg0); end
    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
    def read_io(_arg0, _arg1, _arg2, _arg3); end
    def read_memory(_arg0, _arg1, _arg2, _arg3); end
  end
end

Nokogiri::XML::Document::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
Nokogiri::XML::Document::NCNAME_CHAR = T.let(T.unsafe(nil), String)
Nokogiri::XML::Document::NCNAME_RE = T.let(T.unsafe(nil), Regexp)
Nokogiri::XML::Document::NCNAME_START_CHAR = T.let(T.unsafe(nil), String)

class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end

  def css(*args); end
  def dup; end
  def errors; end
  def errors=(things); end
  def fragment(data); end
  def name; end
  def search(*rules); end
  def serialize; end
  def to_html(*args); end
  def to_s; end
  def to_xhtml(*args); end
  def to_xml(*args); end

  private

  def namespace_declarations(ctx); end

  class << self
    def new(*_arg0); end
    def parse(tags, options = T.unsafe(nil), &block); end
  end
end

class Nokogiri::XML::Element < ::Nokogiri::XML::Node; end

class Nokogiri::XML::ElementContent
  def children; end
  def document; end
  def name; end
  def occur; end
  def prefix; end
  def type; end

  private

  def c1; end
  def c2; end
end

Nokogiri::XML::ElementContent::ELEMENT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ElementContent::MULT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ElementContent::ONCE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ElementContent::OPT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ElementContent::OR = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ElementContent::PCDATA = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ElementContent::PLUS = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ElementContent::SEQ = T.let(T.unsafe(nil), Integer)

class Nokogiri::XML::ElementDecl < ::Nokogiri::XML::Node
  def content; end
  def element_type; end
  def inspect; end
  def prefix; end
end

class Nokogiri::XML::EntityDecl < ::Nokogiri::XML::Node
  def content; end
  def entity_type; end
  def external_id; end
  def inspect; end
  def original_content; end
  def system_id; end

  class << self
    def new(name, doc, *args); end
  end
end

Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_PARSED = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_UNPARSED = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::EntityDecl::EXTERNAL_PARAMETER = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::EntityDecl::INTERNAL_GENERAL = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::EntityDecl::INTERNAL_PARAMETER = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::EntityDecl::INTERNAL_PREDEFINED = T.let(T.unsafe(nil), Integer)

class Nokogiri::XML::EntityReference < ::Nokogiri::XML::Node
  def children; end
  def inspect_attributes; end

  class << self
    def new(*_arg0); end
  end
end

class Nokogiri::XML::Namespace
  include ::Nokogiri::XML::PP::Node

  def document; end
  def href; end
  def prefix; end

  private

  def inspect_attributes; end
end

class Nokogiri::XML::Node
  include ::Nokogiri::HTML5::Node
  include ::Nokogiri::XML::PP::Node
  include ::Nokogiri::XML::Searchable
  include ::Nokogiri::ClassResolver
  include ::Enumerable

  def initialize(name, document); end

  def <<(node_or_tags); end
  def <=>(other); end
  def ==(other); end
  def [](name); end
  def []=(name, value); end
  def accept(visitor); end
  def add_child(node_or_tags); end
  def add_class(names); end
  def add_namespace(_arg0, _arg1); end
  def add_namespace_definition(_arg0, _arg1); end
  def add_next_sibling(node_or_tags); end
  def add_previous_sibling(node_or_tags); end
  def after(node_or_tags); end
  def ancestors(selector = T.unsafe(nil)); end
  def append_class(names); end
  def attr(name); end
  def attribute(_arg0); end
  def attribute_nodes; end
  def attribute_with_ns(_arg0, _arg1); end
  def attributes; end
  def before(node_or_tags); end
  def blank?; end
  def canonicalize(mode = T.unsafe(nil), inclusive_namespaces = T.unsafe(nil), with_comments = T.unsafe(nil)); end
  def cdata?; end
  def child; end
  def children; end
  def children=(node_or_tags); end
  def classes; end
  def clone(*_arg0); end
  def comment?; end
  def content; end
  def content=(string); end
  def create_external_subset(_arg0, _arg1, _arg2); end
  def create_internal_subset(_arg0, _arg1, _arg2); end
  def css_path; end
  def decorate!; end
  def default_namespace=(url); end
  def delete(name); end
  def description; end
  def do_xinclude(options = T.unsafe(nil)); end
  def document; end
  def document?; end
  def dup(*_arg0); end
  def each; end
  def elem?; end
  def element?; end
  def element_children; end
  def elements; end
  def encode_special_chars(_arg0); end
  def external_subset; end
  def first_element_child; end
  def fragment?; end
  def get_attribute(name); end
  def has_attribute?(_arg0); end
  def html?; end
  def inner_html=(node_or_tags); end
  def inner_text; end
  def internal_subset; end
  def key?(_arg0); end
  def keys; end
  def kwattr_add(attribute_name, keywords); end
  def kwattr_append(attribute_name, keywords); end
  def kwattr_remove(attribute_name, keywords); end
  def kwattr_values(attribute_name); end
  def lang; end
  def lang=(_arg0); end
  def last_element_child; end
  def line; end
  def line=(_arg0); end
  def matches?(selector); end
  def name; end
  def name=(_arg0); end
  def namespace; end
  def namespace=(ns); end
  def namespace_definitions; end
  def namespace_scopes; end
  def namespaced_key?(_arg0, _arg1); end
  def namespaces; end
  def native_content=(_arg0); end
  def next; end
  def next=(node_or_tags); end
  def next_element; end
  def next_sibling; end
  def node_name; end
  def node_name=(_arg0); end
  def node_type; end
  def parent; end
  def parent=(parent_node); end
  def parse(string_or_io, options = T.unsafe(nil)); end
  def path; end
  def pointer_id; end
  def prepend_child(node_or_tags); end
  def previous; end
  def previous=(node_or_tags); end
  def previous_element; end
  def previous_sibling; end
  def processing_instruction?; end
  def read_only?; end
  def remove; end
  def remove_attribute(name); end
  def remove_class(names = T.unsafe(nil)); end
  def replace(node_or_tags); end
  def serialize(*args, &block); end
  def set_attribute(name, value); end
  def swap(node_or_tags); end
  def text; end
  def text?; end
  def to_html(options = T.unsafe(nil)); end
  def to_s; end
  def to_str; end
  def to_xhtml(options = T.unsafe(nil)); end
  def to_xml(options = T.unsafe(nil)); end
  def traverse(&block); end
  def type; end
  def unlink; end
  def value?(value); end
  def values; end
  def wrap(html); end
  def write_html_to(io, options = T.unsafe(nil)); end
  def write_xhtml_to(io, options = T.unsafe(nil)); end
  def write_xml_to(io, options = T.unsafe(nil)); end
  def xml?; end

  protected

  def coerce(data); end

  private

  def add_child_node(_arg0); end
  def add_next_sibling_node(_arg0); end
  def add_previous_sibling_node(_arg0); end
  def add_sibling(next_or_previous, node_or_tags); end
  def compare(_arg0); end
  def dump_html; end
  def get(_arg0); end
  def in_context(_arg0, _arg1); end
  def inspect_attributes; end
  def keywordify(keywords); end
  def native_write_to(_arg0, _arg1, _arg2, _arg3); end
  def process_xincludes(_arg0); end
  def replace_node(_arg0); end
  def set(_arg0, _arg1); end
  def set_namespace(_arg0); end
  def to_format(save_option, options); end
  def write_format_to(save_option, io, options); end

  class << self
    def new(*_arg0); end
  end
end

Nokogiri::XML::Node::ATTRIBUTE_DECL = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::ATTRIBUTE_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::CDATA_SECTION_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::COMMENT_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::DOCB_DOCUMENT_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::DOCUMENT_FRAG_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::DOCUMENT_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::DOCUMENT_TYPE_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::DTD_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::ELEMENT_DECL = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::ELEMENT_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::ENTITY_DECL = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::ENTITY_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::ENTITY_REF_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::HTML_DOCUMENT_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
Nokogiri::XML::Node::NAMESPACE_DECL = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::NOTATION_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::PI_NODE = T.let(T.unsafe(nil), Integer)

class Nokogiri::XML::Node::SaveOptions
  def initialize(options = T.unsafe(nil)); end

  def as_html; end
  def as_html?; end
  def as_xhtml; end
  def as_xhtml?; end
  def as_xml; end
  def as_xml?; end
  def default_html; end
  def default_html?; end
  def default_xhtml; end
  def default_xhtml?; end
  def default_xml; end
  def default_xml?; end
  def format; end
  def format?; end
  def no_declaration; end
  def no_declaration?; end
  def no_empty_tags; end
  def no_empty_tags?; end
  def no_xhtml; end
  def no_xhtml?; end
  def options; end
  def to_i; end
end

Nokogiri::XML::Node::SaveOptions::AS_HTML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::AS_XHTML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::AS_XML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::DEFAULT_HTML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::DEFAULT_XHTML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::DEFAULT_XML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::FORMAT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::NO_DECLARATION = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::SaveOptions::NO_XHTML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::TEXT_NODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::XINCLUDE_END = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Node::XINCLUDE_START = T.let(T.unsafe(nil), Integer)

class Nokogiri::XML::NodeSet
  include ::Nokogiri::XML::Searchable
  include ::Enumerable

  def initialize(document, list = T.unsafe(nil)); end

  def %(*args); end
  def &(_arg0); end
  def +(_arg0); end
  def -(_arg0); end
  def <<(_arg0); end
  def ==(other); end
  def [](*_arg0); end
  def add_class(name); end
  def after(datum); end
  def append_class(name); end
  def at(*args); end
  def attr(key, value = T.unsafe(nil), &block); end
  def attribute(key, value = T.unsafe(nil), &block); end
  def before(datum); end
  def children; end
  def clone; end
  def css(*args); end
  def delete(_arg0); end
  def document; end
  def document=(_arg0); end
  def dup; end
  def each; end
  def empty?; end
  def filter(expr); end
  def first(n = T.unsafe(nil)); end
  def include?(_arg0); end
  def index(node = T.unsafe(nil)); end
  def inner_html(*args); end
  def inner_text; end
  def inspect; end
  def last; end
  def length; end
  def pop; end
  def push(_arg0); end
  def remove; end
  def remove_attr(name); end
  def remove_attribute(name); end
  def remove_class(name = T.unsafe(nil)); end
  def reverse; end
  def set(key, value = T.unsafe(nil), &block); end
  def shift; end
  def size; end
  def slice(*_arg0); end
  def text; end
  def to_a; end
  def to_ary; end
  def to_html(*args); end
  def to_s; end
  def to_xhtml(*args); end
  def to_xml(*args); end
  def unlink; end
  def wrap(html); end
  def xpath(*args); end
  def |(_arg0); end
end

Nokogiri::XML::NodeSet::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
class Nokogiri::XML::Notation < ::Struct; end
module Nokogiri::XML::PP; end

module Nokogiri::XML::PP::CharacterData
  def inspect; end
  def pretty_print(pp); end
end

module Nokogiri::XML::PP::Node
  def inspect; end
  def pretty_print(pp); end
end

class Nokogiri::XML::ParseOptions
  def initialize(options = T.unsafe(nil)); end

  def ==(other); end
  def big_lines; end
  def big_lines?; end
  def compact; end
  def compact?; end
  def default_html; end
  def default_html?; end
  def default_schema; end
  def default_schema?; end
  def default_xml; end
  def default_xml?; end
  def default_xslt; end
  def default_xslt?; end
  def dtdattr; end
  def dtdattr?; end
  def dtdload; end
  def dtdload?; end
  def dtdvalid; end
  def dtdvalid?; end
  def huge; end
  def huge?; end
  def inspect; end
  def nobasefix; end
  def nobasefix?; end
  def nobig_lines; end
  def noblanks; end
  def noblanks?; end
  def nocdata; end
  def nocdata?; end
  def nocompact; end
  def nodefault_html; end
  def nodefault_schema; end
  def nodefault_xml; end
  def nodefault_xslt; end
  def nodict; end
  def nodict?; end
  def nodtdattr; end
  def nodtdload; end
  def nodtdvalid; end
  def noent; end
  def noent?; end
  def noerror; end
  def noerror?; end
  def nohuge; end
  def nonet; end
  def nonet?; end
  def nonobasefix; end
  def nonoblanks; end
  def nonocdata; end
  def nonodict; end
  def nonoent; end
  def nonoerror; end
  def nononet; end
  def nonowarning; end
  def nonoxincnode; end
  def nonsclean; end
  def noold10; end
  def nopedantic; end
  def norecover; end
  def nosax1; end
  def nowarning; end
  def nowarning?; end
  def noxinclude; end
  def noxincnode; end
  def noxincnode?; end
  def nsclean; end
  def nsclean?; end
  def old10; end
  def old10?; end
  def options; end
  def options=(_arg0); end
  def pedantic; end
  def pedantic?; end
  def recover; end
  def recover?; end
  def sax1; end
  def sax1?; end
  def strict; end
  def strict?; end
  def to_i; end
  def xinclude; end
  def xinclude?; end
end

Nokogiri::XML::ParseOptions::BIG_LINES = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::COMPACT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::DEFAULT_HTML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::DEFAULT_SCHEMA = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::DEFAULT_XML = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::DEFAULT_XSLT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::DTDATTR = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::DTDLOAD = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::DTDVALID = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::HUGE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NOBASEFIX = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NOBLANKS = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NOCDATA = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NODICT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NOENT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NOERROR = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NONET = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NOWARNING = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NOXINCNODE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::NSCLEAN = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::OLD10 = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::PEDANTIC = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::RECOVER = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::SAX1 = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::STRICT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::ParseOptions::XINCLUDE = T.let(T.unsafe(nil), Integer)

class Nokogiri::XML::ProcessingInstruction < ::Nokogiri::XML::Node
  def initialize(document, name, content); end

  class << self
    def new(*_arg0); end
  end
end

class Nokogiri::XML::Reader
  include ::Enumerable

  def initialize(source, url = T.unsafe(nil), encoding = T.unsafe(nil)); end

  def attribute(_arg0); end
  def attribute_at(_arg0); end
  def attribute_count; end
  def attribute_hash; end
  def attribute_nodes; end
  def attributes; end
  def attributes?; end
  def base_uri; end
  def default?; end
  def depth; end
  def each; end
  def empty_element?; end
  def encoding; end
  def errors; end
  def errors=(_arg0); end
  def inner_xml; end
  def lang; end
  def local_name; end
  def name; end
  def namespace_uri; end
  def namespaces; end
  def node_type; end
  def outer_xml; end
  def prefix; end
  def read; end
  def self_closing?; end
  def source; end
  def state; end
  def value; end
  def value?; end
  def xml_version; end

  class << self
    def from_io(*_arg0); end
    def from_memory(*_arg0); end
  end
end

Nokogiri::XML::Reader::TYPE_ATTRIBUTE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_CDATA = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_COMMENT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_DOCUMENT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_DOCUMENT_FRAGMENT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_DOCUMENT_TYPE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_ELEMENT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_END_ELEMENT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_END_ENTITY = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_ENTITY = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_ENTITY_REFERENCE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_NONE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_NOTATION = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_PROCESSING_INSTRUCTION = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_TEXT = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_WHITESPACE = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::Reader::TYPE_XML_DECLARATION = T.let(T.unsafe(nil), Integer)

class Nokogiri::XML::RelaxNG < ::Nokogiri::XML::Schema
  private

  def validate_document(_arg0); end

  class << self
    def from_document(*_arg0); end
    def read_memory(*_arg0); end
  end
end

module Nokogiri::XML::SAX; end

class Nokogiri::XML::SAX::Document
  def cdata_block(string); end
  def characters(string); end
  def comment(string); end
  def end_document; end
  def end_element(name); end
  def end_element_namespace(name, prefix = T.unsafe(nil), uri = T.unsafe(nil)); end
  def error(string); end
  def processing_instruction(name, content); end
  def start_document; end
  def start_element(name, attrs = T.unsafe(nil)); end
  def start_element_namespace(name, attrs = T.unsafe(nil), prefix = T.unsafe(nil), uri = T.unsafe(nil), ns = T.unsafe(nil)); end
  def warning(string); end
  def xmldecl(version, encoding, standalone); end
end

class Nokogiri::XML::SAX::Parser
  def initialize(doc = T.unsafe(nil), encoding = T.unsafe(nil)); end

  def document; end
  def document=(_arg0); end
  def encoding; end
  def encoding=(_arg0); end
  def parse(thing, &block); end
  def parse_file(filename); end
  def parse_io(io, encoding = T.unsafe(nil)); end
  def parse_memory(data); end

  private

  def check_encoding(encoding); end
end

class Nokogiri::XML::SAX::Parser::Attribute < ::Struct; end
Nokogiri::XML::SAX::Parser::ENCODINGS = T.let(T.unsafe(nil), Hash)

class Nokogiri::XML::SAX::ParserContext
  def column; end
  def line; end
  def parse_with(_arg0); end
  def recovery; end
  def recovery=(_arg0); end
  def replace_entities; end
  def replace_entities=(_arg0); end

  class << self
    def file(_arg0); end
    def io(_arg0, _arg1); end
    def memory(_arg0); end
    def new(thing, encoding = T.unsafe(nil)); end
  end
end

class Nokogiri::XML::SAX::PushParser
  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end

  def <<(chunk, last_chunk = T.unsafe(nil)); end
  def document; end
  def document=(_arg0); end
  def finish; end
  def options; end
  def options=(_arg0); end
  def replace_entities; end
  def replace_entities=(_arg0); end
  def write(chunk, last_chunk = T.unsafe(nil)); end

  private

  def initialize_native(_arg0, _arg1); end
  def native_write(_arg0, _arg1); end
end

class Nokogiri::XML::Schema
  def errors; end
  def errors=(_arg0); end
  def parse_options; end
  def parse_options=(_arg0); end
  def valid?(thing); end
  def validate(thing); end

  private

  def validate_document(_arg0); end
  def validate_file(_arg0); end

  class << self
    def from_document(*_arg0); end
    def new(string_or_io, options = T.unsafe(nil)); end
    def read_memory(*_arg0); end
  end
end

module Nokogiri::XML::Searchable
  def %(*args); end
  def /(*args); end
  def >(selector); end
  def at(*args); end
  def at_css(*args); end
  def at_xpath(*args); end
  def css(*args); end
  def search(*args); end
  def xpath(*args); end

  private

  def css_internal(node, rules, handler, ns); end
  def css_rules_to_xpath(rules, ns); end
  def extract_params(params); end
  def xpath_impl(node, path, handler, ns, binds); end
  def xpath_internal(node, paths, handler, ns, binds); end
  def xpath_query_from_css_rule(rule, ns); end
end

Nokogiri::XML::Searchable::LOOKS_LIKE_XPATH = T.let(T.unsafe(nil), Regexp)

class Nokogiri::XML::SyntaxError < ::Nokogiri::SyntaxError
  def code; end
  def column; end
  def domain; end
  def error?; end
  def fatal?; end
  def file; end
  def int1; end
  def level; end
  def line; end
  def none?; end
  def str1; end
  def str2; end
  def str3; end
  def to_s; end
  def warning?; end

  private

  def level_to_s; end
  def location_to_s; end
  def nil_or_zero?(attribute); end
end

class Nokogiri::XML::Text < ::Nokogiri::XML::CharacterData
  def content=(string); end

  class << self
    def new(*_arg0); end
  end
end

Nokogiri::XML::XML_C14N_1_0 = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::XML_C14N_1_1 = T.let(T.unsafe(nil), Integer)
Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0 = T.let(T.unsafe(nil), Integer)
module Nokogiri::XML::XPath; end
Nokogiri::XML::XPath::CURRENT_SEARCH_PREFIX = T.let(T.unsafe(nil), String)
Nokogiri::XML::XPath::GLOBAL_SEARCH_PREFIX = T.let(T.unsafe(nil), String)
Nokogiri::XML::XPath::ROOT_SEARCH_PREFIX = T.let(T.unsafe(nil), String)
Nokogiri::XML::XPath::SUBTREE_SEARCH_PREFIX = T.let(T.unsafe(nil), String)

class Nokogiri::XML::XPath::SyntaxError < ::Nokogiri::XML::SyntaxError
  def to_s; end
end

class Nokogiri::XML::XPathContext
  def evaluate(*_arg0); end
  def register_namespaces(namespaces); end
  def register_ns(_arg0, _arg1); end
  def register_variable(_arg0, _arg1); end

  class << self
    def new(_arg0); end
  end
end

module Nokogiri::XSLT
  class << self
    def parse(string, modules = T.unsafe(nil)); end
    def quote_params(params); end
    def register(_arg0, _arg1); end
  end
end

class Nokogiri::XSLT::Stylesheet
  def apply_to(document, params = T.unsafe(nil)); end
  def serialize(_arg0); end
  def transform(*_arg0); end

  class << self
    def parse_stylesheet_doc(_arg0); end
  end
end