diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index eaa201754b..27b549f2cd 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -2838,6 +2838,8 @@ end
 
 class Array
   include ::MessagePack::CoreExt
+  def abbrev(pattern=T.unsafe(nil)); end
+
   def compact_blank!(); end
 
   def extract_options!(); end
@@ -2874,6 +2876,8 @@ class Array
 end
 
 class Array
+  def self.parse(string); end
+
   def self.try_convert(_); end
 
   def self.wrap(object); end
@@ -2937,6 +2941,13 @@ class Binding
   def irb(); end
 end
 
+module Blank
+end
+
+module Blank
+  def self.included(base); end
+end
+
 module Bootsnap
   def bundler?(); end
   VERSION = ::T.let(nil, ::T.untyped)
@@ -5857,6 +5868,22 @@ module Cask::Utils
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class Caveats
+  def empty?(*args, &block); end
+
+  def to_s(*args, &block); end
+end
+
+class Checksum
+  def [](*args, &block); end
+
+  def empty?(*args, &block); end
+
+  def length(*args, &block); end
+
+  def to_s(*args, &block); end
+end
+
 class Class
   def any_instance(); end
 
@@ -6251,6 +6278,351 @@ module CodeRay
   def self.scanner(lang, options=T.unsafe(nil), &block); end
 end
 
