e621stream 0.0.0

data/sorbet/rbi/gems/regexp_parser@2.13.1.rbi

@@ -0,0 +1,3500 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `regexp_parser` gem.
+# Please instead update this file by running `bin/tapioca gem regexp_parser`.
+
+
+# This file implements several tree traversal methods.
+#
+# Note: The methods are optimized for performance and avoid stack overflows on
+#       large trees. Check tasks/benchmark/traversal.rb when working in here.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:3
+module Regexp::Expression; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/alternation.rb:7
+class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/alternation.rb:10
+  def alternatives; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:11
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:132
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/alternation.rb:8
+Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
+
+# A sequence of expressions, used by Alternation as one of its alternatives.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/alternation.rb:5
+class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:12
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:4
+module Regexp::Expression::Anchor; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:20
+Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:22
+Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:5
+class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:149
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:7
+class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:13
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:10
+class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:14
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:21
+Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:23
+Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:24
+Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:8
+class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:15
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:11
+class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:16
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:13
+class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:17
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:18
+class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:18
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:16
+class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:19
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:15
+  def negative?; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/anchor.rb:15
+class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:20
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:66
+module Regexp::Expression::Assertion; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:67
+class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:149
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:69
+class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:21
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:72
+class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:22
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:70
+class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:23
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:16
+  def negative?; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:73
+class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:24
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:17
+  def negative?; end
+end
+
+# alias for symmetry between token symbol and Expression class name
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:57
+Regexp::Expression::Backref = Regexp::Expression::Backreference
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:4
+module Regexp::Expression::Backreference; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:5
+class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:157
+  def match_length; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:158
+    def referential?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:17
+class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:21
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:25
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:18
+  def name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:19
+  def reference; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:33
+class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:26
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:45
+class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:48
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:46
+  def recursion_level; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:7
+class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:11
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:27
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:8
+  def number; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:9
+  def reference; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:32
+class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:29
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:34
+class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:30
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:36
+class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:39
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:37
+  def recursion_level; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:27
+class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:28
+  def effective_number; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:28
+  def effective_number=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:28
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/backreference.rb:29
+  def reference; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:4
+class Regexp::Expression::Base
+  include ::Regexp::Expression::Shared
+  include ::Regexp::Expression::ReferencedExpressions
+  extend ::Regexp::Expression::Shared::ClassMethods
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:7
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match.rb:13
+  def =~(string, offset = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:30
+  def a?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:27
+  def ascii_classes?; end
+
+  # Assigns referenced expressions to referring expressions, e.g. if there is
+  # an instance of Backreference::Number, its #referenced_expression is set to
+  # the instance of Group::Capture that it refers to via its number.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:92
+  def assign_referenced_expressions; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:69
+  def attributes; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:10
+  def case_insensitive?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def conditional_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def conditional_level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def custom_to_s_handling; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def custom_to_s_handling=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:25
+  def d?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:22
+  def default_classes?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:20
+  def extended?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:16
+  def free_spacing?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:42
+  def greedy?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:13
+  def i?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:14
+  def ignore_case?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:49
+  def lazy?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:8
+  def m?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match.rb:10
+  def match(string, offset = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match.rb:5
+  def match?(string); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match.rb:8
+  def matches?(string); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:5
+  def multiline?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def nesting_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def nesting_level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def options; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def options=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def parent; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def parent=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:51
+  def possessive?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def pre_quantifier_decorations; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def pre_quantifier_decorations=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def quantifier; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def quantifier=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:19
+  def quantify(*args); end
+
+  # Deprecated. Prefer `#repetitions` which has a more uniform interface.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:28
+  def quantity; end
+
+  # Recalculates the nesting_level for this node and children, which reflects
+  # how deep a node is in the tree. Do this at the end of parsing to account
+  # for tree rewrites.
+  # This must be safe against overflows and performant - check the benchmarks.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:75
+  def recursively_update_nesting_levels(base = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:46
+  def reluctant?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:34
+  def repetitions; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def set_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def set_level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/strfregexp.rb:100
+  def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
+
+  #   %l  Level (depth) of the expression. Returns 'root' for the root
+  #       expression, returns zero or higher for all others.
+  #
+  #   %>  Indentation at expression's level.
+  #
+  #   %x  Index of the expression at its depth. Available when using
+  #       the sprintf_tree method only.
+  #
+  #   %s  Start offset within the whole expression.
+  #   %e  End offset within the whole expression.
+  #   %S  Length of expression.
+  #
+  #   %o  Coded offset and length, same as '@%s+%S'
+  #
+  #   %y  Type of expression.
+  #   %k  Token of expression.
+  #   %i  ID, same as '%y:%k'
+  #   %c  Class name
+  #
+  #   %q  Quantifier info, as {m[,M]}
+  #   %Q  Quantifier text
+  #
+  #   %z  Quantifier min
+  #   %Z  Quantifier max
+  #
+  #   %t  Base text of the expression (excludes quantifier, if any)
+  #   %~t Full text if the expression is terminal, otherwise %i
+  #   %T  Full text of the expression (includes quantifier, if any)
+  #
+  #   %b  Basic info, same as '%o %i'
+  #   %m  Most info, same as '%b %q'
+  #   %a  All info, same as '%m %t'
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/strfregexp.rb:39
+  def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def te; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def te=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def text; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def text=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:55
+  def to_h; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:11
+  def to_re(format = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def token; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def token=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def ts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def ts=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def type; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:5
+  def type=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:35
+  def u?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:32
+  def unicode_classes?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/base.rb:23
+  def unquantified_clone; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/options.rb:19
+  def x?; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:4
+class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:8
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:18
+  def close; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:5
+  def closed; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:5
+  def closed=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:6
+  def closed?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:14
+  def negate; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:5
+  def negative; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:5
+  def negative=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:18
+  def negative?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:17
+  def parts; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set/intersection.rb:5
+class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:31
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set/intersection.rb:7
+class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:32
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set/intersection.rb:8
+Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set/range.rb:5
+class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set/range.rb:10
+  def <<(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set/range.rb:16
+  def complete?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:33
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:18
+  def parts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set/range.rb:6
+  def ts; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:4
+module Regexp::Expression::CharacterType; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:7
+class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:34
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:5
+class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:19
+  def negative?; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:8
+class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:17
+class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:10
+class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:16
+class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:9
+class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:11
+class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:15
+class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:13
+class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:14
+class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_type.rb:12
+class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/free_space.rb:10
+class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:35
+  def human_name; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:148
+    def comment?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:4
+module Regexp::Expression::Conditional; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:20
+class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:36
+  def human_name; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:11
+class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:37
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:149
+  def match_length; end
+
+  # Name or number of the referenced capturing group that determines state.
+  # Returns a String if reference is by name, Integer if by number.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:14
+  def reference; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:159
+    def referential?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:22
+class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:23
+  def <<(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:27
+  def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:32
+  def branch(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:43
+  def branches; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:39
+  def condition; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:34
+  def condition=(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:38
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:132
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:19
+  def parts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:47
+  def reference; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:160
+    def referential?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:5
+class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/conditional.rb:6
+  def initialize; end
+end
+
+# alias for symmetry between Token::* and Expression::*
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:32
+Regexp::Expression::Escape = Regexp::Expression::EscapeSequence
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:4
+module Regexp::Expression::EscapeSequence; end
+
+# e.g. \xE2\x82\xAC
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:25
+class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:48
+  def control_sequence_to_s(control_sequence); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:53
+  def meta_char_to_codepoint(meta_char); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:7
+class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:4
+  def codepoint; end
+end
+
+# \e
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:8
+class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:5
+  def codepoint; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:5
+class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_char.rb:4
+  def char; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+end
+
+# \b
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:9
+class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:6
+  def codepoint; end
+end
+
+# e.g. \x0A
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:20
+class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:18
+  def codepoint; end
+end
+
+# e.g. \u000A
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:22
+class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:28
+  def char; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:36
+  def chars; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:32
+  def codepoint; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:40
+  def codepoints; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:174
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:26
+class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:60
+  def codepoint; end
+end
+
+# \a
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:10
+class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:7
+  def codepoint; end
+end
+
+# e.g. \012
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:19
+class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:17
+  def codepoint; end
+end
+
+# \v
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:16
+class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:13
+  def codepoint; end
+end
+
+# e.g. \cB
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:27
+class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:66
+  def codepoint; end
+end
+
+# e.g. \M-Z
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:28
+class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:72
+  def codepoint; end
+end
+
+# \f
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:11
+class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:8
+  def codepoint; end
+end
+
+# e.g. \j, \@, \😀 (ineffectual escapes)
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:18
+class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:15
+  def codepoint; end
+end
+
+# \n
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:12
+class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:9
+  def codepoint; end
+end
+
+# \r
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:13
+class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:10
+  def codepoint; end
+end
+
+# e.g. \u{A B}
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:23
+class Regexp::Expression::EscapeSequence::UTF8Hex < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:21
+  def codepoint; end
+end
+
+# \t
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/escape_sequence.rb:14
+class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb:11
+  def codepoint; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/free_space.rb:4
+class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:149
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/free_space.rb:5
+  def quantify(*_args); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:153
+    def decorative?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:4
+module Regexp::Expression::Group; end
+
+# Special case. Absence group can match 0.. chars, irrespective of content.
+# TODO: in theory, they *can* exclude match lengths with `.`: `(?~.{3})`
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:21
+class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:182
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:22
+class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:5
+class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:20
+  def parts; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:42
+class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:39
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:44
+  def identifier; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:43
+  def number; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:43
+  def number=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:43
+  def number_at_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:43
+  def number_at_level=(_arg0); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:144
+    def capturing?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:62
+class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:22
+  def parts; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:149
+    def comment?; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:154
+    def decorative?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:47
+class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:51
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:40
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:49
+  def identifier; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:48
+  def name; end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:56
+  def initialize_copy(orig); end
+end
+
+# TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no
+# longer inherit from Group because it is effectively a terminal expression.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:25
+class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:26
+  def option_changes; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:26
+  def option_changes=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:33
+  def quantify(*args); end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:28
+  def initialize_copy(orig); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:8
+class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:11
+  def initialize(*); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:9
+  def implicit=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/group.rb:16
+  def implicit?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:21
+  def parts; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/keep.rb:4
+module Regexp::Expression::Keep; end
+
+# TODO: in regexp_parser v3.0.0 this should possibly be a Subexpression
+#       that contains all expressions to its left.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/keep.rb:7
+class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:41
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:149
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/literal.rb:4
+class Regexp::Expression::Literal < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:42
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:107
+  def match_length; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:87
+Regexp::Expression::MatchLength = Regexp::MatchLength
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/posix_class.rb:12
+Regexp::Expression::Nonposixclass = Regexp::Expression::PosixClass
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:120
+Regexp::Expression::Nonproperty = Regexp::Expression::UnicodeProperty
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/posix_class.rb:4
+class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/posix_class.rb:5
+  def name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:20
+  def negative?; end
+end
+
+# alias for symmetry between token symbol and Expression class name
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/posix_class.rb:11
+Regexp::Expression::Posixclass = Regexp::Expression::PosixClass
+
+# alias for symmetry between token symbol and Expression class name
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:119
+Regexp::Expression::Property = Regexp::Expression::UnicodeProperty
+
+# TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and
+# call super in #initialize, but raise in #quantifier= and #quantify,
+# or introduce an Expression::Quantifiable intermediate class.
+# Or actually allow chaining as a more concise but tricky solution than PR#69.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:8
+class Regexp::Expression::Quantifier
+  include ::Regexp::Expression::Shared
+  extend ::Regexp::Expression::Shared::ClassMethods
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:13
+  def initialize(*args); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def conditional_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def conditional_level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def custom_to_s_handling; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def custom_to_s_handling=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:32
+  def greedy?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:38
+  def lazy?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:44
+  def max; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:40
+  def min; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:48
+  def mode; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def nesting_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def nesting_level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def options; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def options=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def parent; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def parent=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:32
+  def possessive?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def pre_quantifier_decorations; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def pre_quantifier_decorations=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def quantifier; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def quantifier=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:32
+  def reluctant?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def set_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def set_level=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def te; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def te=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def text; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def text=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:21
+  def to_h; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def token; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def token=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def ts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def ts=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def type; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:9
+  def type=(_arg0); end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:54
+  def deprecated_old_init(token, text, _min, _max, _mode = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:66
+  def derived_data; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/quantifier.rb:11
+Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/referenced_expressions.rb:4
+module Regexp::Expression::ReferencedExpressions
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/referenced_expressions.rb:7
+  def referenced_expression; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/referenced_expressions.rb:5
+  def referenced_expressions; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/referenced_expressions.rb:5
+  def referenced_expressions=(_arg0); end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/referenced_expressions.rb:11
+  def initialize_copy(orig); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/root.rb:4
+class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:43
+  def human_name; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/root.rb:5
+    def build(options = T.unsafe(nil)); end
+  end
+end
+
+# A sequence of expressions. Differs from a Subexpressions by how it handles
+# quantifiers, as it applies them to its last element instead of itself as
+# a whole subexpression.
+#
+# Used as the base class for the Alternation alternatives, Conditional
+# branches, and CharacterSet::Intersection intersected sequences.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence.rb:10
+class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence.rb:29
+  def quantify(token, *args); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence.rb:25
+  def ts; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence.rb:12
+    def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
+  end
+end
+
+# abstract class
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence_operation.rb:5
+class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence_operation.rb:14
+  def <<(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence_operation.rb:18
+  def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence_operation.rb:7
+  def operands; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence_operation.rb:8
+  def operator; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:24
+  def parts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence_operation.rb:6
+  def sequences; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/sequence_operation.rb:10
+  def ts; end
+end
+
+# alias for symmetry between token symbol and Expression class name
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/character_set.rb:24
+Regexp::Expression::Set = Regexp::Expression::CharacterSet
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:4
+module Regexp::Expression::Shared
+  mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
+
+  # Deep-compare two expressions for equality.
+  #
+  # When changing the conditions, please make sure to update
+  # #pretty_print_instance_variables so that it includes all relevant values.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:103
+  def ==(other); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:118
+  def ===(other); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:51
+  def base_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:142
+  def capturing?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:112
+  def coded_offset; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:146
+  def comment?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:151
+  def decorative?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:47
+  def ends_at(include_quantifier = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:119
+  def eql?(other); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:55
+  def full_length; end
+
+  # default implementation, e.g. "atomic group", "hex escape", "word type", ..
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:6
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/printing.rb:5
+  def inspect; end
+
+  # Test if this expression has the given test_token, and optionally a given
+  # test_type.
+  #
+  #   # Any expressions
+  #   exp.is? :*  # always returns true
+  #
+  #   # is it a :capture
+  #   exp.is? :capture
+  #
+  #   # is it a :character and a :set
+  #   exp.is? :character, :set
+  #
+  #   # is it a :meta :dot
+  #   exp.is? :dot, :meta
+  #
+  #   # is it a :meta or :escape :dot
+  #   exp.is? :dot, [:meta, :escape]
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:38
+  def is?(test_token, test_type = T.unsafe(nil)); end
+
+  # not an alias so as to respect overrides of #negative?
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:10
+  def negated?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:5
+  def negative?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:108
+  def offset; end
+
+  # Test if this expression matches an entry in the given scope spec.
+  #
+  # A scope spec can be one of:
+  #
+  #   . An array: Interpreted as a set of tokens, tested for inclusion
+  #               of the expression's token.
+  #
+  #   . A hash:   Where the key is interpreted as the expression type
+  #               and the value is either a symbol or an array. In this
+  #               case, when the scope is a hash, one_of? calls itself to
+  #               evaluate the key's value.
+  #
+  #   . A symbol: matches the expression's token or type, depending on
+  #               the level of the call. If one_of? is called directly with
+  #               a symbol then it will always be checked against the
+  #               type of the expression. If it's being called for a value
+  #               from a hash, it will be checked against the token of the
+  #               expression.
+  #
+  #   # any expression
+  #   exp.one_of?(:*) # always true
+  #
+  #   # like exp.type?(:group)
+  #   exp.one_of?(:group)
+  #
+  #   # any expression of type meta
+  #   exp.one_of?(:meta => :*)
+  #
+  #   # meta dots and alternations
+  #   exp.one_of?(:meta => [:dot, :alternation])
+  #
+  #   # meta dots and any set tokens
+  #   exp.one_of?({meta: [:dot], set: :*})
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:77
+  def one_of?(scope, top = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:129
+  def optional?; end
+
+  # default implementation
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:6
+  def parts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:100
+  def pre_quantifier_decoration(expression_format = T.unsafe(nil)); end
+
+  # Make pretty-print work despite #inspect implementation.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/printing.rb:14
+  def pretty_print(q); end
+
+  # Called by pretty_print (ruby/pp) and #inspect.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/printing.rb:19
+  def pretty_print_instance_variables; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:133
+  def quantified?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:104
+  def quantifier_affix(expression_format = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:156
+  def referential?; end
+
+  # Compares two expressions without considering their subexpressions.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:122
+  def shallow_equal?(other); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:43
+  def starts_at; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:138
+  def terminal?; end
+
+  # #to_s reproduces the original source, as an unparser would.
+  #
+  # It takes an optional format argument.
+  #
+  # Example:
+  #
+  # lit = Regexp::Parser.parse(/a +/x)[0]
+  #
+  # lit.to_s            # => 'a+'  # default; with quantifier
+  # lit.to_s(:full)     # => 'a+'  # default; with quantifier
+  # lit.to_s(:base)     # => 'a'   # without quantifier
+  # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:72
+  def to_s(format = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:98
+  def to_str(format = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/construct.rb:39
+  def token_class; end
+
+  # Test if this expression has the given test_type, which can be either
+  # a symbol or an array of symbols to check against the expression's type.
+  #
+  #   # is it a :group expression
+  #   exp.type? :group
+  #
+  #   # is it a :set, or :meta
+  #   exp.type? [:set, :meta]
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:15
+  def type?(test_type); end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:18
+  def init_from_token_and_options(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:32
+  def initialize_copy(orig); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:12
+  def intersperse(expressions, separator); end
+
+  class << self
+    # filled in ./methods/*.rb
+    #
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:7
+    def included(mod); end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/shared.rb:5
+module Regexp::Expression::Shared::ClassMethods
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:143
+  def capturing?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:147
+  def comment?; end
+
+  # Convenience method to init a valid Expression without a Regexp::Token
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/construct.rb:7
+  def construct(params = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/construct.rb:17
+  def construct_defaults; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:152
+  def decorative?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:157
+  def referential?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:139
+  def terminal?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/construct.rb:27
+  def token_class; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:4
+class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
+  include ::Enumerable
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:9
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:22
+  def <<(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def [](*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def at(*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:35
+  def dig(*indices); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def each(*args, &block); end
+
+  # Traverses the expression, passing each recursive child to the
+  # given block.
+  # If the block takes two arguments, the indices of the children within
+  # their parents are also passed to it.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/traverse.rb:14
+  def each_expression(include_self = T.unsafe(nil), &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def empty?(*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:7
+  def expressions; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:7
+  def expressions=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:52
+  def extract_quantifier_target(quantifier_description); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def fetch(*args, &block); end
+
+  # Returns a new array with the results of calling the given block once
+  # for every expression. If a block is not given, returns an array with
+  # each expression and its level index as an array.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/traverse.rb:78
+  def flat_map(include_self = T.unsafe(nil), &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def index(*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:120
+  def inner_match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def join(*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def last(*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def length(*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:113
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/parts.rb:23
+  def parts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/strfregexp.rb:114
+  def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/strfregexp.rb:104
+  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:41
+  def te; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:45
+  def to_h; end
+
+  # Traverses the subexpression (depth-first, pre-order) and calls the given
+  # block for each expression with three arguments; the traversal event,
+  # the expression, and the index of the expression within its parent.
+  #
+  # The event argument is passed as follows:
+  #
+  # - For subexpressions, :enter upon entering the subexpression, and
+  #   :exit upon exiting it.
+  #
+  # - For terminal expressions, :visit is called once.
+  #
+  # Returns self.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/traverse.rb:38
+  def traverse(include_self = T.unsafe(nil), &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def values_at(*args, &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/traverse.rb:73
+  def walk(include_self = T.unsafe(nil), &block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:28
+  def zip(*args, &block); end
+
+  protected
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/traverse.rb:88
+  def each_expression_with_index(&block); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/traverse.rb:110
+  def each_expression_without_index(&block); end
+
+  private
+
+  # Override base method to clone the expressions as well.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/subexpression.rb:15
+  def initialize_copy(orig); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/tests.rb:140
+    def terminal?; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:4
+module Regexp::Expression::UnicodeProperty; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:110
+class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:15
+class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:16
+class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:33
+class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:17
+class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:34
+class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:5
+class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:99
+  def match_length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:6
+  def name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/negative.rb:21
+  def negative?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:10
+  def shortcut; end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:18
+class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:111
+class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:19
+class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:99
+module Regexp::Expression::UnicodeProperty::Codepoint; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:102
+class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:100
+class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:103
+class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:104
+class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:106
+class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:105
+class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:107
+class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:112
+class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:20
+class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:113
+class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:114
+class Regexp::Expression::UnicodeProperty::Enumerated < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:21
+class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:36
+module Regexp::Expression::UnicodeProperty::Letter; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:39
+class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:37
+class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:40
+class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:42
+class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:44
+class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:45
+class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:43
+class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:41
+class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:22
+class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:48
+module Regexp::Expression::UnicodeProperty::Mark; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:51
+class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:49
+class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:52
+class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:55
+class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:53
+class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:54
+class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:31
+class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:58
+module Regexp::Expression::UnicodeProperty::Number; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:61
+class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:59
+class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:62
+class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:63
+class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:64
+class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:23
+class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:24
+class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:67
+module Regexp::Expression::UnicodeProperty::Punctuation; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:70
+class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:68
+class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:74
+class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:71
+class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:72
+class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:76
+class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:75
+class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:73
+class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:77
+class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:115
+class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:80
+module Regexp::Expression::UnicodeProperty::Separator; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:83
+class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:81
+class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:85
+class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:86
+class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:84
+class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:25
+class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:89
+module Regexp::Expression::UnicodeProperty::Symbol; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:92
+class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:90
+class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:94
+class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:93
+class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:95
+class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:96
+class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:26
+class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:27
+class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:29
+class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/unicode_property.rb:28
+class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/free_space.rb:13
+class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/human_name.rb:44
+  def human_name; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/classes/free_space.rb:14
+  def merge(exp); end
+end
+
+# A very thin wrapper around the scanner that breaks quantified literal runs,
+# collects emitted tokens into an array, calculates their nesting depth, and
+# normalizes tokens for the parser, and checks if they are implemented by the
+# given syntax flavor.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:7
+class Regexp::Lexer
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:73
+  def emit(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:20
+  def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:89
+  def ascend(type, token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def block; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def block=(_arg0); end
+
+  # if a codepoint list is followed by a quantifier, that quantifier applies
+  # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc'
+  # c.f. #break_literal_run.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:141
+  def break_codepoint_list(token); end
+
+  # called by scan to break a literal run that is longer than one character
+  # into two separate tokens when it is followed by a quantifier
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:121
+  def break_literal_run(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def collect_tokens; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def collect_tokens=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def conditional_nesting; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def conditional_nesting=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:104
+  def descend(type, token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:164
+  def merge_condition(current, last); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def nesting; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def nesting=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def preprev_token; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def preprev_token=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def prev_token; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def prev_token=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def set_nesting; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def set_nesting=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def shift; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def shift=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def tokens; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:85
+  def tokens=(_arg0); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:15
+    def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:18
+    def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:13
+Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/lexer.rb:8
+Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:3
+class Regexp::MatchLength
+  include ::Enumerable
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:11
+  def initialize(exp, opts = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:26
+  def each(opts = T.unsafe(nil)); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:37
+  def endless_each; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:46
+  def fixed?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:42
+  def include?(length); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:62
+  def inspect; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:54
+  def max; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:50
+  def min; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:58
+  def minmax; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:67
+  def to_re; end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def base_max; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def base_max=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def base_min; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def base_min=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def exp_class; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def exp_class=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def max_rep; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def max_rep=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def min_rep; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def min_rep=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def reify; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:73
+  def reify=(_arg0); end
+
+  # ruby >= 2.4
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:76
+  def test_regexp; end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/expression/methods/match_length.rb:6
+    def of(obj); end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/version.rb:4
+class Regexp::Parser
+  include ::Regexp::Expression
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:27
+  def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:575
+  def active_opts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:100
+  def anchor(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:260
+  def assign_effective_number(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:225
+  def backref(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:199
+  def captured_group_count_at_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def captured_group_counts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def captured_group_counts=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:571
+  def close_completed_character_set_range; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:208
+  def close_group; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:539
+  def close_set; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:267
+  def conditional(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def conditional_nesting; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def conditional_nesting=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:203
+  def count_captured_group; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:214
+  def decrease_nesting; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:303
+  def escape(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:61
+  def extract_options(input, options); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:348
+  def free_space(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:115
+  def group(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:511
+  def increment_group_level(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:550
+  def intersection(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:359
+  def keep(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:363
+  def literal(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:367
+  def meta(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:535
+  def negate_set; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:297
+  def nest(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:292
+  def nest_conditional(exp); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def nesting; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def nesting=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def node; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def node=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:166
+  def open_group(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:528
+  def open_set(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:131
+  def options_group(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def options_stack; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def options_stack=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:77
+  def parse_token(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:389
+  def posixclass(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:396
+  def property(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:478
+  def quantifier(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:543
+  def range(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def root; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def root=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:378
+  def sequence_operation(klass, token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:516
+  def set(token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def switching_options; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def switching_options=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def total_captured_group_count; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:57
+  def total_captured_group_count=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:554
+  def type(token); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:23
+    def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:129
+Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
+
+# base class for all gem-specific errors
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/error.rb:5
+class Regexp::Parser::Error < ::StandardError; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:128
+Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:9
+class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:393
+Regexp::Parser::UP = Regexp::Expression::UnicodeProperty
+
+# pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:394
+Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
+
+# pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:17
+class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:18
+  def initialize(type, token); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:11
+class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
+  # pkg:gem/regexp_parser#lib/regexp_parser/parser.rb:12
+  def initialize(type, token); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/version.rb:5
+Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/scanner_error.rb:5
+class Regexp::Scanner
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2485
+  def capturing_group_count; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2485
+  def capturing_group_count=(_arg0); end
+
+  # Emits an array with the details of the scanned pattern
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2460
+  def emit(type, token, text); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2485
+  def literal_run; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2485
+  def literal_run=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:963
+  def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+  private
+
+  # Appends one or more characters to the literal buffer, to be emitted later
+  # by a call to emit_literal.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2544
+  def append_literal(source, ts, te); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def block; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def block=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def char_pos; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def char_pos=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def collect_tokens; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def collect_tokens=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def conditional_stack; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def conditional_stack=(_arg0); end
+
+  # Ragel offsets are bytes; emitted token positions are characters.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2525
+  def copy(source, ts, te); end
+
+  # Emits the literal run collected by calls to the append_literal method.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2549
+  def emit_literal; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2584
+  def emit_meta_control_sequence(data, source, ts, te, token); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2555
+  def emit_options(text); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2529
+  def error_text(source, ts, position); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2496
+  def extract_encoding(input_object, options); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def free_spacing; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def free_spacing=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2504
+  def free_spacing?(input_object, options); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def group_depth; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def group_depth=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2516
+  def in_group?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2520
+  def in_set?; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def prev_token; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def prev_token=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def regexp_encoding; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def regexp_encoding=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def set_depth; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def set_depth=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def spacing_stack; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def spacing_stack=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def tokens; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2489
+  def tokens=(_arg0); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2445
+    def long_prop_map; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2449
+    def parse_prop_map(name); end
+
+    # Scans the given regular expression text, or Regexp object and collects the
+    # emitted token into an array that gets returned at the end. If a block is
+    # given, it gets called for each emitted token.
+    #
+    # This method may raise errors if a syntax error is encountered.
+    # --------------------------------------------------------------------------
+    #
+    # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:959
+    def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+    # lazy-load property maps when first needed
+    #
+    # pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2441
+    def short_prop_map; end
+  end
+end
+
+# Invalid back reference. Used for name a number refs/calls.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:46
+class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:47
+  def initialize(what, reason); end
+end
+
+# Invalid group. Used for named groups.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:31
+class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:32
+  def initialize(what, reason); end
+end
+
+# Invalid groupOption. Used for inline options.
+# TODO: should become InvalidGroupOptionError in v3.0.0 for consistency
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:39
+class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:40
+  def initialize(option, text); end
+end
+
+# Invalid sequence format. Used for escape sequences, mainly.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:24
+class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:25
+  def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
+end
+
+# Use each_with_object for required_ruby_version >= 2.2,or #to_h for >= 2.6
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:2454
+Regexp::Scanner::POSIX_CLASSES = T.let(T.unsafe(nil), Hash)
+
+# Unexpected end of pattern
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/premature_end_error.rb:5
+class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/premature_end_error.rb:6
+  def initialize(where = T.unsafe(nil)); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:947
+Regexp::Scanner::RE_SCANNER_EN_CHARACTER_SET = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:945
+Regexp::Scanner::RE_SCANNER_EN_CHAR_TYPE = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:950
+Regexp::Scanner::RE_SCANNER_EN_CONDITIONAL_EXPRESSION = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:949
+Regexp::Scanner::RE_SCANNER_EN_ESCAPE_SEQUENCE = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:951
+Regexp::Scanner::RE_SCANNER_EN_MAIN = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:948
+Regexp::Scanner::RE_SCANNER_EN_SET_ESCAPE_SEQUENCE = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:946
+Regexp::Scanner::RE_SCANNER_EN_UNICODE_PROPERTY = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:901
+Regexp::Scanner::RE_SCANNER_EOF_ACTIONS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:921
+Regexp::Scanner::RE_SCANNER_EOF_TRANS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:943
+Regexp::Scanner::RE_SCANNER_ERROR = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:942
+Regexp::Scanner::RE_SCANNER_FIRST_FINAL = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:881
+Regexp::Scanner::RE_SCANNER_FROM_STATE_ACTIONS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:90
+Regexp::Scanner::RE_SCANNER_INDEX_OFFSETS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:110
+Regexp::Scanner::RE_SCANNER_INDICIES = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:70
+Regexp::Scanner::RE_SCANNER_KEY_SPANS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:941
+Regexp::Scanner::RE_SCANNER_START = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:861
+Regexp::Scanner::RE_SCANNER_TO_STATE_ACTIONS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:831
+Regexp::Scanner::RE_SCANNER_TRANS_ACTIONS = T.let(T.unsafe(nil), Array)
+
+# Emit fixed machine data once. The ragel task converts its generated
+# accessors and tables to constants with frozen values.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:17
+Regexp::Scanner::RE_SCANNER_TRANS_KEYS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner.rb:801
+Regexp::Scanner::RE_SCANNER_TRANS_TARGS = T.let(T.unsafe(nil), Array)
+
+# General scanner error (catch all)
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/scanner_error.rb:7
+class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
+
+# The POSIX class name was not recognized by the scanner.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:60
+class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:61
+  def initialize(text, _); end
+end
+
+# The property name was not recognized by the scanner.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:53
+class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
+  # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:54
+  def initialize(name, _); end
+end
+
+# Base for all scanner validation errors
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:5
+class Regexp::Scanner::ValidationError < ::Regexp::Scanner::ScannerError
+  class << self
+    # Centralizes and unifies the handling of validation related errors.
+    #
+    # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:7
+    def for(type, problem, reason = T.unsafe(nil)); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/scanner/errors/validation_error.rb:11
+    def types; end
+  end
+end
+
+# Define the base module and the simplest of tokens.
+# After loading all the tokens the map is full. Extract all tokens and types
+# into the All and Types constants.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax.rb:5
+module Regexp::Syntax
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:78
+  def comparable(name); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:48
+  def const_missing(const_name); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:68
+  def fallback_version_class(version); end
+
+  # Returns the syntax specification class for the given syntax
+  # version name. The special names 'any' and '*' return Syntax::Any.
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:24
+  def for(name); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:32
+  def new(name); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:56
+  def set_fallback_version_class(const_name); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:74
+  def specified_versions; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:44
+  def supported?(name); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:38
+  def version_class(name); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:78
+    def comparable(name); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:48
+    def const_missing(const_name); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:68
+    def fallback_version_class(version); end
+
+    # Returns the syntax specification class for the given syntax
+    # version name. The special names 'any' and '*' return Syntax::Any.
+    #
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:24
+    def for(name); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:32
+    def new(name); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:56
+    def set_fallback_version_class(const_name); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:74
+    def specified_versions; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:44
+    def supported?(name); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:38
+    def version_class(name); end
+  end
+end
+
+# A syntax that always returns true, passing all tokens as implemented. This
+# is useful during development, testing, and should be useful for some types
+# of transformations as well.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/any.rb:7
+class Regexp::Syntax::Any < ::Regexp::Syntax::Base
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/any.rb:10
+    def implements?(_type, _token); end
+  end
+end
+
+# A lookup map of supported types and tokens in a given syntax
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:11
+class Regexp::Syntax::Base
+  include ::Regexp::Syntax::Token
+
+  # TODO: drop this backwards compatibility code in v3.0.0, do `private :new`
+  #
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:101
+  def initialize; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:106
+  def method_missing(name, *args); end
+
+  private
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:117
+  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:48
+    def added_features; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:46
+    def check!(type, token); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:36
+    def check?(type, token); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:28
+    def excludes(type, tokens); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:15
+    def features; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:15
+    def features=(_arg0); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:38
+    def implementations(type); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:23
+    def implements(type, tokens); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:42
+    def implements!(type, token); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:33
+    def implements?(type, token); end
+
+    # automatically inherit features through the syntax class hierarchy
+    #
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:18
+    def inherited(subclass); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:56
+    def normalize(type, token); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:76
+    def normalize_backref(type, token); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:67
+    def normalize_group(type, token); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:52
+    def removed_features; end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions.rb:10
+Regexp::Syntax::CURRENT = Regexp::Syntax::V3_2_0
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:8
+class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:9
+  def initialize(name); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:4
+class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/base.rb:5
+  def initialize(syntax, type, token); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax.rb:6
+class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:5
+module Regexp::Syntax::Token; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:44
+Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
+
+# alias for symmetry between Token::* and Expression::*
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:17
+module Regexp::Syntax::Token::Alternation; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:18
+Regexp::Syntax::Token::Alternation::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:19
+Regexp::Syntax::Token::Alternation::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/anchor.rb:5
+module Regexp::Syntax::Token::Anchor; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/anchor.rb:11
+Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/anchor.rb:6
+Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/anchor.rb:7
+Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/anchor.rb:9
+Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/anchor.rb:8
+Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/anchor.rb:12
+Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/assertion.rb:5
+module Regexp::Syntax::Token::Assertion; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/assertion.rb:9
+Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/assertion.rb:6
+Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/assertion.rb:7
+Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/assertion.rb:10
+Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
+
+# alias for symmetry between token symbol and Expression class name
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:33
+Regexp::Syntax::Token::Backref = Regexp::Syntax::Token::Backreference
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:5
+module Regexp::Syntax::Token::Backreference; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:17
+Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:9
+Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:8
+Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:7
+Regexp::Syntax::Token::Backreference::NumberRef = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:6
+Regexp::Syntax::Token::Backreference::Plain = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:11
+Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:18
+Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:13
+Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:15
+Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_set.rb:5
+module Regexp::Syntax::Token::CharacterSet; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_set.rb:9
+Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_set.rb:6
+Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_set.rb:7
+Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_set.rb:10
+Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_type.rb:5
+module Regexp::Syntax::Token::CharacterType; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_type.rb:12
+Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_type.rb:6
+Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_type.rb:10
+Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_type.rb:7
+Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_type.rb:8
+Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_type.rb:13
+Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/conditional.rb:5
+module Regexp::Syntax::Token::Conditional; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/conditional.rb:11
+Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/conditional.rb:8
+Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/conditional.rb:6
+Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/conditional.rb:9
+Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/conditional.rb:13
+Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:5
+module Regexp::Syntax::Token::Escape; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:10
+Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:26
+Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:6
+Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:8
+Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:22
+Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:15
+Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:24
+Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:27
+Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:13
+Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
+
+# alias for symmetry between Token::* and Expression::*
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/escape.rb:33
+Regexp::Syntax::Token::EscapeSequence = Regexp::Syntax::Token::Escape
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:13
+module Regexp::Syntax::Token::FreeSpace; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:14
+Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:15
+Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:5
+module Regexp::Syntax::Token::Group; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:19
+Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:10
+Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:6
+Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:12
+Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:7
+Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:9
+Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:11
+Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:20
+Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:14
+Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/group.rb:17
+Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/keep.rb:5
+module Regexp::Syntax::Token::Keep; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/keep.rb:8
+Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/keep.rb:6
+Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/keep.rb:9
+Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:8
+module Regexp::Syntax::Token::Literal; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:9
+Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:10
+Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:6
+Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:5
+module Regexp::Syntax::Token::Meta; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:10
+Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:7
+Regexp::Syntax::Token::Meta::Alternation = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:6
+Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:8
+Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/meta.rb:11
+Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/posix_class.rb:5
+module Regexp::Syntax::Token::PosixClass; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/posix_class.rb:11
+Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/posix_class.rb:9
+Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/posix_class.rb:13
+Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/posix_class.rb:6
+Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/posix_class.rb:12
+Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
+
+# alias for symmetry between token symbol and Token module name
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:809
+Regexp::Syntax::Token::Property = Regexp::Syntax::Token::UnicodeProperty
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:5
+module Regexp::Syntax::Token::Quantifier; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:31
+Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:6
+Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:24
+Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:28
+Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:26
+Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:25
+Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:18
+Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:12
+Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:32
+Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/quantifier.rb:30
+Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array)
+
+# alias for symmetry between token symbol and Token module name
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/character_set.rb:16
+Regexp::Syntax::Token::Set = Regexp::Syntax::Token::CharacterSet
+
+# Type is the same as Backreference so keeping it here, for now.
+#
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:22
+module Regexp::Syntax::Token::SubexpressionCall; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:26
+Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:23
+Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/backreference.rb:24
+Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token.rb:45
+Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:5
+module Regexp::Syntax::Token::UnicodeProperty
+  class << self
+    private
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:6
+    def all(name); end
+  end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:73
+Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:45
+Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:49
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:51
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:53
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:55
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:57
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:59
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:61
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:63
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:65
+Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:67
+Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:69
+Regexp::Syntax::Token::UnicodeProperty::Age_V3_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:71
+Regexp::Syntax::Token::UnicodeProperty::Age_V4_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:799
+Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:18
+module Regexp::Syntax::Token::UnicodeProperty::Category; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:41
+Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:38
+Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:19
+Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:22
+Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:25
+Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:28
+Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:35
+Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:32
+Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:11
+Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:14
+Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:152
+Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:75
+Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:129
+Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:134
+Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:138
+Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:142
+Regexp::Syntax::Token::UnicodeProperty::Derived_V3_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:148
+Regexp::Syntax::Token::UnicodeProperty::Derived_V4_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:782
+Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:752
+Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:760
+Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:780
+Regexp::Syntax::Token::UnicodeProperty::Enumerated = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:764
+Regexp::Syntax::Token::UnicodeProperty::Enumerated_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:802
+Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:16
+Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:365
+Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:154
+Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:250
+Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:256
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:266
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:292
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:301
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:310
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:317
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:327
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:334
+Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:341
+Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:351
+Regexp::Syntax::Token::UnicodeProperty::Script_V4_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:801
+Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:750
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:367
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:466
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:594
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:629
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:642
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:656
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:666
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:680
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:692
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:703
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:725
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:729
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V4_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:784
+Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:785
+Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:786
+Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:787
+Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:788
+Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:789
+Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:790
+Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:791
+Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:792
+Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:793
+Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:794
+Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:795
+Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:796
+Regexp::Syntax::Token::UnicodeProperty::V3_5_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/token/unicode_property.rb:797
+Regexp::Syntax::Token::UnicodeProperty::V4_0_0 = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:14
+class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
+  # pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:15
+  def initialize(name); end
+end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/1.8.6.rb:3
+class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/1.9.1.rb:3
+class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/1.9.3.rb:3
+class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.0.0.rb:3
+class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.2.0.rb:3
+class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.3.0.rb:3
+class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.4.0.rb:3
+class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.4.1.rb:3
+class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.5.0.rb:3
+class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.6.0.rb:3
+class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.6.2.rb:3
+class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/2.6.3.rb:3
+class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/3.1.0.rb:3
+class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/3.2.0.rb:3
+class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:64
+Regexp::Syntax::V3_4_1 = Regexp::Syntax::V3_2_0
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/3.5.0.rb:1
+class Regexp::Syntax::V3_5_0 < ::Regexp::Syntax::V3_2_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/versions/4.0.0.rb:1
+class Regexp::Syntax::V4_0_0 < ::Regexp::Syntax::V3_5_0; end
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:6
+Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:4
+Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/syntax/version_lookup.rb:5
+Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/token.rb:4
+Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+class Regexp::Token < ::Struct
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def conditional_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def conditional_level=(_); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:22
+  def length; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def level=(_); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:16
+  def next; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:16
+  def next=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:18
+  def offset; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:16
+  def previous; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:16
+  def previous=(_arg0); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def set_level; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def set_level=(_); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def te; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def te=(_); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def text; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def text=(_); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def token; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def token=(_); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def ts; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def ts=(_); end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def type; end
+
+  # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+  def type=(_); end
+
+  class << self
+    # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+    def [](*_arg0); end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+    def inspect; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+    def keyword_init?; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+    def members; end
+
+    # pkg:gem/regexp_parser#lib/regexp_parser/token.rb:15
+    def new(*_arg0); end
+  end
+end