workos 2.9.0 → 2.11.0

data/sorbet/rbi/gems/{rexml.rbi → rexml@3.2.5.rbi}

@@ -1,207 +1,432 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
+# typed: true
 
-# typed: strict
-#
-# 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/rexml/all/rexml.rbi
-#
-# rexml-3.2.5
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rexml` gem.
+# Please instead update this file by running `bin/tapioca gem rexml`.
 
-module REXML
+class REXML::AttlistDecl < ::REXML::Child
+  include ::Enumerable
+
+  def initialize(source); end
+
+  def [](key); end
+  def each(&block); end
+  def element_name; end
+  def include?(key); end
+  def node_type; end
+  def write(out, indent = T.unsafe(nil)); end
 end
-class REXML::ParseException < RuntimeError
-  def context; end
-  def continued_exception; end
-  def continued_exception=(arg0); end
-  def initialize(message, source = nil, parser = nil, exception = nil); end
-  def line; end
-  def parser; end
-  def parser=(arg0); end
-  def position; end
-  def source; end
-  def source=(arg0); end
+
+class REXML::Attribute
+  include ::REXML::Node
+  include ::REXML::XMLTokens
+  include ::REXML::Namespace
+
+  def initialize(first, second = T.unsafe(nil), parent = T.unsafe(nil)); end
+
+  def ==(other); end
+  def clone; end
+  def doctype; end
+  def element; end
+  def element=(element); end
+  def hash; end
+  def inspect; end
+  def namespace(arg = T.unsafe(nil)); end
+  def node_type; end
+  def normalized=(_arg0); end
+  def prefix; end
+  def remove; end
   def to_s; end
+  def to_string; end
+  def value; end
+  def write(output, indent = T.unsafe(nil)); end
+  def xpath; end
 end
-class REXML::UndefinedNamespaceException < REXML::ParseException
-  def initialize(prefix, source, parser); end
+
+class REXML::Attributes < ::Hash
+  def initialize(element); end
+
+  def <<(attribute); end
+  def [](name); end
+  def []=(name, value); end
+  def add(attribute); end
+  def delete(attribute); end
+  def delete_all(name); end
+  def each; end
+  def each_attribute; end
+  def get_attribute(name); end
+  def get_attribute_ns(namespace, name); end
+  def length; end
+  def namespaces; end
+  def prefixes; end
+  def size; end
+  def to_a; end
+end
+
+class REXML::CData < ::REXML::Text
+  def initialize(first, whitespace = T.unsafe(nil), parent = T.unsafe(nil)); end
+
+  def clone; end
+  def to_s; end
+  def value; end
+  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
+end
+
+class REXML::Child
+  include ::REXML::Node
+
+  def initialize(parent = T.unsafe(nil)); end
+
+  def bytes; end
+  def document; end
+  def next_sibling; end
+  def next_sibling=(other); end
+  def parent; end
+  def parent=(other); end
+  def previous_sibling; end
+  def previous_sibling=(other); end
+  def remove; end
+  def replace_with(child); end
+end
+
+class REXML::Comment < ::REXML::Child
+  include ::Comparable
+
+  def initialize(first, second = T.unsafe(nil)); end
+
+  def <=>(other); end
+  def ==(other); end
+  def clone; end
+  def node_type; end
+  def string; end
+  def string=(_arg0); end
+  def to_s; end
+  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
+end
+
+module REXML::DClonable; end
+
+class REXML::Declaration < ::REXML::Child
+  def initialize(src); end
+
+  def to_s; end
+  def write(output, indent); end
+end
+
+class REXML::DocType < ::REXML::Parent
+  include ::REXML::XMLTokens
+
+  def initialize(first, parent = T.unsafe(nil)); end
+
+  def add(child); end
+  def attribute_of(element, attribute); end
+  def attributes_of(element); end
+  def clone; end
+  def context; end
+  def entities; end
+  def entity(name); end
+  def external_id; end
+  def name; end
+  def namespaces; end
+  def node_type; end
+  def notation(name); end
+  def notations; end
+  def public; end
+  def system; end
+  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
+end
+
+class REXML::Document < ::REXML::Element
+  def initialize(source = T.unsafe(nil), context = T.unsafe(nil)); end
+
+  def <<(child); end
+  def add(child); end
+  def add_element(arg = T.unsafe(nil), arg2 = T.unsafe(nil)); end
+  def clone; end
+  def doctype; end
+  def document; end
+  def encoding; end
+  def entity_expansion_count; end
+  def expanded_name; end
+  def name; end
+  def node_type; end
+  def record_entity_expansion; end
+  def root; end
+  def stand_alone?; end
+  def version; end
+  def write(*arguments); end
+  def xml_decl; end
+
+  private
+
+  def build(source); end
+
+  class << self
+    def entity_expansion_limit; end
+    def entity_expansion_limit=(val); end
+    def entity_expansion_text_limit; end
+    def entity_expansion_text_limit=(val); end
+    def parse_stream(source, listener); end
+  end
+end
+
+class REXML::Element < ::REXML::Parent
+  include ::REXML::XMLTokens
+  include ::REXML::Namespace
+
+  def initialize(arg = T.unsafe(nil), parent = T.unsafe(nil), context = T.unsafe(nil)); end
+
+  def [](name_or_index); end
+  def add_attribute(key, value = T.unsafe(nil)); end
+  def add_attributes(hash); end
+  def add_element(element, attrs = T.unsafe(nil)); end
+  def add_namespace(prefix, uri = T.unsafe(nil)); end
+  def add_text(text); end
+  def attribute(name, namespace = T.unsafe(nil)); end
+  def attributes; end
+  def cdatas; end
+  def clone; end
+  def comments; end
+  def context; end
+  def context=(_arg0); end
+  def delete_attribute(key); end
+  def delete_element(element); end
+  def delete_namespace(namespace = T.unsafe(nil)); end
+  def document; end
+  def each_element(xpath = T.unsafe(nil), &block); end
+  def each_element_with_attribute(key, value = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
+  def each_element_with_text(text = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
+  def elements; end
+  def get_elements(xpath); end
+  def get_text(path = T.unsafe(nil)); end
+  def has_attributes?; end
+  def has_elements?; end
+  def has_text?; end
+  def ignore_whitespace_nodes; end
+  def inspect; end
+  def instructions; end
+  def namespace(prefix = T.unsafe(nil)); end
+  def namespaces; end
+  def next_element; end
+  def node_type; end
+  def prefixes; end
+  def previous_element; end
+  def raw; end
+  def root; end
+  def root_node; end
+  def text(path = T.unsafe(nil)); end
+  def text=(text); end
+  def texts; end
+  def whitespace; end
+  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
+  def xpath; end
+
+  private
+
+  def __to_xpath_helper(node); end
+  def each_with_something(test, max = T.unsafe(nil), name = T.unsafe(nil)); end
+end
+
+class REXML::ElementDecl < ::REXML::Declaration
+  def initialize(src); end
 end
+
+class REXML::Elements
+  include ::Enumerable
+
+  def initialize(parent); end
+
+  def <<(element = T.unsafe(nil)); end
+  def [](index, name = T.unsafe(nil)); end
+  def []=(index, element); end
+  def add(element = T.unsafe(nil)); end
+  def collect(xpath = T.unsafe(nil)); end
+  def delete(element); end
+  def delete_all(xpath); end
+  def each(xpath = T.unsafe(nil)); end
+  def empty?; end
+  def index(element); end
+  def inject(xpath = T.unsafe(nil), initial = T.unsafe(nil)); end
+  def parent; end
+  def size; end
+  def to_a(xpath = T.unsafe(nil)); end
+
+  private
+
+  def literalize(name); end
+end
+
 module REXML::Encoding
   def decode(string); end
   def encode(string); end
   def encoding; end
   def encoding=(encoding); end
+
+  private
+
   def find_encoding(name); end
 end
-class REXML::SourceFactory
-  def self.create_from(arg); end
+
+class REXML::Entity < ::REXML::Child
+  include ::REXML::XMLTokens
+
+  def initialize(stream, value = T.unsafe(nil), parent = T.unsafe(nil), reference = T.unsafe(nil)); end
+
+  def external; end
+  def name; end
+  def ndata; end
+  def normalized; end
+  def pubid; end
+  def ref; end
+  def to_s; end
+  def unnormalized; end
+  def value; end
+  def write(out, indent = T.unsafe(nil)); end
+
+  class << self
+    def matches?(string); end
+  end
 end
-class REXML::Source
-  def buffer; end
-  def consume(pattern); end
-  def current_line; end
-  def detect_encoding; end
-  def empty?; end
-  def encoding; end
-  def encoding=(enc); end
-  def encoding_updated; end
-  def initialize(arg, encoding = nil); end
-  def line; end
-  def match(pattern, cons = nil); end
-  def match_to(char, pattern); end
-  def match_to_consume(char, pattern); end
-  def position; end
-  def read; end
-  def scan(pattern, cons = nil); end
-  include REXML::Encoding
+
+class REXML::ExternalEntity < ::REXML::Child
+  def initialize(src); end
+
+  def to_s; end
+  def write(output, indent); end
 end
-class REXML::IOSource < REXML::Source
+
+class REXML::Formatters::Default
+  def initialize(ie_hack = T.unsafe(nil)); end
+
+  def write(node, output); end
+
+  protected
+
+  def write_cdata(node, output); end
+  def write_comment(node, output); end
+  def write_document(node, output); end
+  def write_element(node, output); end
+  def write_instruction(node, output); end
+  def write_text(node, output); end
+end
+
+class REXML::Formatters::Pretty < ::REXML::Formatters::Default
+  def initialize(indentation = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
+
+  def compact; end
+  def compact=(_arg0); end
+  def width; end
+  def width=(_arg0); end
+
+  protected
+
+  def write_cdata(node, output); end
+  def write_comment(node, output); end
+  def write_document(node, output); end
+  def write_element(node, output); end
+  def write_text(node, output); end
+
+  private
+
+  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
+  def wrap(string, width); end
+end
+
+class REXML::IOSource < ::REXML::Source
+  def initialize(arg, block_size = T.unsafe(nil), encoding = T.unsafe(nil)); end
+
   def consume(pattern); end
   def current_line; end
   def empty?; end
-  def encoding_updated; end
-  def initialize(arg, block_size = nil, encoding = nil); end
-  def match(pattern, cons = nil); end
+  def match(pattern, cons = T.unsafe(nil)); end
   def position; end
   def read; end
+  def scan(pattern, cons = T.unsafe(nil)); end
+
+  private
+
+  def encoding_updated; end
   def readline; end
-  def scan(pattern, cons = nil); end
-end
-module REXML::Parsers
 end
-class REXML::Parsers::BaseParser
-  def add_listener(listener); end
-  def empty?; end
-  def entity(reference, entities); end
-  def has_next?; end
-  def initialize(source); end
-  def need_source_encoding_update?(xml_declaration_encoding); end
-  def normalize(input, entities = nil, entity_filter = nil); end
-  def parse_attributes(prefixes, curr_ns); end
-  def parse_id(base_error_message, accept_external_id:, accept_public_id:); end
-  def parse_id_invalid_details(accept_external_id:, accept_public_id:); end
-  def parse_name(base_error_message); end
-  def peek(depth = nil); end
-  def position; end
-  def process_instruction; end
-  def pull; end
-  def pull_event; end
-  def source; end
-  def stream=(source); end
-  def unnormalize(string, entities = nil, filter = nil); end
-  def unshift(token); end
-end
-class REXML::Parsers::StreamParser
-  def add_listener(listener); end
-  def initialize(source, listener); end
-  def parse; end
-end
-module REXML::XMLTokens
-end
-module REXML::Light
+
+class REXML::Instruction < ::REXML::Child
+  def initialize(target, content = T.unsafe(nil)); end
+
+  def ==(other); end
+  def clone; end
+  def content; end
+  def content=(_arg0); end
+  def inspect; end
+  def node_type; end
+  def target; end
+  def target=(_arg0); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
+
+module REXML::Light; end
+
 class REXML::Light::Node
+  def initialize(node = T.unsafe(nil)); end
+
   def <<(element); end
   def =~(path); end
-  def [](reference, ns = nil); end
-  def []=(reference, ns, value = nil); end
+  def [](reference, ns = T.unsafe(nil)); end
+  def []=(reference, ns, value = T.unsafe(nil)); end
   def children; end
   def each; end
-  def has_name?(name, namespace = nil); end
-  def initialize(node = nil); end
+  def has_name?(name, namespace = T.unsafe(nil)); end
   def local_name; end
   def local_name=(name_str); end
   def name; end
-  def name=(name_str, ns = nil); end
-  def namespace(prefix = nil); end
+  def name=(name_str, ns = T.unsafe(nil)); end
+  def namespace(prefix = T.unsafe(nil)); end
   def namespace=(namespace); end
-  def namespace_of(node, prefix = nil); end
-  def namesplit; end
   def node_type; end
   def parent; end
   def parent=(node); end
-  def prefix(namespace = nil); end
-  def prefix_of(node, namespace = nil); end
+  def prefix(namespace = T.unsafe(nil)); end
   def root; end
   def size; end
   def text=(foo); end
   def to_s; end
+
+  private
+
+  def namespace_of(node, prefix = T.unsafe(nil)); end
+  def namesplit; end
+  def prefix_of(node, namespace = T.unsafe(nil)); end
 end
-module REXML::Security
-  def self.entity_expansion_limit; end
-  def self.entity_expansion_limit=(val); end
-  def self.entity_expansion_text_limit; end
-  def self.entity_expansion_text_limit=(val); end
-end
-module REXML::Formatters
-end
-class REXML::Formatters::Default
-  def initialize(ie_hack = nil); end
-  def write(node, output); end
-  def write_cdata(node, output); end
-  def write_comment(node, output); end
-  def write_document(node, output); end
-  def write_element(node, output); end
-  def write_instruction(node, output); end
-  def write_text(node, output); end
-end
-class REXML::Formatters::Pretty < REXML::Formatters::Default
-  def compact; end
-  def compact=(arg0); end
-  def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
-  def initialize(indentation = nil, ie_hack = nil); end
-  def width; end
-  def width=(arg0); end
-  def wrap(string, width); end
-  def write_cdata(node, output); end
-  def write_comment(node, output); end
-  def write_document(node, output); end
-  def write_element(node, output); end
-  def write_text(node, output); end
-end
-module REXML::Node
-  def each_recursive(&block); end
-  def find_first_recursive(&block); end
-  def indent(to, ind); end
-  def index_in_parent; end
-  def next_sibling_node; end
-  def parent?; end
-  def previous_sibling_node; end
-  def to_s(indent = nil); end
-end
-class REXML::Child
-  def bytes; end
-  def document; end
-  def initialize(parent = nil); end
-  def next_sibling; end
-  def next_sibling=(other); end
-  def parent; end
-  def parent=(other); end
-  def previous_sibling; end
-  def previous_sibling=(other); end
-  def remove; end
-  def replace_with(child); end
-  include REXML::Node
-end
-class REXML::Entity < REXML::Child
-  def external; end
-  def initialize(stream, value = nil, parent = nil, reference = nil); end
+
+REXML::Light::Node::NAMESPLIT = T.let(T.unsafe(nil), Regexp)
+REXML::Light::Node::PARENTS = T.let(T.unsafe(nil), Array)
+
+class REXML::NotationDecl < ::REXML::Child
+  def initialize(name, middle, pub, sys); end
+
   def name; end
-  def ndata; end
-  def normalized; end
-  def pubid; end
-  def ref; end
-  def self.matches?(string); end
+  def public; end
+  def public=(_arg0); end
+  def system; end
+  def system=(_arg0); end
   def to_s; end
-  def unnormalized; end
-  def value; end
-  def write(out, indent = nil); end
-  include REXML::XMLTokens
+  def write(output, indent = T.unsafe(nil)); end
 end
-module REXML::EntityConst
+
+class REXML::Output
+  include ::REXML::Encoding
+
+  def initialize(real_IO, encd = T.unsafe(nil)); end
+
+  def <<(content); end
+  def encoding; end
+  def to_s; end
 end
-class REXML::Parent < REXML::Child
+
+class REXML::Parent < ::REXML::Child
+  include ::Enumerable
+
+  def initialize(parent = T.unsafe(nil)); end
+
   def <<(object); end
   def [](index); end
   def []=(*args); end
@@ -215,7 +440,6 @@ class REXML::Parent < REXML::Child
   def each_child(&block); end
   def each_index(&block); end
   def index(child); end
-  def initialize(parent = nil); end
   def insert_after(child1, child2); end
   def insert_before(child1, child2); end
   def length; end
@@ -225,136 +449,82 @@ class REXML::Parent < REXML::Child
   def size; end
   def to_a; end
   def unshift(object); end
-  include Enumerable
 end
-module REXML::Namespace
-  def expanded_name; end
-  def fully_expanded_name; end
-  def has_name?(other, ns = nil); end
-  def local_name; end
-  def name; end
-  def name=(name); end
-  def prefix; end
-  def prefix=(arg0); end
-  include REXML::XMLTokens
-end
-class REXML::AttlistDecl < REXML::Child
-  def [](key); end
-  def each(&block); end
-  def element_name; end
-  def include?(key); end
-  def initialize(source); end
-  def node_type; end
-  def write(out, indent = nil); end
-  include Enumerable
-end
-class REXML::ReferenceWriter
-  def initialize(id_type, public_id_literal, system_literal, context = nil); end
-  def write(output); end
-end
-class REXML::DocType < REXML::Parent
-  def add(child); end
-  def attribute_of(element, attribute); end
-  def attributes_of(element); end
-  def clone; end
+
+class REXML::ParseException < ::RuntimeError
+  def initialize(message, source = T.unsafe(nil), parser = T.unsafe(nil), exception = T.unsafe(nil)); end
+
   def context; end
-  def entities; end
-  def entity(name); end
-  def external_id; end
-  def initialize(first, parent = nil); end
-  def name; end
-  def namespaces; end
-  def node_type; end
-  def notation(name); end
-  def notations; end
-  def public; end
-  def system; end
-  def write(output, indent = nil, transitive = nil, ie_hack = nil); end
-  include REXML::XMLTokens
-end
-class REXML::Declaration < REXML::Child
-  def initialize(src); end
-  def to_s; end
-  def write(output, indent); end
-end
-class REXML::ElementDecl < REXML::Declaration
-  def initialize(src); end
-end
-class REXML::ExternalEntity < REXML::Child
-  def initialize(src); end
-  def to_s; end
-  def write(output, indent); end
-end
-class REXML::NotationDecl < REXML::Child
-  def initialize(name, middle, pub, sys); end
-  def name; end
-  def public; end
-  def public=(arg0); end
-  def system; end
-  def system=(arg0); end
+  def continued_exception; end
+  def continued_exception=(_arg0); end
+  def line; end
+  def parser; end
+  def parser=(_arg0); end
+  def position; end
+  def source; end
+  def source=(_arg0); end
   def to_s; end
-  def write(output, indent = nil); end
 end
-class REXML::Text < REXML::Child
-  def <<(to_append); end
-  def <=>(other); end
-  def clear_cache; end
-  def clone; end
-  def doctype; end
+
+class REXML::Parsers::BaseParser
+  def initialize(source); end
+
+  def add_listener(listener); end
   def empty?; end
-  def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
-  def initialize(arg, respect_whitespace = nil, parent = nil, raw = nil, entity_filter = nil, illegal = nil); end
-  def inspect; end
-  def node_type; end
-  def parent=(parent); end
-  def raw; end
-  def raw=(arg0); end
-  def self.check(string, pattern, doctype); end
-  def self.expand(ref, doctype, filter); end
-  def self.normalize(input, doctype = nil, entity_filter = nil); end
-  def self.read_with_substitution(input, illegal = nil); end
-  def self.unnormalize(string, doctype = nil, filter = nil, illegal = nil); end
-  def to_s; end
-  def value; end
-  def value=(val); end
-  def wrap(string, width, addnewline = nil); end
-  def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
-  def write_with_substitution(out, input); end
-  def xpath; end
-  include Comparable
-end
-class REXML::Attribute
-  def ==(other); end
-  def clone; end
-  def doctype; end
-  def element; end
-  def element=(element); end
-  def hash; end
-  def initialize(first, second = nil, parent = nil); end
-  def inspect; end
-  def namespace(arg = nil); end
-  def node_type; end
-  def normalized=(arg0); end
-  def prefix; end
-  def remove; end
-  def to_s; end
-  def to_string; end
-  def value; end
-  def write(output, indent = nil); end
-  def xpath; end
-  include REXML::Namespace
-  include REXML::Node
+  def entity(reference, entities); end
+  def has_next?; end
+  def normalize(input, entities = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
+  def peek(depth = T.unsafe(nil)); end
+  def position; end
+  def pull; end
+  def source; end
+  def stream=(source); end
+  def unnormalize(string, entities = T.unsafe(nil), filter = T.unsafe(nil)); end
+  def unshift(token); end
+
+  private
+
+  def need_source_encoding_update?(xml_declaration_encoding); end
+  def parse_attributes(prefixes, curr_ns); end
+  def parse_id(base_error_message, accept_external_id:, accept_public_id:); end
+  def parse_id_invalid_details(accept_external_id:, accept_public_id:); end
+  def parse_name(base_error_message); end
+  def process_instruction; end
+  def pull_event; end
 end
-class REXML::CData < REXML::Text
-  def clone; end
-  def initialize(first, whitespace = nil, parent = nil); end
-  def to_s; end
-  def value; end
-  def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
+
+REXML::Parsers::BaseParser::EXTERNAL_ID_PUBLIC = T.let(T.unsafe(nil), Regexp)
+REXML::Parsers::BaseParser::EXTERNAL_ID_SYSTEM = T.let(T.unsafe(nil), Regexp)
+REXML::Parsers::BaseParser::PUBLIC_ID = T.let(T.unsafe(nil), Regexp)
+REXML::Parsers::BaseParser::QNAME = T.let(T.unsafe(nil), Regexp)
+REXML::Parsers::BaseParser::QNAME_STR = T.let(T.unsafe(nil), String)
+
+class REXML::Parsers::StreamParser
+  def initialize(source, listener); end
+
+  def add_listener(listener); end
+  def parse; end
 end
-module REXML::Functions
+
+class REXML::Parsers::TreeParser
+  def initialize(source, build_context = T.unsafe(nil)); end
+
+  def add_listener(listener); end
+  def parse; end
 end
+
 class REXML::Parsers::XPathParser
+  include ::REXML::XMLTokens
+
+  def abbreviate(path); end
+  def expand(path); end
+  def namespaces=(namespaces); end
+  def parse(path); end
+  def predicate(path); end
+  def predicate_to_string(path, &block); end
+
+  private
+
   def AdditiveExpr(path, parsed); end
   def AndExpr(path, parsed); end
   def EqualityExpr(path, parsed); end
@@ -371,258 +541,169 @@ class REXML::Parsers::XPathParser
   def RelativeLocationPath(path, parsed); end
   def UnaryExpr(path, parsed); end
   def UnionExpr(path, parsed); end
-  def abbreviate(path); end
-  def expand(path); end
   def get_group(string); end
-  def namespaces=(namespaces); end
-  def parse(path); end
   def parse_args(string); end
-  def predicate(path); end
-  def predicate_to_string(path, &block); end
-  include REXML::XMLTokens
 end
-module REXML::DClonable
-end
-class REXML::XPathParser
-  def []=(variable_name, value); end
-  def child(nodeset); end
-  def compare(a, operator, b); end
-  def descendant(nodeset, include_self); end
-  def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
-  def each_unnode(nodeset); end
-  def enter(tag, *args); end
-  def equality_relational_compare(set1, op, set2); end
-  def evaluate_predicate(expression, nodesets); end
-  def expr(path_stack, nodeset, context = nil); end
-  def filter_nodeset(nodeset); end
-  def first(path_stack, node); end
-  def following(node); end
-  def following_node_of(node); end
-  def get_first(path, nodeset); end
-  def get_namespace(node, prefix); end
-  def initialize(strict: nil); end
-  def leave(tag, *args); end
-  def match(path_stack, nodeset); end
-  def namespaces=(namespaces = nil); end
-  def next_sibling_node(node); end
-  def node_test(path_stack, nodesets, any_type: nil); end
-  def norm(b); end
-  def normalize_compare_values(a, operator, b); end
-  def parse(path, nodeset); end
-  def preceding(node); end
-  def preceding_node_of(node); end
-  def predicate(path, nodeset); end
-  def sort(array_of_nodes, order); end
-  def step(path_stack, any_type: nil, order: nil); end
-  def strict?; end
-  def trace(*args); end
-  def unnode(nodeset); end
-  def value_type(value); end
-  def variables=(vars = nil); end
-  include REXML::XMLTokens
+
+REXML::Parsers::XPathParser::LOCAL_NAME_WILDCARD = T.let(T.unsafe(nil), Regexp)
+REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp)
+
+class REXML::ReferenceWriter
+  def initialize(id_type, public_id_literal, system_literal, context = T.unsafe(nil)); end
+
+  def write(output); end
 end
-class REXML::XPathNode
-  def context; end
-  def initialize(node, context = nil); end
+
+class REXML::Source
+  include ::REXML::Encoding
+
+  def initialize(arg, encoding = T.unsafe(nil)); end
+
+  def buffer; end
+  def consume(pattern); end
+  def current_line; end
+  def empty?; end
+  def encoding; end
+  def encoding=(enc); end
+  def line; end
+  def match(pattern, cons = T.unsafe(nil)); end
+  def match_to(char, pattern); end
+  def match_to_consume(char, pattern); end
   def position; end
-  def raw_node; end
-end
-class REXML::XPath
-  def self.each(element, path = nil, namespaces = nil, variables = nil, options = nil, &block); end
-  def self.first(element, path = nil, namespaces = nil, variables = nil, options = nil); end
-  def self.match(element, path = nil, namespaces = nil, variables = nil, options = nil); end
-  include REXML::Functions
+  def read; end
+  def scan(pattern, cons = T.unsafe(nil)); end
+
+  private
+
+  def detect_encoding; end
+  def encoding_updated; end
 end
-class REXML::Element < REXML::Parent
-  def [](name_or_index); end
-  def __to_xpath_helper(node); end
-  def add_attribute(key, value = nil); end
-  def add_attributes(hash); end
-  def add_element(element, attrs = nil); end
-  def add_namespace(prefix, uri = nil); end
-  def add_text(text); end
-  def attribute(name, namespace = nil); end
-  def attributes; end
-  def cdatas; end
+
+class REXML::Text < ::REXML::Child
+  include ::Comparable
+
+  def initialize(arg, respect_whitespace = T.unsafe(nil), parent = T.unsafe(nil), raw = T.unsafe(nil), entity_filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
+
+  def <<(to_append); end
+  def <=>(other); end
   def clone; end
-  def comments; end
-  def context; end
-  def context=(arg0); end
-  def delete_attribute(key); end
-  def delete_element(element); end
-  def delete_namespace(namespace = nil); end
-  def document; end
-  def each_element(xpath = nil, &block); end
-  def each_element_with_attribute(key, value = nil, max = nil, name = nil, &block); end
-  def each_element_with_text(text = nil, max = nil, name = nil, &block); end
-  def each_with_something(test, max = nil, name = nil); end
-  def elements; end
-  def get_elements(xpath); end
-  def get_text(path = nil); end
-  def has_attributes?; end
-  def has_elements?; end
-  def has_text?; end
-  def ignore_whitespace_nodes; end
-  def initialize(arg = nil, parent = nil, context = nil); end
+  def doctype; end
+  def empty?; end
+  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
   def inspect; end
-  def instructions; end
-  def namespace(prefix = nil); end
-  def namespaces; end
-  def next_element; end
   def node_type; end
-  def prefixes; end
-  def previous_element; end
+  def parent=(parent); end
   def raw; end
-  def root; end
-  def root_node; end
-  def text(path = nil); end
-  def text=(text); end
-  def texts; end
-  def whitespace; end
-  def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
+  def raw=(_arg0); end
+  def to_s; end
+  def value; end
+  def value=(val); end
+  def wrap(string, width, addnewline = T.unsafe(nil)); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
+  def write_with_substitution(out, input); end
   def xpath; end
-  include REXML::Namespace
+
+  private
+
+  def clear_cache; end
+
+  class << self
+    def check(string, pattern, doctype); end
+    def expand(ref, doctype, filter); end
+    def normalize(input, doctype = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
+    def read_with_substitution(input, illegal = T.unsafe(nil)); end
+    def unnormalize(string, doctype = T.unsafe(nil), filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
+  end
 end
-class REXML::Elements
-  def <<(element = nil); end
-  def [](index, name = nil); end
-  def []=(index, element); end
-  def add(element = nil); end
-  def collect(xpath = nil); end
-  def delete(element); end
-  def delete_all(xpath); end
-  def each(xpath = nil); end
-  def empty?; end
-  def index(element); end
-  def initialize(parent); end
-  def inject(xpath = nil, initial = nil); end
-  def literalize(name); end
-  def parent; end
-  def size; end
-  def to_a(xpath = nil); end
-  include Enumerable
+
+class REXML::UndefinedNamespaceException < ::REXML::ParseException
+  def initialize(prefix, source, parser); end
 end
-class REXML::Attributes < Hash
-  def <<(attribute); end
-  def [](name); end
-  def []=(name, value); end
-  def add(attribute); end
-  def delete(attribute); end
-  def delete_all(name); end
-  def each; end
-  def each_attribute; end
-  def get_attribute(name); end
-  def get_attribute_ns(namespace, name); end
-  def initialize(element); end
-  def length; end
-  def namespaces; end
-  def prefixes; end
-  def size; end
-  def to_a; end
+
+class REXML::Validation::ValidationException < ::RuntimeError
+  def initialize(msg); end
 end
-class REXML::XMLDecl < REXML::Child
+
+class REXML::XMLDecl < ::REXML::Child
+  include ::REXML::Encoding
+
+  def initialize(version = T.unsafe(nil), encoding = T.unsafe(nil), standalone = T.unsafe(nil)); end
+
   def ==(other); end
   def clone; end
-  def content(enc); end
   def dowrite; end
   def encoding=(enc); end
-  def initialize(version = nil, encoding = nil, standalone = nil); end
   def inspect; end
   def node_type; end
   def nowrite; end
   def old_enc=(encoding); end
-  def self.default; end
   def stand_alone?; end
   def standalone; end
-  def standalone=(arg0); end
+  def standalone=(_arg0); end
   def version; end
-  def version=(arg0); end
-  def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
+  def version=(_arg0); end
+  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
   def writeencoding; end
   def writethis; end
   def xmldecl(version, encoding, standalone); end
-  include REXML::Encoding
-end
-class REXML::Comment < REXML::Child
-  def <=>(other); end
-  def ==(other); end
-  def clone; end
-  def initialize(first, second = nil); end
-  def node_type; end
-  def string; end
-  def string=(arg0); end
-  def to_s; end
-  def write(output, indent = nil, transitive = nil, ie_hack = nil); end
-  include Comparable
-end
-class REXML::Instruction < REXML::Child
-  def ==(other); end
-  def clone; end
-  def content; end
-  def content=(arg0); end
-  def initialize(target, content = nil); end
-  def inspect; end
-  def node_type; end
-  def target; end
-  def target=(arg0); end
-  def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
-end
-class REXML::Output
-  def <<(content); end
-  def encoding; end
-  def initialize(real_IO, encd = nil); end
-  def to_s; end
-  include REXML::Encoding
-end
-module REXML::Validation
-end
-class REXML::Validation::ValidationException < RuntimeError
-  def initialize(msg); end
-end
-class REXML::Parsers::TreeParser
-  def add_listener(listener); end
-  def initialize(source, build_context = nil); end
-  def parse; end
+
+  private
+
+  def content(enc); end
+
+  class << self
+    def default; end
+  end
 end
-class REXML::Document < REXML::Element
-  def <<(child); end
-  def add(child); end
-  def add_element(arg = nil, arg2 = nil); end
-  def build(source); end
-  def clone; end
-  def doctype; end
-  def document; end
-  def encoding; end
-  def entity_expansion_count; end
-  def expanded_name; end
-  def initialize(source = nil, context = nil); end
-  def name; end
-  def node_type; end
-  def record_entity_expansion; end
-  def root; end
-  def self.entity_expansion_limit; end
-  def self.entity_expansion_limit=(val); end
-  def self.entity_expansion_text_limit; end
-  def self.entity_expansion_text_limit=(val); end
-  def self.parse_stream(source, listener); end
-  def stand_alone?; end
-  def version; end
-  def write(*arguments); end
-  def xml_decl; end
+
+class REXML::XPathNode
+  def initialize(node, context = T.unsafe(nil)); end
+
+  def context; end
+  def position; end
+  def raw_node; end
 end
-module REXML::StreamListener
-  def attlistdecl(element_name, attributes, raw_content); end
-  def cdata(content); end
-  def comment(comment); end
-  def doctype(name, pub_sys, long_name, uri); end
-  def doctype_end; end
-  def elementdecl(content); end
-  def entity(content); end
-  def entitydecl(content); end
-  def instruction(name, instruction); end
-  def notationdecl(content); end
-  def tag_end(name); end
-  def tag_start(name, attrs); end
-  def text(text); end
-  def xmldecl(version, encoding, standalone); end
+
+class REXML::XPathParser
+  include ::REXML::XMLTokens
+
+  def initialize(strict: T.unsafe(nil)); end
+
+  def []=(variable_name, value); end
+  def first(path_stack, node); end
+  def get_first(path, nodeset); end
+  def match(path_stack, nodeset); end
+  def namespaces=(namespaces = T.unsafe(nil)); end
+  def parse(path, nodeset); end
+  def predicate(path, nodeset); end
+  def variables=(vars = T.unsafe(nil)); end
+
+  private
+
+  def child(nodeset); end
+  def compare(a, operator, b); end
+  def descendant(nodeset, include_self); end
+  def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
+  def each_unnode(nodeset); end
+  def enter(tag, *args); end
+  def equality_relational_compare(set1, op, set2); end
+  def evaluate_predicate(expression, nodesets); end
+  def expr(path_stack, nodeset, context = T.unsafe(nil)); end
+  def filter_nodeset(nodeset); end
+  def following(node); end
+  def following_node_of(node); end
+  def get_namespace(node, prefix); end
+  def leave(tag, *args); end
+  def next_sibling_node(node); end
+  def node_test(path_stack, nodesets, any_type: T.unsafe(nil)); end
+  def norm(b); end
+  def normalize_compare_values(a, operator, b); end
+  def preceding(node); end
+  def preceding_node_of(node); end
+  def sort(array_of_nodes, order); end
+  def step(path_stack, any_type: T.unsafe(nil), order: T.unsafe(nil)); end
+  def strict?; end
+  def trace(*args); end
+  def unnode(nodeset); end
+  def value_type(value); end
 end