+module Commander
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Commander::Command
+  def action(*args, &block); end
+
+  def call(args=T.unsafe(nil)); end
+
+  def description(); end
+
+  def description=(description); end
+
+  def example(description, command); end
+
+  def examples(); end
+
+  def examples=(examples); end
+
+  def global_options(); end
+
+  def initialize(name); end
+
+  def name(); end
+
+  def name=(name); end
+
+  def option(*args, &block); end
+
+  def option_proc(switches); end
+
+  def options(); end
+
+  def options=(options); end
+
+  def parse_options_and_call_procs(*args); end
+
+  def proxy_option_struct(); end
+
+  def proxy_options(); end
+
+  def proxy_options=(proxy_options); end
+
+  def run(*args); end
+
+  def summary(); end
+
+  def summary=(summary); end
+
+  def syntax(); end
+
+  def syntax=(syntax); end
+
+  def when_called(*args, &block); end
+end
+
+class Commander::Command::Options
+  include ::Blank
+  def __hash__(); end
+
+  def default(defaults=T.unsafe(nil)); end
+
+  def method_missing(meth, *args); end
+end
+
+class Commander::Command::Options
+end
+
+class Commander::Command
+end
+
+module Commander::Delegates
+  def add_command(*args, &block); end
+
+  def alias_command(*args, &block); end
+
+  def always_trace!(*args, &block); end
+
+  def command(*args, &block); end
+
+  def default_command(*args, &block); end
+
+  def defined_commands(*args, &block); end
+
+  def global_option(*args, &block); end
+
+  def never_trace!(*args, &block); end
+
+  def program(*args, &block); end
+
+  def run!(*args, &block); end
+end
+
+module Commander::Delegates
+end
+
+module Commander::HelpFormatter
+end
+
+class Commander::HelpFormatter::Base
+  def initialize(runner); end
+
+  def render(); end
+
+  def render_command(command); end
+end
+
+class Commander::HelpFormatter::Base
+end
+
+class Commander::HelpFormatter::Context
+  def decorate_binding(_bind); end
+
+  def initialize(target); end
+end
+
+class Commander::HelpFormatter::Context
+end
+
+class Commander::HelpFormatter::ProgramContext
+  def decorate_binding(bind); end
+
+  def max_aliases_length(bind); end
+
+  def max_command_length(bind); end
+
+  def max_key_length(hash, default=T.unsafe(nil)); end
+end
+
+class Commander::HelpFormatter::ProgramContext
+end
+
+class Commander::HelpFormatter::Terminal
+  def template(name); end
+end
+
+class Commander::HelpFormatter::Terminal
+end
+
+class Commander::HelpFormatter::TerminalCompact
+end
+
+class Commander::HelpFormatter::TerminalCompact
+end
+
+module Commander::HelpFormatter
+  def self.indent(amount, text); end
+end
+
+module Commander::Methods
+  include ::Commander::UI
+  include ::Commander::UI::AskForClass
+  include ::Commander::Delegates
+end
+
+module Commander::Methods
+end
+
+module Commander::Platform
+end
+
+module Commander::Platform
+  def self.jruby?(); end
+end
+
+class Commander::Runner
+  def active_command(); end
+
+  def add_command(command); end
+
+  def alias?(name); end
+
+  def alias_command(alias_name, name, *args); end
+
+  def always_trace!(); end
+
+  def args_without_command_name(); end
+
+  def command(name, &block); end
+
+  def command_exists?(name); end
+
+  def command_name_from_args(); end
+
+  def commands(); end
+
+  def create_default_commands(); end
+
+  def default_command(name); end
+
+  def expand_optionally_negative_switches(switches); end
+
+  def global_option(*args, &block); end
+
+  def global_option_proc(switches, &block); end
+
+  def help_formatter(); end
+
+  def help_formatter_alias_defaults(); end
+
+  def help_formatter_aliases(); end
+
+  def initialize(args=T.unsafe(nil)); end
+
+  def never_trace!(); end
+
+  def options(); end
+
+  def parse_global_options(); end
+
+  def program(key, *args, &block); end
+
+  def program_defaults(); end
+
+  def remove_global_options(options, args); end
+
+  def require_program(*keys); end
+
+  def require_valid_command(command=T.unsafe(nil)); end
+
+  def run!(); end
+
+  def run_active_command(); end
+
+  def say(*args); end
+
+  def valid_command_names_from(*args); end
+
+  def version(); end
+end
+
+class Commander::Runner::CommandError
+end
+
+class Commander::Runner::CommandError
+end
+
+class Commander::Runner::InvalidCommandError
+end
+
+class Commander::Runner::InvalidCommandError
+end
+
+class Commander::Runner
+  def self.instance(); end
+
+  def self.separate_switches_from_description(*args); end
+
+  def self.switch_to_sym(switch); end
+end
+
+module Commander::UI
+end
+
+module Commander::UI::AskForClass
+  def ask_for_array(prompt); end
+
+  def ask_for_file(prompt); end
+
+  def ask_for_float(prompt); end
+
+  def ask_for_integer(prompt); end
+
+  def ask_for_pathname(prompt); end
+
+  def ask_for_regexp(prompt); end
+
+  def ask_for_string(prompt); end
+
+  def ask_for_symbol(prompt); end
+
+  def method_missing(method_name, *arguments, &block); end
+  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
+end
+
+module Commander::UI::AskForClass
+end
+
+class Commander::UI::ProgressBar
+  def completed?(); end
+
+  def erase_line(); end
+
+  def finished?(); end
+
+  def generate_tokens(); end
+
+  def increment(tokens=T.unsafe(nil)); end
+
+  def initialize(total, options=T.unsafe(nil)); end
+
+  def percent_complete(); end
+
+  def progress_bar(); end
+
+  def show(); end
+
+  def steps_remaining(); end
+
+  def time_elapsed(); end
+
+  def time_remaining(); end
+end
+
+class Commander::UI::ProgressBar
+end
+
+module Commander::UI
+  def self.applescript(script); end
+
+  def self.ask_editor(input=T.unsafe(nil), preferred_editor=T.unsafe(nil)); end
+
+  def self.available_editor(preferred=T.unsafe(nil)); end
+
+  def self.choose(message=T.unsafe(nil), *choices, &block); end
+
+  def self.color(*args); end
+
+  def self.converse(prompt, responses=T.unsafe(nil)); end
+
+  def self.enable_paging(); end
+
+  def self.io(input=T.unsafe(nil), output=T.unsafe(nil), &block); end
+
+  def self.log(action, *args); end
+
+  def self.password(message=T.unsafe(nil), mask=T.unsafe(nil)); end
+
+  def self.progress(arr, options=T.unsafe(nil)); end
+
+  def self.replace_tokens(str, hash); end
+
+  def self.say_error(*args); end
+
+  def self.say_ok(*args); end
+
+  def self.say_warning(*args); end
+
+  def self.speak(message, voice=T.unsafe(nil), rate=T.unsafe(nil)); end
+end
+
+module Commander
+  def self.configure(*configuration_opts, &configuration_block); end
+end
+
 class CompilerSelector::Compiler
   def self.[](*_); end
 
@@ -7113,8 +7485,6 @@ end
 
 module Enumerable
   include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  def chain(*_); end
-
   def compact_blank(); end
 
   def exclude?(object); end
@@ -8237,6 +8607,1052 @@ class Hash
   def self.try_convert(_); end
 end
 
+class HighLine
+  include ::HighLine::BuiltinStyles
+  include ::HighLine::CustomErrors
+  def agree(yes_or_no_question, character=T.unsafe(nil)); end
+
+  def ask(template_or_question, answer_type=T.unsafe(nil), &details); end
+
+  def choose(*items, &details); end
+
+  def color(string, *colors); end
+
+  def color_code(*colors); end
+
+  def get_response_character_mode(question); end
+
+  def get_response_getc_mode(question); end
+
+  def get_response_line_mode(question); end
+
+  def indent(increase=T.unsafe(nil), statement=T.unsafe(nil), multiline=T.unsafe(nil)); end
+
+  def indent_level(); end
+
+  def indent_level=(indent_level); end
+
+  def indent_size(); end
+
+  def indent_size=(indent_size); end
+
+  def indentation(); end
+
+  def initialize(input=T.unsafe(nil), output=T.unsafe(nil), wrap_at=T.unsafe(nil), page_at=T.unsafe(nil), indent_size=T.unsafe(nil), indent_level=T.unsafe(nil)); end
+
+  def input(); end
+
+  def key(); end
+
+  def key=(key); end
+
+  def list(items, mode=T.unsafe(nil), option=T.unsafe(nil)); end
+
+  def multi_indent(); end
+
+  def multi_indent=(multi_indent); end
+
+  def new_scope(); end
+
+  def newline(); end
+
+  def output(); end
+
+  def output_cols(); end
+
+  def output_rows(); end
+
+  def page_at(); end
+
+  def page_at=(setting); end
+
+  def puts(*args); end
+
+  def render_statement(statement); end
+
+  def reset_use_color(); end
+
+  def say(statement); end
+
+  def shell_style_lambda(menu); end
+
+  def terminal(); end
+
+  def track_eof(); end
+
+  def track_eof=(track_eof); end
+
+  def track_eof?(); end
+
+  def uncolor(string); end
+
+  def use_color(); end
+
+  def use_color=(use_color); end
+
+  def use_color?(); end
+
+  def wrap_at(); end
+
+  def wrap_at=(setting); end
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::BuiltinStyles
+  BASIC_COLORS = ::T.let(nil, ::T.untyped)
+  BLACK = ::T.let(nil, ::T.untyped)
+  BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  BLINK = ::T.let(nil, ::T.untyped)
+  BLINK_STYLE = ::T.let(nil, ::T.untyped)
+  BLUE = ::T.let(nil, ::T.untyped)
+  BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  BOLD_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREY = ::T.let(nil, ::T.untyped)
+  BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_NONE = ::T.let(nil, ::T.untyped)
+  BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_RED = ::T.let(nil, ::T.untyped)
+  BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  BRIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  CLEAR = ::T.let(nil, ::T.untyped)
+  CLEAR_STYLE = ::T.let(nil, ::T.untyped)
+  COLORS = ::T.let(nil, ::T.untyped)
+  COLOR_LIST = ::T.let(nil, ::T.untyped)
+  CONCEALED = ::T.let(nil, ::T.untyped)
+  CONCEALED_STYLE = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  DARK = ::T.let(nil, ::T.untyped)
+  DARK_STYLE = ::T.let(nil, ::T.untyped)
+  ERASE_CHAR = ::T.let(nil, ::T.untyped)
+  ERASE_CHAR_STYLE = ::T.let(nil, ::T.untyped)
+  ERASE_LINE = ::T.let(nil, ::T.untyped)
+  ERASE_LINE_STYLE = ::T.let(nil, ::T.untyped)
+  GRAY = ::T.let(nil, ::T.untyped)
+  GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  GREY = ::T.let(nil, ::T.untyped)
+  GREY_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_GREY = ::T.let(nil, ::T.untyped)
+  LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_NONE = ::T.let(nil, ::T.untyped)
+  LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_RED = ::T.let(nil, ::T.untyped)
+  LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  LIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  NONE = ::T.let(nil, ::T.untyped)
+  NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BLUE = ::T.let(nil, ::T.untyped)
+  ON_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREY = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_NONE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_RED = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  ON_BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  ON_CYAN = ::T.let(nil, ::T.untyped)
+  ON_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_GRAY = ::T.let(nil, ::T.untyped)
+  ON_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_GREEN = ::T.let(nil, ::T.untyped)
+  ON_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_GREY = ::T.let(nil, ::T.untyped)
+  ON_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLACK = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLUE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_CYAN = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GRAY = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREEN = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREY = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_NONE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_RED = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_WHITE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_YELLOW = ::T.let(nil, ::T.untyped)
+  ON_LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
+  ON_NONE = ::T.let(nil, ::T.untyped)
+  ON_NONE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_RED = ::T.let(nil, ::T.untyped)
+  ON_RED_STYLE = ::T.let(nil, ::T.untyped)
+  ON_WHITE = ::T.let(nil, ::T.untyped)
+  ON_WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  ON_YELLOW = ::T.let(nil, ::T.untyped)
+  ON_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  RED_STYLE = ::T.let(nil, ::T.untyped)
+  RESET = ::T.let(nil, ::T.untyped)
+  RESET_STYLE = ::T.let(nil, ::T.untyped)
+  REVERSE = ::T.let(nil, ::T.untyped)
+  REVERSE_STYLE = ::T.let(nil, ::T.untyped)
+  STYLES = ::T.let(nil, ::T.untyped)
+  STYLE_LIST = ::T.let(nil, ::T.untyped)
+  UNDERLINE = ::T.let(nil, ::T.untyped)
+  UNDERLINE_STYLE = ::T.let(nil, ::T.untyped)
+  UNDERSCORE = ::T.let(nil, ::T.untyped)
+  UNDERSCORE_STYLE = ::T.let(nil, ::T.untyped)
+  WHITE = ::T.let(nil, ::T.untyped)
+  WHITE_STYLE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
+  YELLOW_STYLE = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::BuiltinStyles::ClassMethods
+  def const_missing(name); end
+  RGB_COLOR_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::BuiltinStyles::ClassMethods
+end
+
+module HighLine::BuiltinStyles
+  def self.included(base); end
+end
+
+class HighLine::ColorScheme
+  def [](color_tag); end
+
+  def []=(color_tag, constants); end
+
+  def definition(color_tag); end
+
+  def include?(color_tag); end
+
+  def initialize(h=T.unsafe(nil)); end
+
+  def keys(); end
+
+  def load_from_hash(h); end
+
+  def to_hash(); end
+end
+
+class HighLine::ColorScheme
+end
+
+module HighLine::CustomErrors
+end
+
+class HighLine::CustomErrors::ExplainableError
+  def explanation_key(); end
+end
+
+class HighLine::CustomErrors::ExplainableError
+end
+
+class HighLine::CustomErrors::NoAutoCompleteMatch
+end
+
+class HighLine::CustomErrors::NoAutoCompleteMatch
+end
+
+class HighLine::CustomErrors::NoConfirmationQuestionError
+end
+
+class HighLine::CustomErrors::NoConfirmationQuestionError
+end
+
+class HighLine::CustomErrors::NotInRangeQuestionError
+end
+
+class HighLine::CustomErrors::NotInRangeQuestionError
+end
+
+class HighLine::CustomErrors::NotValidQuestionError
+end
+
+class HighLine::CustomErrors::NotValidQuestionError
+end
+
+class HighLine::CustomErrors::QuestionError
+end
+
+class HighLine::CustomErrors::QuestionError
+end
+
+module HighLine::CustomErrors
+end
+
+class HighLine::List
+  def col_down(); end
+
+  def col_down_mode(); end
+
+  def cols(); end
+
+  def cols=(cols); end
+
+  def initialize(items, options=T.unsafe(nil)); end
+
+  def items(); end
+
+  def list(); end
+
+  def row_join_str_size(); end
+
+  def row_join_string(); end
+
+  def row_join_string=(row_join_string); end
+
+  def slice_by_cols(); end
+
+  def slice_by_rows(); end
+
+  def to_a(); end
+
+  def transpose(); end
+
+  def transpose_mode(); end
+end
+
+class HighLine::List
+end
+
+class HighLine::ListRenderer
+  def highline(); end
+
+  def initialize(items, mode=T.unsafe(nil), option=T.unsafe(nil), highline); end
+
+  def items(); end
+
+  def mode(); end
+
+  def option(); end
+
+  def render(); end
+end
+
+class HighLine::ListRenderer
+end
+
+class HighLine::Menu
+  def add_item(item); end
+
+  def all_items(); end
+
+  def build_item(*args); end
+
+  def choice(name, help=T.unsafe(nil), text=T.unsafe(nil), &action); end
+
+  def choices(*names, &action); end
+
+  def decorate_index(index); end
+
+  def decorate_item(text, ix); end
+
+  def find_item_from_selection(items, selection); end
+
+  def flow(); end
+
+  def flow=(flow); end
+
+  def gather_selected(highline_context, selections, details=T.unsafe(nil)); end
+
+  def get_item_by_letter(items, selection); end
+
+  def get_item_by_number(items, selection); end
+
+  def header(); end
+
+  def header=(header); end
+
+  def help(topic, help); end
+
+  def hidden(name, help=T.unsafe(nil), &action); end
+
+  def index(); end
+
+  def index=(style); end
+
+  def index_color(); end
+
+  def index_color=(index_color); end
+
+  def index_suffix(); end
+
+  def index_suffix=(index_suffix); end
+
+  def init_help(); end
+
+  def initialize(); end
+
+  def layout(); end
+
+  def layout=(new_layout); end
+
+  def list_option(); end
+
+  def list_option=(list_option); end
+
+  def map_items_by_index(); end
+
+  def map_items_by_name(); end
+
+  def mark_for_decoration(text, ix); end
+
+  def nil_on_handled(); end
+
+  def nil_on_handled=(nil_on_handled); end
+
+  def options(); end
+
+  def parse_list(); end
+
+  def prompt(); end
+
+  def prompt=(prompt); end
+
+  def select(highline_context, selection, details=T.unsafe(nil)); end
+
+  def select_by(); end
+
+  def select_by=(select_by); end
+
+  def shell(); end
+
+  def shell=(shell); end
+
+  def show_default_if_any(); end
+
+  def to_ary(); end
+
+  def update_responses(); end
+
+  def value_for_array_selections(items, selections, details); end
+
+  def value_for_hash_selections(items, selections, details); end
+
+  def value_for_selected_item(item, details); end
+end
+
+class HighLine::Menu::Item
+  def action(); end
+
+  def help(); end
+
+  def initialize(name, attributes); end
+
+  def item_help(); end
+
+  def name(); end
+
+  def text(); end
+end
+
+class HighLine::Menu::Item
+end
+
+class HighLine::Menu
+  def self.index_color(); end
+
+  def self.index_color=(index_color); end
+end
+
+class HighLine::Paginator
+  def continue_paging?(); end
+
+  def highline(); end
+
+  def initialize(highline); end
+
+  def page_print(text); end
+end
+
+class HighLine::Paginator
+end
+
+class HighLine::Question
+  include ::HighLine::CustomErrors
+  def above(); end
+
+  def above=(above); end
+
+  def answer(); end
+
+  def answer=(answer); end
+
+  def answer_or_default(answer_string); end
+
+  def answer_type(); end
+
+  def answer_type=(answer_type); end
+
+  def ask_on_error_msg(); end
+
+  def below(); end
+
+  def below=(below); end
+
+  def build_responses(message_source=T.unsafe(nil)); end
+
+  def build_responses_new_hash(message_source); end
+
+  def case(); end
+
+  def case=(_); end
+
+  def change_case(answer_string); end
+
+  def character(); end
+
+  def character=(character); end
+
+  def check_range(); end
+
+  def choices_complete(answer_string); end
+
+  def completion(); end
+
+  def completion=(completion); end
+
+  def confirm(); end
+
+  def confirm=(confirm); end
+
+  def confirm_question(highline); end
+
+  def convert(); end
+
+  def default(); end
+
+  def default=(default); end
+
+  def default_responses_hash(); end
+
+  def directory(); end
+
+  def directory=(directory); end
+
+  def echo(); end
+
+  def echo=(echo); end
+
+  def expected_range(); end
+
+  def final_response(error); end
+
+  def final_responses(); end
+
+  def first_answer(); end
+
+  def first_answer=(first_answer); end
+
+  def first_answer?(); end
+
+  def format_answer(answer_string); end
+
+  def gather(); end
+
+  def gather=(gather); end
+
+  def get_echo_for_response(response); end
+
+  def get_response(highline); end
+
+  def get_response_or_default(highline); end
+
+  def glob(); end
+
+  def glob=(glob); end
+
+  def in(); end
+
+  def in=(_); end
+
+  def in_range?(); end
+
+  def initialize(template, answer_type); end
+
+  def limit(); end
+
+  def limit=(limit); end
+
+  def overwrite(); end
+
+  def overwrite=(overwrite); end
+
+  def readline(); end
+
+  def readline=(readline); end
+
+  def remove_whitespace(answer_string); end
+
+  def responses(); end
+
+  def selection(); end
+
+  def show_question(highline); end
+
+  def template(); end
+
+  def template=(template); end
+
+  def valid_answer?(); end
+
+  def validate(); end
+
+  def validate=(validate); end
+
+  def verify_match(); end
+
+  def verify_match=(verify_match); end
+
+  def whitespace(); end
+
+  def whitespace=(whitespace); end
+end
+
+class HighLine::Question::AnswerConverter
+  def answer(*args, &block); end
+
+  def answer=(*args, &block); end
+
+  def answer_type(*args, &block); end
+
+  def check_range(*args, &block); end
+
+  def choices_complete(*args, &block); end
+
+  def convert(); end
+
+  def directory(*args, &block); end
+
+  def initialize(question); end
+
+  def to_array(); end
+
+  def to_file(); end
+
+  def to_float(); end
+
+  def to_integer(); end
+
+  def to_pathname(); end
+
+  def to_proc(); end
+
+  def to_regexp(); end
+
+  def to_string(); end
+
+  def to_symbol(); end
+end
+
+class HighLine::Question::AnswerConverter
+  extend ::Forwardable
+end
+
+class HighLine::Question
+  def self.build(template_or_question, answer_type=T.unsafe(nil), &details); end
+end
+
+class HighLine::QuestionAsker
+  include ::HighLine::CustomErrors
+  def ask_once(); end
+
+  def gather_answers(); end
+
+  def gather_hash(); end
+
+  def gather_integer(); end
+
+  def gather_regexp(); end
+
+  def initialize(question, highline); end
+
+  def question(); end
+end
+
+class HighLine::QuestionAsker
+end
+
+class HighLine::SampleColorScheme
+  def initialize(_h=T.unsafe(nil)); end
+  SAMPLE_SCHEME = ::T.let(nil, ::T.untyped)
+end
+
+class HighLine::SampleColorScheme
+end
+
+class HighLine::Statement
+  def highline(); end
+
+  def initialize(source, highline); end
+
+  def source(); end
+
+  def statement(); end
+
+  def template_string(); end
+end
+
+class HighLine::Statement
+  def self.const_missing(constant); end
+end
+
+class HighLine::String
+  include ::HighLine::StringExtensions
+  def bright_black(); end
+
+  def bright_blue(); end
+
+  def bright_cyan(); end
+
+  def bright_gray(); end
+
+  def bright_green(); end
+
+  def bright_grey(); end
+
+  def bright_magenta(); end
+
+  def bright_none(); end
+
+  def bright_red(); end
+
+  def bright_white(); end
+
+  def bright_yellow(); end
+
+  def color(*args); end
+
+  def concealed(); end
+
+  def dark(); end
+
+  def foreground(*args); end
+
+  def gray(); end
+
+  def grey(); end
+
+  def light_gray(); end
+
+  def light_grey(); end
+
+  def light_none(); end
+
+  def method_missing(method, *_args); end
+
+  def none(); end
+
+  def on(arg); end
+
+  def on_bright_black(); end
+
+  def on_bright_blue(); end
+
+  def on_bright_cyan(); end
+
+  def on_bright_gray(); end
+
+  def on_bright_green(); end
+
+  def on_bright_grey(); end
+
+  def on_bright_magenta(); end
+
+  def on_bright_none(); end
+
+  def on_bright_red(); end
+
+  def on_bright_white(); end
+
+  def on_bright_yellow(); end
+
+  def on_gray(); end
+
+  def on_grey(); end
+
+  def on_light_gray(); end
+
+  def on_light_grey(); end
+
+  def on_light_none(); end
+
+  def on_none(); end
+
+  def on_rgb(*colors); end
+
+  def reset(); end
+
+  def rgb(*colors); end
+
+  def uncolor(); end
+end
+
+class HighLine::String
+end
+
+module HighLine::StringExtensions
+  STYLE_METHOD_NAME_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+module HighLine::StringExtensions
+  def self.define_builtin_style_methods(base); end
+
+  def self.define_style_support_methods(base); end
+
+  def self.included(base); end
+end
+
+class HighLine::Style
+  def blue(); end
+
+  def bright(); end
+
+  def builtin(); end
+
+  def builtin=(builtin); end
+
+  def code(); end
+
+  def color(string); end
+
+  def green(); end
+
+  def initialize(defn=T.unsafe(nil)); end
+
+  def light(); end
+
+  def list(); end
+
+  def name(); end
+
+  def on(); end
+
+  def red(); end
+
+  def rgb(); end
+
+  def rgb=(rgb); end
+
+  def to_hash(); end
+
+  def variant(new_name, options=T.unsafe(nil)); end
+end
+
+class HighLine::Style
+  def self.ansi_rgb_to_hex(ansi_number); end
+
+  def self.clear_index(); end
+
+  def self.code_index(); end
+
+  def self.index(style); end
+
+  def self.list(); end
+
+  def self.rgb(*colors); end
+
+  def self.rgb_hex(*colors); end
+
+  def self.rgb_number(*parts); end
+
+  def self.rgb_parts(hex); end
+
+  def self.uncolor(string); end
+end
+
+class HighLine::TemplateRenderer
+  def answer(*args, &block); end
+
+  def answer_type(*args, &block); end
+
+  def color(*args, &block); end
+
+  def header(*args, &block); end
+
+  def highline(); end
+
+  def initialize(template, source, highline); end
+
+  def key(*args, &block); end
+
+  def list(*args, &block); end
+
+  def menu(); end
+
+  def method_missing(method, *args); end
+
+  def prompt(*args, &block); end
+
+  def render(); end
+
+  def source(); end
+
+  def template(); end
+end
+
+class HighLine::TemplateRenderer
+  extend ::Forwardable
+  def self.const_missing(name); end
+end
+
+class HighLine::Terminal
+  def character_mode(); end
+
+  def get_character(); end
+
+  def get_line(question, highline); end
+
+  def get_line_default(highline); end
+
+  def get_line_with_readline(question, highline); end
+
+  def initialize(input, output); end
+
+  def initialize_system_extensions(); end
+
+  def input(); end
+
+  def jruby?(); end
+
+  def output(); end
+
+  def raw_no_echo_mode(); end
+
+  def raw_no_echo_mode_exec(); end
+
+  def readline_read(question); end
+
+  def restore_mode(); end
+
+  def rubinius?(); end
+
+  def terminal_size(); end
+
+  def windows?(); end
+end
+
+class HighLine::Terminal::IOConsole
+end
+
+class HighLine::Terminal::IOConsole
+end
+
+class HighLine::Terminal
+  def self.get_terminal(input, output); end
+end
+
+module HighLine::Wrapper
+end
+
+module HighLine::Wrapper
+  def self.actual_length(string_with_escapes); end
+
+  def self.wrap(text, wrap_at); end
+end
+
+class HighLine
+  extend ::HighLine::BuiltinStyles::ClassMethods
+  extend ::SingleForwardable
+  def self.String(s); end
+
+  def self.Style(*args); end
+
+  def self.color(*args, &block); end
+
+  def self.color_code(*args, &block); end
+
+  def self.color_scheme(); end
+
+  def self.color_scheme=(color_scheme); end
+
+  def self.colorize_strings(); end
+
+  def self.default_instance(); end
+
+  def self.default_instance=(default_instance); end
+
+  def self.find_or_create_style(arg); end
+
+  def self.find_or_create_style_list(*args); end
+
+  def self.reset(); end
+
+  def self.reset_color_scheme(); end
+
+  def self.reset_use_color(*args, &block); end
+
+  def self.supports_rgb_color?(); end
+
+  def self.track_eof=(*args, &block); end
+
+  def self.track_eof?(*args, &block); end
+
+  def self.uncolor(*args, &block); end
+
+  def self.use_color=(*args, &block); end
+
+  def self.use_color?(*args, &block); end
+
+  def self.using_color_scheme?(); end
+end
+
 module Homebrew
   MAX_PORT = ::T.let(nil, ::T.untyped)
   MIN_PORT = ::T.let(nil, ::T.untyped)
@@ -8566,6 +9982,31 @@ module Homebrew::Livecheck::Strategy
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+module Homebrew::Parlour
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class Homebrew::Service
+  def bin(*args, &block); end
+
+  def etc(*args, &block); end
+
+  def libexec(*args, &block); end
+
+  def opt_bin(*args, &block); end
+
+  def opt_libexec(*args, &block); end
+
+  def opt_pkgshare(*args, &block); end
+
+  def opt_prefix(*args, &block); end
+
+  def opt_sbin(*args, &block); end
+
+  def var(*args, &block); end
+end
+
 class Homebrew::Service
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -9900,18 +11341,27 @@ end
 module Kernel
   include ::ActiveSupport::ForkTracker::CoreExtPrivate
   include ::ActiveSupport::ForkTracker::CoreExt
+  def agree(*args, &block); end
+
+  def ask(*args, &block); end
+
+  def choose(*args, &block); end
+
   def itself(); end
 
   def object_id(); end
 
   def pretty_inspect(); end
 
+  def say(*args, &block); end
+
   def then(); end
 
   def yield_self(); end
 end
 
 module Kernel
+  extend ::Forwardable
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
   def self.at_exit(); end
@@ -11288,6 +12738,12 @@ module MachO
   def self.open(filename); end
 end
 
+module MachOShim
+  def dylib_id(*args, &block); end
+
+  def rpaths(*args, &block); end
+end
+
 Markdown = RDiscount
 
 module MessagePack
@@ -12581,9 +14037,13 @@ Net::HTTPServerErrorCode = Net::HTTPServerError
 
 Net::HTTPSession = Net::HTTP
 
-Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError
+class Net::HTTPSuccess
+end
 
-Net::HTTPSuccessCode = Net::HTTPSuccess
+Net::HTTPSuccessCode::EXCEPTION_TYPE = Net::HTTPError
+
+class Net::HTTPSuccess
+end
 
 class Net::HTTPURITooLong
   HAS_BODY = ::T.let(nil, ::T.untyped)
@@ -12742,8 +14202,12 @@ class Object
   include ::ActiveSupport::ForkTracker::CoreExt
   def acts_like?(duck); end
 
+  def get_binding(); end
+
   def html_safe?(); end
 
+  def or_ask(*args, &details); end
+
   def pry(object=T.unsafe(nil), hash=T.unsafe(nil)); end
 
   def stub(name, val_or_callable, *block_args); end
@@ -12911,8 +14375,6 @@ module OpenSSL::SSL
 end
 
 class OpenSSL::SSL::SSLContext
-  def add_certificate(*_); end
-
   def alpn_protocols(); end
 
   def alpn_protocols=(alpn_protocols); end
@@ -12980,6 +14442,10 @@ class Options
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class PATH
+  def each(*args, &block); end
+end
+
 class PATH
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -14085,6 +15551,18 @@ class Pathname
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class PkgVersion
+  def major(*args, &block); end
+
+  def major_minor(*args, &block); end
+
+  def major_minor_patch(*args, &block); end
+
+  def minor(*args, &block); end
+
+  def patch(*args, &block); end
+end
+
 class Proc
   include ::MethodSource::SourceLocation::ProcExtensions
   include ::MethodSource::MethodExtensions
@@ -20069,6 +21547,8 @@ class RSpec::Core::OutputWrapper
 
   def autoclose?(*args, &block); end
 
+  def beep(*args, &block); end
+
   def binmode(*args, &block); end
 
   def binmode?(*args, &block); end
@@ -20091,6 +21571,14 @@ class RSpec::Core::OutputWrapper
 
   def codepoints(*args, &block); end
 
+  def cooked(*args, &block); end
+
+  def cooked!(*args, &block); end
+
+  def cursor(*args, &block); end
+
+  def cursor=(*args, &block); end
+
   def each(*args, &block); end
 
   def each_byte(*args, &block); end
@@ -20101,6 +21589,10 @@ class RSpec::Core::OutputWrapper
 
   def each_line(*args, &block); end
 
+  def echo=(*args, &block); end
+
+  def echo?(*args, &block); end
+
   def eof(*args, &block); end
 
   def eof?(*args, &block); end
@@ -20121,8 +21613,16 @@ class RSpec::Core::OutputWrapper
 
   def getc(*args, &block); end
 
+  def getch(*args, &block); end
+
+  def getpass(*args, &block); end
+
   def gets(*args, &block); end
 
+  def goto(*args, &block); end
+
+  def iflush(*args, &block); end
+
   def initialize(output); end
 
   def inspect(*args, &block); end
@@ -20131,6 +21631,8 @@ class RSpec::Core::OutputWrapper
 
   def ioctl(*args, &block); end
 
+  def ioflush(*args, &block); end
+
   def isatty(*args, &block); end
 
   def lineno(*args, &block); end
@@ -20141,6 +21643,8 @@ class RSpec::Core::OutputWrapper
 
   def method_missing(name, *args, &block); end
 
+  def noecho(*args, &block); end
+
   def nonblock(*args, &block); end
 
   def nonblock=(*args, &block); end
@@ -20149,6 +21653,8 @@ class RSpec::Core::OutputWrapper
 
   def nread(*args, &block); end
 
+  def oflush(*args, &block); end
+
   def output(); end
 
   def output=(output); end
@@ -20163,6 +21669,8 @@ class RSpec::Core::OutputWrapper
 
   def pread(*args, &block); end
 
+  def pressed?(*args, &block); end
+
   def print(*args, &block); end
 
   def printf(*args, &block); end
@@ -20173,6 +21681,10 @@ class RSpec::Core::OutputWrapper
 
   def pwrite(*args, &block); end
 
+  def raw(*args, &block); end
+
+  def raw!(*args, &block); end
+
   def read(*args, &block); end
 
   def read_nonblock(*args, &block); end
@@ -20229,6 +21741,10 @@ class RSpec::Core::OutputWrapper
 
   def wait_writable(*args, &block); end
 
+  def winsize(*args, &block); end
+
+  def winsize=(*args, &block); end
+
   def write(*args, &block); end
 
   def write_nonblock(*args, &block); end
@@ -26841,6 +28357,8 @@ end
 RspecJunitFormatter = RSpecJUnitFormatter
 
 module RuboCop::AST::CollectionNode
+  def abbrev(*args, &block); end
+
   def compact_blank(*args, &block); end
 
   def compact_blank!(*args, &block); end
@@ -29948,6 +31466,10 @@ class User
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+class Utils::AST::FormulaAST
+  def process(*args, &block); end
+end
+
 class Utils::AST::FormulaAST
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks