# DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `pry` gem. # Please instead update this file by running `bin/tapioca gem pry`. # typed: true class BasicObject def __binding__; end end class Object < ::BasicObject include ::Kernel include ::JSON::Ext::Generator::GeneratorMethods::Object include ::PP::ObjectMixin def __binding__; end def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end end class Pry extend ::Forwardable extend ::Pry::Forwardable def initialize(options = T.unsafe(nil)); end def add_sticky_local(name, &block); end def backtrace; end def backtrace=(_arg0); end def binding_stack; end def binding_stack=(_arg0); end def color(*args, &block); end def color=(*args, &block); end def commands(*args, &block); end def commands=(*args, &block); end def complete(str); end def config; end def current_binding; end def current_context; end def custom_completions; end def custom_completions=(_arg0); end def editor(*args, &block); end def editor=(*args, &block); end def eval(line, options = T.unsafe(nil)); end def eval_string; end def eval_string=(_arg0); end def evaluate_ruby(code); end def exception_handler(*args, &block); end def exception_handler=(*args, &block); end def exec_hook(name, *args, &block); end def exit_value; end def extra_sticky_locals(*args, &block); end def extra_sticky_locals=(*args, &block); end def hooks(*args, &block); end def hooks=(*args, &block); end def inject_local(name, value, binding); end def inject_sticky_locals!; end def input(*args, &block); end def input=(*args, &block); end def input_ring; end def last_dir; end def last_dir=(_arg0); end def last_exception; end def last_exception=(exception); end def last_file; end def last_file=(_arg0); end def last_result; end def last_result=(_arg0); end def last_result_is_exception?; end def memory_size; end def memory_size=(size); end def output; end def output=(*args, &block); end def output_ring; end def pager; end def pager=(*args, &block); end def pop_prompt; end def print(*args, &block); end def print=(*args, &block); end def process_command(val); end def process_command_safely(val); end def prompt; end def prompt=(new_prompt); end def push_binding(object); end def push_initial_binding(target = T.unsafe(nil)); end def push_prompt(new_prompt); end def quiet?; end def raise_up(*args); end def raise_up!(*args); end def raise_up_common(force, *args); end def repl(target = T.unsafe(nil)); end def reset_eval_string; end def run_command(val); end def select_prompt; end def set_last_result(result, code = T.unsafe(nil)); end def should_print?; end def show_result(result); end def sticky_locals; end def suppress_output; end def suppress_output=(_arg0); end def update_input_history(code); end private def ensure_correct_encoding!(val); end def generate_prompt(prompt_proc, conf); end def handle_line(line, options); end def prompt_stack; end class << self def Code(obj); end def Method(obj); end def WrappedModule(obj); end def auto_resize!; end def binding_for(target); end def cli; end def cli=(_arg0); end def color(*args, &block); end def color=(*args, &block); end def commands(*args, &block); end def commands=(*args, &block); end def config; end def config=(_arg0); end def configure; end def critical_section; end def current; end def current_line; end def current_line=(_arg0); end def custom_completions; end def custom_completions=(_arg0); end def editor(*args, &block); end def editor=(*args, &block); end def eval_path; end def eval_path=(_arg0); end def exception_handler(*args, &block); end def exception_handler=(*args, &block); end def extra_sticky_locals(*args, &block); end def extra_sticky_locals=(*args, &block); end def final_session_setup; end def history(*args, &block); end def history=(*args, &block); end def hooks(*args, &block); end def hooks=(*args, &block); end def in_critical_section?; end def init; end def initial_session?; end def initial_session_setup; end def input(*args, &block); end def input=(*args, &block); end def last_internal_error; end def last_internal_error=(_arg0); end def line_buffer; end def line_buffer=(_arg0); end def load_file_at_toplevel(file); end def load_file_through_repl(file_name); end def load_history; end def load_rc_files; end def load_requires; end def load_traps; end def load_win32console; end def main; end def memory_size(*args, &block); end def memory_size=(*args, &block); end def output(*args, &block); end def output=(*args, &block); end def pager(*args, &block); end def pager=(*args, &block); end def print(*args, &block); end def print=(*args, &block); end def prompt(*args, &block); end def prompt=(*args, &block); end def quiet; end def quiet=(_arg0); end def rc_files_to_load; end def real_path_to(file); end def reset_defaults; end def run_command(command_string, options = T.unsafe(nil)); end def start(target = T.unsafe(nil), options = T.unsafe(nil)); end def start_with_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end def start_without_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end def toplevel_binding; end def toplevel_binding=(_arg0); end def view_clip(obj, options = T.unsafe(nil)); end end end Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array) class Pry::BasicObject < ::BasicObject include ::Kernel end Pry::BasicObject::Dir = Dir Pry::BasicObject::ENV = T.let(T.unsafe(nil), Object) Pry::BasicObject::File = File Pry::BasicObject::Kernel = Kernel Pry::BasicObject::LoadError = LoadError Pry::BasicObject::Pry = Pry class Pry::BlockCommand < ::Pry::Command def call(*args); end def help; end end class Pry::CLI class << self def add_option_processor(&block); end def add_options(&block); end def input_args; end def input_args=(_arg0); end def option_processors; end def option_processors=(_arg0); end def options; end def options=(_arg0); end def parse_options(args = T.unsafe(nil)); end def reset; end def start(opts); end end end class Pry::CLI::NoOptionsError < ::StandardError; end class Pry::ClassCommand < ::Pry::Command def args; end def args=(_arg0); end def call(*args); end def complete(search); end def help; end def options(opt); end def opts; end def opts=(_arg0); end def process; end def setup; end def slop; end def subcommands(cmd); end class << self def doc; end def file; end def inherited(klass); end def line; end def source; end def source_file; end def source_line; end def source_location; end private def source_object; end end end class Pry::Code extend ::MethodSource::CodeHelpers def initialize(lines = T.unsafe(nil), start_line = T.unsafe(nil), code_type = T.unsafe(nil)); end def <<(line); end def ==(other); end def after(lineno, lines = T.unsafe(nil)); end def around(lineno, lines = T.unsafe(nil)); end def before(lineno, lines = T.unsafe(nil)); end def between(start_line, end_line = T.unsafe(nil)); end def code_type; end def code_type=(_arg0); end def comment_describing(line_number); end def expression_at(line_number, consume = T.unsafe(nil)); end def grep(pattern); end def highlighted; end def length; end def max_lineno_width; end def method_missing(method_name, *args, &block); end def nesting_at(line_number); end def print_to_output(output, color = T.unsafe(nil)); end def push(line); end def raw; end def reject(&block); end def select(&block); end def take_lines(start_line, num_lines); end def to_s; end def with_indentation(spaces = T.unsafe(nil)); end def with_line_numbers(y_n = T.unsafe(nil)); end def with_marker(lineno = T.unsafe(nil)); end protected def alter(&block); end private def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end class << self def from_file(filename, code_type = T.unsafe(nil)); end def from_method(meth, start_line = T.unsafe(nil)); end def from_module(mod, candidate_rank = T.unsafe(nil), start_line = T.unsafe(nil)); end end end class Pry::Code::CodeRange def initialize(start_line, end_line = T.unsafe(nil)); end def indices_range(lines); end private def end_line; end def find_end_index(lines); end def find_start_index(lines); end def force_set_end_line; end def indices(lines); end def set_end_line_from_range; end def start_line; end end class Pry::Code::LOC def initialize(line, lineno); end def ==(other); end def add_line_number(max_width = T.unsafe(nil), color = T.unsafe(nil)); end def add_marker(marker_lineno); end def colorize(code_type); end def dup; end def handle_multiline_entries_from_edit_command(line, max_width); end def indent(distance); end def line; end def lineno; end def tuple; end end class Pry::CodeFile def initialize(filename, code_type = T.unsafe(nil)); end def code; end def code_type; end private def abs_path; end def code_path; end def from_load_path; end def from_pry_init_pwd; end def from_pwd; end def readable?(path); end def type_from_filename(filename, default = T.unsafe(nil)); end end Pry::CodeFile::DEFAULT_EXT = T.let(T.unsafe(nil), String) Pry::CodeFile::EXTENSIONS = T.let(T.unsafe(nil), Hash) Pry::CodeFile::FILES = T.let(T.unsafe(nil), Hash) Pry::CodeFile::INITIAL_PWD = T.let(T.unsafe(nil), String) class Pry::CodeObject include ::Pry::Helpers::OptionsHelpers include ::Pry::Helpers::CommandHelpers def initialize(str, pry_instance, options = T.unsafe(nil)); end def command_lookup; end def default_lookup; end def empty_lookup; end def method_or_class_lookup; end def pry_instance; end def pry_instance=(_arg0); end def str; end def str=(_arg0); end def super_level; end def super_level=(_arg0); end def target; end def target=(_arg0); end private def looks_like_an_instance_method?(str); end def lookup_super(obj, super_level); end def safe_to_evaluate?(str); end def sourcable_object?(obj); end def target_self; end class << self def lookup(str, pry_instance, options = T.unsafe(nil)); end end end module Pry::CodeObject::Helpers def c_method?; end def c_module?; end def command?; end def module_with_yard_docs?; end def real_method_object?; end end class Pry::ColorPrinter < ::PP def pp(object); end def text(str, max_width = T.unsafe(nil)); end private def highlight_object_literal(object_literal); end def inspect_object(object); end class << self def default(_output, value, pry_instance); end def pp(obj, output = T.unsafe(nil), max_width = T.unsafe(nil)); end end end class Pry::Command include ::Pry::Helpers::BaseHelpers include ::Pry::Helpers::OptionsHelpers include ::Pry::Helpers::CommandHelpers include ::Pry::Helpers::Text extend ::Pry::Helpers::DocumentationHelpers extend ::Pry::CodeObject::Helpers def initialize(context = T.unsafe(nil)); end def _pry_; end def _pry_=(_arg0); end def arg_string; end def arg_string=(_arg0); end def block; end def captures; end def captures=(_arg0); end def check_for_command_collision(command_match, arg_string); end def command_block; end def command_block=(_arg0); end def command_name; end def command_options; end def command_set; end def command_set=(_arg0); end def commands; end def complete(_search); end def context; end def context=(_arg0); end def description; end def eval_string; end def eval_string=(_arg0); end def hooks; end def hooks=(_arg0); end def interpolate_string(str); end def match; end def name; end def output; end def output=(_arg0); end def process_line(line); end def pry_instance; end def pry_instance=(_arg0); end def run(command_string, *args); end def source; end def state; end def target; end def target=(_arg0); end def target_self; end def tokenize(val); end def void; end private def after_hooks; end def before_hooks; end def call_safely(*args); end def call_with_hooks(*args); end def find_hooks(event); end def normalize_method_args(method, args); end def pass_block(arg_string); end def use_unpatched_symbol; end class << self def banner(arg = T.unsafe(nil)); end def block; end def block=(_arg0); end def command_name; end def command_options(arg = T.unsafe(nil)); end def command_options=(_arg0); end def command_regex; end def convert_to_regex(obj); end def default_options(match); end def description(arg = T.unsafe(nil)); end def description=(_arg0); end def doc; end def file; end def group(name = T.unsafe(nil)); end def inspect; end def line; end def match(arg = T.unsafe(nil)); end def match=(_arg0); end def match_score(val); end def matches?(val); end def name; end def options(arg = T.unsafe(nil)); end def options=(_arg0); end def source; end def source_file; end def source_line; end def state; end def subclass(match, description, options, helpers, &block); end end end class Pry::Command::AmendLine < ::Pry::ClassCommand def process; end private def amend_input; end def delete_from_array(array, range); end def insert_into_array(array, range); end def line_count; end def line_range; end def replace_in_array(array, range); end def start_and_end_line_number; end def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end end class Pry::Command::Bang < ::Pry::ClassCommand def process; end end class Pry::Command::BangPry < ::Pry::ClassCommand def process; end end class Pry::Command::Cat < ::Pry::ClassCommand def complete(search); end def load_path_completions; end def options(opt); end def process; end end class Pry::Command::Cat::AbstractFormatter include ::Pry::Helpers::OptionsHelpers include ::Pry::Helpers::CommandHelpers include ::Pry::Helpers::BaseHelpers private def between_lines; end def code_type; end def decorate(content); end def use_line_numbers?; end end class Pry::Command::Cat::ExceptionFormatter < ::Pry::Command::Cat::AbstractFormatter include ::Pry::Helpers::Text def initialize(exception, pry_instance, opts); end def ex; end def format; end def opts; end def pry_instance; end private def backtrace_file; end def backtrace_level; end def backtrace_line; end def check_for_errors; end def code_window_size; end def header; end def increment_backtrace_level; end def start_and_end_line_for_code_window; end end class Pry::Command::Cat::FileFormatter < ::Pry::Command::Cat::AbstractFormatter def initialize(file_with_embedded_line, pry_instance, opts); end def file_and_line; end def file_with_embedded_line; end def format; end def opts; end def pry_instance; end private def code_type; end def code_window_size; end def decorate(content); end def detect_code_type_from_file(file_name); end def file_name; end def line_number; end end class Pry::Command::Cat::InputExpressionFormatter < ::Pry::Command::Cat::AbstractFormatter def initialize(input_expressions, opts); end def format; end def input_expressions; end def input_expressions=(_arg0); end def opts; end def opts=(_arg0); end private def normalized_expression_range; end def numbered_input_items; end def selected_input_items; end end class Pry::Command::Cd < ::Pry::ClassCommand def process; end end class Pry::Command::ChangeInspector < ::Pry::ClassCommand def process(inspector); end private def inspector_map; end end class Pry::Command::ChangePrompt < ::Pry::ClassCommand def options(opt); end def process(prompt); end private def change_prompt(prompt); end def list_prompts; end end class Pry::Command::ClearScreen < ::Pry::ClassCommand def process; end end class Pry::Command::CodeCollector include ::Pry::Helpers::OptionsHelpers include ::Pry::Helpers::CommandHelpers def initialize(args, opts, pry_instance); end def args; end def code_object; end def content; end def file; end def file=(_arg0); end def line_range; end def obj_name; end def opts; end def pry_input_content; end def pry_instance; end def pry_output_content; end def restrict_to_lines(content, range); end private def bad_option_combination?; end def code_object_doc; end def code_object_source_or_file; end def convert_to_range(range); end def could_not_locate(name); end def file_content; end def pry_array_content_as_string(array, ranges); end class << self def inject_options(opt); end def input_expression_ranges; end def input_expression_ranges=(_arg0); end def output_result_ranges; end def output_result_ranges=(_arg0); end end end class Pry::Command::DisablePry < ::Pry::ClassCommand def process; end end class Pry::Command::Edit < ::Pry::ClassCommand def apply_runtime_patch; end def bad_option_combination?; end def code_object; end def ensure_file_name_is_valid(file_name); end def file_and_line; end def file_and_line_for_current_exception; end def file_based_exception?; end def file_edit; end def filename_argument; end def initial_temp_file_content; end def input_expression; end def never_reload?; end def options(opt); end def patch_exception?; end def previously_patched?(code_object); end def probably_a_file?(str); end def process; end def pry_method?(code_object); end def reload?(file_name = T.unsafe(nil)); end def reloadable?; end def repl_edit; end def repl_edit?; end def runtime_patch?; end end class Pry::Command::Edit::ExceptionPatcher def initialize(pry_instance, state, exception_file_and_line); end def file_and_line; end def file_and_line=(_arg0); end def perform_patch; end def pry_instance; end def pry_instance=(_arg0); end def state; end def state=(_arg0); end end module Pry::Command::Edit::FileAndLineLocator class << self def from_binding(target); end def from_code_object(code_object, filename_argument); end def from_exception(exception, backtrace_level); end def from_filename_argument(filename_argument); end end end class Pry::Command::Exit < ::Pry::ClassCommand def process; end def process_pop_and_return; end end class Pry::Command::ExitAll < ::Pry::ClassCommand def process; end end class Pry::Command::ExitProgram < ::Pry::ClassCommand def process; end end class Pry::Command::FindMethod < ::Pry::ClassCommand extend ::Pry::Helpers::BaseHelpers def options(opt); end def process; end private def additional_info(header, method); end def content_search(namespace); end def matched_method_lines(header, method); end def name_search(namespace); end def pattern; end def print_matches(matches); end def print_matches_for_class(klass, grouped); end def recurse_namespace(klass, done = T.unsafe(nil), &block); end def search_all_methods(namespace); end def search_class; end def show_search_results(matches); end end class Pry::Command::FixIndent < ::Pry::ClassCommand def process; end end class Pry::Command::Help < ::Pry::ClassCommand def command_groups; end def display_command(command); end def display_filtered_commands(search); end def display_filtered_search_results(search); end def display_index(groups); end def display_search(search); end def group_sort_key(group_name); end def help_text_for_commands(name, commands); end def normalize(key); end def process; end def search_hash(search, hash); end def sorted_commands(commands); end def sorted_group_names(groups); end def visible_commands; end end class Pry::Command::Hist < ::Pry::ClassCommand def options(opt); end def process; end private def check_for_juxtaposed_replay(replay_sequence); end def find_history; end def process_clear; end def process_display; end def process_replay; end def process_save; end end class Pry::Command::ImportSet < ::Pry::ClassCommand def process(_command_set_name); end end class Pry::Command::JumpTo < ::Pry::ClassCommand def process(break_level); end end class Pry::Command::ListInspectors < ::Pry::ClassCommand def process; end private def inspector_map; end def selected_inspector?(inspector); end def selected_text; end end class Pry::Command::Ls < ::Pry::ClassCommand def no_user_opts?; end def options(opt); end def process; end private def error_list; end def raise_errors_if_arguments_are_weird; end end class Pry::Command::Ls::Constants < ::Pry::Command::Ls::Formatter include ::Pry::Command::Ls::Interrogatable def initialize(interrogatee, no_user_opts, opts, pry_instance); end def correct_opts?; end def output_self; end private def format(mod, constants); end def show_deprecated_constants?; end end Pry::Command::Ls::Constants::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array) Pry::Command::Ls::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) class Pry::Command::Ls::Formatter def initialize(pry_instance); end def grep=(_arg0); end def pry_instance; end def write_out; end private def color(type, str); end def correct_opts?; end def format_value(value); end def grep; end def output_section(heading, body); end def output_self; end end class Pry::Command::Ls::Globals < ::Pry::Command::Ls::Formatter def initialize(opts, pry_instance); end def output_self; end private def format(globals); end end Pry::Command::Ls::Globals::BUILTIN_GLOBALS = T.let(T.unsafe(nil), Array) Pry::Command::Ls::Globals::PSEUDO_GLOBALS = T.let(T.unsafe(nil), Array) class Pry::Command::Ls::Grep def initialize(grep_regexp); end def regexp; end end class Pry::Command::Ls::InstanceVars < ::Pry::Command::Ls::Formatter include ::Pry::Command::Ls::Interrogatable def initialize(interrogatee, no_user_opts, opts, pry_instance); end def correct_opts?; end def output_self; end private def format(type, vars); end end module Pry::Command::Ls::Interrogatable private def interrogatee_mod; end def interrogating_a_module?; end end module Pry::Command::Ls::JRubyHacks private def rubbishness(name); end def trim_jruby_aliases(methods); end end class Pry::Command::Ls::LocalNames < ::Pry::Command::Ls::Formatter def initialize(no_user_opts, args, pry_instance); end def correct_opts?; end def output_self; end private def format(locals); end end class Pry::Command::Ls::LocalVars < ::Pry::Command::Ls::Formatter def initialize(opts, pry_instance); end def output_self; end private def colorized_assignment_style(lhs, rhs, desired_width = T.unsafe(nil)); end def format(name_value_pairs); end end class Pry::Command::Ls::LsEntity def initialize(opts); end def entities_table; end def pry_instance; end private def constants; end def entities; end def globals; end def grep(entity); end def instance_vars; end def local_names; end def local_vars; end def methods; end def self_methods; end end class Pry::Command::Ls::Methods < ::Pry::Command::Ls::Formatter include ::Pry::Command::Ls::Interrogatable include ::Pry::Command::Ls::JRubyHacks include ::Pry::Command::Ls::MethodsHelper def initialize(interrogatee, no_user_opts, opts, pry_instance); end def output_self; end private def below_ceiling; end def correct_opts?; end end module Pry::Command::Ls::MethodsHelper include ::Pry::Command::Ls::JRubyHacks private def all_methods(instance_methods = T.unsafe(nil)); end def format(methods); end def resolution_order; end end class Pry::Command::Ls::SelfMethods < ::Pry::Command::Ls::Formatter include ::Pry::Command::Ls::Interrogatable include ::Pry::Command::Ls::JRubyHacks include ::Pry::Command::Ls::MethodsHelper def initialize(interrogatee, no_user_opts, opts, pry_instance); end def output_self; end private def correct_opts?; end end class Pry::Command::Nesting < ::Pry::ClassCommand def process; end end class Pry::Command::Play < ::Pry::ClassCommand def code_object; end def content; end def content_after_options; end def content_at_expression; end def default_file; end def file_content; end def options(opt); end def perform_play; end def process; end def should_use_default_file?; end def show_input; end end class Pry::Command::PryBacktrace < ::Pry::ClassCommand def process; end end class Pry::Command::RaiseUp < ::Pry::ClassCommand def process; end end class Pry::Command::ReloadCode < ::Pry::ClassCommand def process; end private def check_for_reloadability(code_object, identifier); end def current_file; end def reload_current_file; end def reload_object(identifier); end end class Pry::Command::Reset < ::Pry::ClassCommand def process; end end class Pry::Command::Ri < ::Pry::ClassCommand def process(spec); end end class Pry::Command::SaveFile < ::Pry::ClassCommand def display_content; end def file_name; end def mode; end def options(opt); end def process; end def save_file; end end class Pry::Command::ShellCommand < ::Pry::ClassCommand def process(cmd); end private def cd_path_env; end def cd_path_exists?; end def parse_destination(dest); end def path_from_cd_path(dest); end def process_cd(dest); end def special_case_path?(dest); end end class Pry::Command::ShellMode < ::Pry::ClassCommand def process; end end class Pry::Command::ShowDoc < ::Pry::Command::ShowInfo include ::Pry::Helpers::DocumentationHelpers def content_for(code_object); end def docs_for(code_object); end def header_options; end def process; end def render_doc_markup_for(code_object); end def start_line_for(code_object); end end class Pry::Command::ShowInfo < ::Pry::ClassCommand extend ::Pry::Helpers::BaseHelpers def initialize(*_arg0); end def code_object_header(code_object, line_num); end def code_object_with_accessible_source(code_object); end def complete(input); end def content_and_header_for_code_object(code_object); end def content_and_headers_for_all_module_candidates(mod); end def file_and_line_for(code_object); end def header(code_object); end def header_options; end def method_header(code_object, line_num); end def method_sections(code_object); end def module_header(code_object, line_num); end def no_definition_message; end def obj_name; end def options(opt); end def process; end def show_all_modules?(code_object); end def start_line_for(code_object); end def use_line_numbers?; end def valid_superclass?(code_object); end end class Pry::Command::ShowInput < ::Pry::ClassCommand def process; end end class Pry::Command::ShowSource < ::Pry::Command::ShowInfo include ::Pry::Helpers::DocumentationHelpers def content_for(code_object); end def docs_for(code_object); end def header_options; end def options(opt); end def process; end def render_doc_markup_for(code_object); end def start_line_for(code_object); end end class Pry::Command::Stat < ::Pry::ClassCommand def options(opt); end def process; end end class Pry::Command::SwitchTo < ::Pry::ClassCommand def process(selection); end end class Pry::Command::ToggleColor < ::Pry::ClassCommand def color_toggle; end def process; end end Pry::Command::VOID_VALUE = T.let(T.unsafe(nil), Object) class Pry::Command::Version < ::Pry::ClassCommand def process; end end class Pry::Command::WatchExpression < ::Pry::ClassCommand def options(opt); end def process; end private def add_expression(_arguments); end def add_hook; end def delete(index); end def eval_and_print_changed(output); end def expressions; end def list; end end class Pry::Command::WatchExpression::Expression def initialize(pry_instance, target, source); end def changed?; end def eval!; end def previous_value; end def pry_instance; end def source; end def target; end def to_s; end def value; end private def target_eval(target, source); end end class Pry::Command::Whereami < ::Pry::ClassCommand def initialize(*_arg0); end def bad_option_combination?; end def code; end def code?; end def location; end def options(opt); end def process; end def setup; end private def class_code; end def code_window; end def default_code; end def expand_path(filename); end def handle_internal_binding; end def marker; end def method_code; end def nothing_to_do?; end def small_method?; end def target_class; end def top_level?; end def use_line_numbers?; end def valid_method?; end def window_size; end class << self def method_size_cutoff; end def method_size_cutoff=(_arg0); end end end class Pry::Command::Wtf < ::Pry::ClassCommand def options(opt); end def process; end private def format_backtrace(backtrace); end def format_header(title, exception); end def read_line(file, line); end def trim_backtrace(backtrace); end def unwind_exceptions; end end Pry::Command::Wtf::RUBY_FRAME_PATTERN = T.let(T.unsafe(nil), Regexp) class Pry::CommandError < ::StandardError; end class Pry::CommandSet include ::Enumerable include ::Pry::Helpers::BaseHelpers def initialize(*imported_sets, &block); end def [](pattern); end def []=(pattern, command); end def add_command(command); end def alias_command(match, action, options = T.unsafe(nil)); end def block_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end def command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end def complete(search, context = T.unsafe(nil)); end def create_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end def delete(*searches); end def desc(search, description = T.unsafe(nil)); end def each(&block); end def find_command(pattern); end def find_command_by_match_or_listing(match_or_listing); end def find_command_for_help(search); end def helper_module; end def import(*sets); end def import_from(set, *matches); end def keys; end def list_commands; end def process_line(val, context = T.unsafe(nil)); end def rename_command(new_match, search, options = T.unsafe(nil)); end def to_h; end def to_hash; end def valid_command?(val); end private def helpers(&block); end end class Pry::CommandState def initialize; end def reset(command_name); end def state_for(command_name); end class << self def default; end end end Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet) class Pry::Config extend ::Pry::Config::Attributable def initialize; end def [](attr); end def []=(attr, value); end def auto_indent; end def auto_indent=(_arg0); end def collision_warning; end def collision_warning=(_arg0); end def color; end def color=(_arg0); end def command_completions; end def command_completions=(_arg0); end def command_prefix; end def command_prefix=(_arg0); end def commands; end def commands=(_arg0); end def completer; end def completer=(_arg0); end def control_d_handler; end def control_d_handler=(value); end def correct_indent; end def correct_indent=(_arg0); end def default_window_size; end def default_window_size=(_arg0); end def disable_auto_reload; end def disable_auto_reload=(_arg0); end def editor; end def editor=(_arg0); end def exception_handler; end def exception_handler=(_arg0); end def exception_whitelist; end def exception_whitelist=(_arg0); end def exec_string; end def exec_string=(_arg0); end def extra_sticky_locals; end def extra_sticky_locals=(_arg0); end def file_completions; end def file_completions=(_arg0); end def history; end def history=(_arg0); end def history_file; end def history_file=(_arg0); end def history_ignorelist; end def history_ignorelist=(_arg0); end def history_load; end def history_load=(_arg0); end def history_save; end def history_save=(_arg0); end def hooks; end def hooks=(_arg0); end def input; end def input=(_arg0); end def ls; end def ls=(_arg0); end def memory_size; end def memory_size=(_arg0); end def merge(config_hash); end def merge!(config_hash); end def method_missing(method_name, *args, &_block); end def output; end def output=(_arg0); end def output_prefix; end def output_prefix=(_arg0); end def pager; end def pager=(_arg0); end def print; end def print=(_arg0); end def prompt; end def prompt=(_arg0); end def prompt_name; end def prompt_name=(_arg0); end def prompt_safe_contexts; end def prompt_safe_contexts=(_arg0); end def quiet; end def quiet=(_arg0); end def rc_file; end def rc_file=(_arg0); end def requires; end def requires=(_arg0); end def should_load_local_rc; end def should_load_local_rc=(_arg0); end def should_load_rc; end def should_load_rc=(_arg0); end def should_load_requires; end def should_load_requires=(_arg0); end def should_trap_interrupts; end def should_trap_interrupts=(_arg0); end def system; end def system=(_arg0); end def unrescued_exceptions; end def unrescued_exceptions=(_arg0); end def windows_console_warning; end def windows_console_warning=(_arg0); end private def default_rc_file; end def initialize_dup(other); end def lazy_readline; end def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end end module Pry::Config::Attributable def attribute(attr_name); end end class Pry::Config::LazyValue def initialize(&block); end def call; end end class Pry::Config::MemoizedValue def initialize(&block); end def call; end end class Pry::Config::Value def initialize(value); end def call; end end module Pry::ControlDHandler class << self def default(pry_instance); end end end Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array) class Pry::Editor include ::Pry::Helpers::OptionsHelpers include ::Pry::Helpers::CommandHelpers def initialize(pry_instance); end def build_editor_invocation_string(file, line, blocking); end def edit_tempfile_with_content(initial_content, line = T.unsafe(nil)); end def invoke_editor(file, line, blocking = T.unsafe(nil)); end def pry_instance; end private def blocking_flag_for_editor(blocking); end def editor_name; end def open_editor(editor_invocation); end def open_editor_on_jruby(editor_invocation); end def start_line_syntax_for_editor(file_name, line_number); end class << self def default; end end end module Pry::Env class << self def [](key); end end end module Pry::ExceptionHandler class << self def handle_exception(output, exception, _pry_instance); end private def cause_text(cause); end def exception_text(exception); end def standard_error_text_for(exception); end end end module Pry::Forwardable include ::Forwardable def def_private_delegators(target, *private_delegates); end end module Pry::FrozenObjectException class << self def ===(exception); end end end module Pry::Helpers class << self def tablify(things, line_length, pry_instance = T.unsafe(nil)); end def tablify_or_one_line(heading, things, pry_instance = T.unsafe(nil)); end def tablify_to_screen_width(things, options, pry_instance = T.unsafe(nil)); end end end module Pry::Helpers::BaseHelpers extend ::Pry::Helpers::BaseHelpers def colorize_code(code); end def find_command(name, set = T.unsafe(nil)); end def heading(text); end def highlight(string, regexp, highlight_color = T.unsafe(nil)); end def not_a_real_file?(file); end def safe_send(obj, method, *args, &block); end def silence_warnings; end def stagger_output(text, _out = T.unsafe(nil)); end def use_ansi_codes?; end end module Pry::Helpers::CommandHelpers include ::Pry::Helpers::OptionsHelpers extend ::Pry::Helpers::OptionsHelpers extend ::Pry::Helpers::CommandHelpers def absolute_index_number(line_number, array_length); end def absolute_index_range(range_or_number, array_length); end def get_method_or_raise(method_name, context, opts = T.unsafe(nil)); end def internal_binding?(context); end def one_index_number(line_number); end def one_index_range(range); end def one_index_range_or_number(range_or_number); end def restrict_to_lines(content, lines); end def set_file_and_dir_locals(file_name, pry = T.unsafe(nil), ctx = T.unsafe(nil)); end def temp_file(ext = T.unsafe(nil)); end def unindent(dirty_text, left_padding = T.unsafe(nil)); end end module Pry::Helpers::DocumentationHelpers private def get_comment_content(comment); end def process_comment_markup(comment); end def process_rdoc(comment); end def process_yardoc(comment); end def process_yardoc_tag(comment, tag); end def strip_comments_from_c_code(code); end def strip_leading_whitespace(text); end class << self def get_comment_content(comment); end def process_comment_markup(comment); end def process_rdoc(comment); end def process_yardoc(comment); end def process_yardoc_tag(comment, tag); end def strip_comments_from_c_code(code); end def strip_leading_whitespace(text); end end end Pry::Helpers::DocumentationHelpers::YARD_TAGS = T.let(T.unsafe(nil), Array) module Pry::Helpers::OptionsHelpers private def method_object; end def method_options(opt); end class << self def method_object; end def method_options(opt); end end end module Pry::Helpers::Platform class << self def jruby?; end def jruby_19?; end def linux?; end def mac_osx?; end def mri?; end def mri_19?; end def mri_2?; end def windows?; end def windows_ansi?; end end end class Pry::Helpers::Table def initialize(items, args, pry_instance = T.unsafe(nil)); end def ==(other); end def column_count; end def column_count=(count); end def columns; end def fits_on_line?(line_length); end def items; end def items=(items); end def rows_to_s(style = T.unsafe(nil)); end def to_a; end def to_s; end private def _max_width(things); end def _rebuild_colorless_cache; end def _recall_color_for(thing); end def _recolumn; end end module Pry::Helpers::Text extend ::Pry::Helpers::Text def black(text); end def black_on_black(text); end def black_on_blue(text); end def black_on_cyan(text); end def black_on_green(text); end def black_on_magenta(text); end def black_on_purple(text); end def black_on_red(text); end def black_on_white(text); end def black_on_yellow(text); end def blue(text); end def blue_on_black(text); end def blue_on_blue(text); end def blue_on_cyan(text); end def blue_on_green(text); end def blue_on_magenta(text); end def blue_on_purple(text); end def blue_on_red(text); end def blue_on_white(text); end def blue_on_yellow(text); end def bold(text); end def bright_black(text); end def bright_black_on_black(text); end def bright_black_on_blue(text); end def bright_black_on_cyan(text); end def bright_black_on_green(text); end def bright_black_on_magenta(text); end def bright_black_on_purple(text); end def bright_black_on_red(text); end def bright_black_on_white(text); end def bright_black_on_yellow(text); end def bright_blue(text); end def bright_blue_on_black(text); end def bright_blue_on_blue(text); end def bright_blue_on_cyan(text); end def bright_blue_on_green(text); end def bright_blue_on_magenta(text); end def bright_blue_on_purple(text); end def bright_blue_on_red(text); end def bright_blue_on_white(text); end def bright_blue_on_yellow(text); end def bright_cyan(text); end def bright_cyan_on_black(text); end def bright_cyan_on_blue(text); end def bright_cyan_on_cyan(text); end def bright_cyan_on_green(text); end def bright_cyan_on_magenta(text); end def bright_cyan_on_purple(text); end def bright_cyan_on_red(text); end def bright_cyan_on_white(text); end def bright_cyan_on_yellow(text); end def bright_green(text); end def bright_green_on_black(text); end def bright_green_on_blue(text); end def bright_green_on_cyan(text); end def bright_green_on_green(text); end def bright_green_on_magenta(text); end def bright_green_on_purple(text); end def bright_green_on_red(text); end def bright_green_on_white(text); end def bright_green_on_yellow(text); end def bright_magenta(text); end def bright_magenta_on_black(text); end def bright_magenta_on_blue(text); end def bright_magenta_on_cyan(text); end def bright_magenta_on_green(text); end def bright_magenta_on_magenta(text); end def bright_magenta_on_purple(text); end def bright_magenta_on_red(text); end def bright_magenta_on_white(text); end def bright_magenta_on_yellow(text); end def bright_purple(text); end def bright_purple_on_black(text); end def bright_purple_on_blue(text); end def bright_purple_on_cyan(text); end def bright_purple_on_green(text); end def bright_purple_on_magenta(text); end def bright_purple_on_purple(text); end def bright_purple_on_red(text); end def bright_purple_on_white(text); end def bright_purple_on_yellow(text); end def bright_red(text); end def bright_red_on_black(text); end def bright_red_on_blue(text); end def bright_red_on_cyan(text); end def bright_red_on_green(text); end def bright_red_on_magenta(text); end def bright_red_on_purple(text); end def bright_red_on_red(text); end def bright_red_on_white(text); end def bright_red_on_yellow(text); end def bright_white(text); end def bright_white_on_black(text); end def bright_white_on_blue(text); end def bright_white_on_cyan(text); end def bright_white_on_green(text); end def bright_white_on_magenta(text); end def bright_white_on_purple(text); end def bright_white_on_red(text); end def bright_white_on_white(text); end def bright_white_on_yellow(text); end def bright_yellow(text); end def bright_yellow_on_black(text); end def bright_yellow_on_blue(text); end def bright_yellow_on_cyan(text); end def bright_yellow_on_green(text); end def bright_yellow_on_magenta(text); end def bright_yellow_on_purple(text); end def bright_yellow_on_red(text); end def bright_yellow_on_white(text); end def bright_yellow_on_yellow(text); end def cyan(text); end def cyan_on_black(text); end def cyan_on_blue(text); end def cyan_on_cyan(text); end def cyan_on_green(text); end def cyan_on_magenta(text); end def cyan_on_purple(text); end def cyan_on_red(text); end def cyan_on_white(text); end def cyan_on_yellow(text); end def default(text); end def green(text); end def green_on_black(text); end def green_on_blue(text); end def green_on_cyan(text); end def green_on_green(text); end def green_on_magenta(text); end def green_on_purple(text); end def green_on_red(text); end def green_on_white(text); end def green_on_yellow(text); end def indent(text, chars); end def magenta(text); end def magenta_on_black(text); end def magenta_on_blue(text); end def magenta_on_cyan(text); end def magenta_on_green(text); end def magenta_on_magenta(text); end def magenta_on_purple(text); end def magenta_on_red(text); end def magenta_on_white(text); end def magenta_on_yellow(text); end def no_color; end def no_pager; end def purple(text); end def purple_on_black(text); end def purple_on_blue(text); end def purple_on_cyan(text); end def purple_on_green(text); end def purple_on_magenta(text); end def purple_on_purple(text); end def purple_on_red(text); end def purple_on_white(text); end def purple_on_yellow(text); end def red(text); end def red_on_black(text); end def red_on_blue(text); end def red_on_cyan(text); end def red_on_green(text); end def red_on_magenta(text); end def red_on_purple(text); end def red_on_red(text); end def red_on_white(text); end def red_on_yellow(text); end def strip_color(text); end def white(text); end def white_on_black(text); end def white_on_blue(text); end def white_on_cyan(text); end def white_on_green(text); end def white_on_magenta(text); end def white_on_purple(text); end def white_on_red(text); end def white_on_white(text); end def white_on_yellow(text); end def with_line_numbers(text, offset, color = T.unsafe(nil)); end def yellow(text); end def yellow_on_black(text); end def yellow_on_blue(text); end def yellow_on_cyan(text); end def yellow_on_green(text); end def yellow_on_magenta(text); end def yellow_on_purple(text); end def yellow_on_red(text); end def yellow_on_white(text); end def yellow_on_yellow(text); end end Pry::Helpers::Text::COLORS = T.let(T.unsafe(nil), Hash) class Pry::History def initialize(options = T.unsafe(nil)); end def <<(line); end def clear; end def filter(history); end def history_line_count; end def load; end def loader; end def loader=(_arg0); end def original_lines; end def push(line); end def saver; end def saver=(_arg0); end def session_line_count; end def to_a; end private def history_file; end def history_file_path; end def invalid_readline_line?(line); end def read_from_file; end def save_to_file(line); end def should_ignore?(line); end class << self def default_file; end end end class Pry::Hooks def initialize; end def add_hook(event_name, hook_name, callable = T.unsafe(nil), &block); end def clear_event_hooks(event_name); end def delete_hook(event_name, hook_name); end def errors; end def exec_hook(event_name, *args, &block); end def get_hook(event_name, hook_name); end def get_hooks(event_name); end def hook_count(event_name); end def hook_exists?(event_name, hook_name); end def merge(other); end def merge!(other); end protected def hooks; end private def initialize_copy(_orig); end class << self def default; end end end class Pry::Indent include ::Pry::Helpers::BaseHelpers def initialize(pry_instance = T.unsafe(nil)); end def correct_indentation(prompt, code, overhang = T.unsafe(nil)); end def current_prefix; end def end_of_statement?(last_token, last_kind); end def in_string?; end def indent(input); end def indent_level; end def indentation_delta(tokens); end def module_nesting; end def open_delimiters; end def open_delimiters_line; end def reset; end def stack; end def tokenize(string); end def track_delimiter(token); end def track_module_nesting(token, kind); end def track_module_nesting_end(token, kind = T.unsafe(nil)); end class << self def indent(str); end def nesting_at(str, line_number); end end end Pry::Indent::IGNORE_TOKENS = T.let(T.unsafe(nil), Array) Pry::Indent::MIDWAY_TOKENS = T.let(T.unsafe(nil), Array) Pry::Indent::OPEN_TOKENS = T.let(T.unsafe(nil), Hash) Pry::Indent::OPTIONAL_DO_TOKENS = T.let(T.unsafe(nil), Array) Pry::Indent::SINGLELINE_TOKENS = T.let(T.unsafe(nil), Array) Pry::Indent::SPACES = T.let(T.unsafe(nil), String) Pry::Indent::STATEMENT_END_TOKENS = T.let(T.unsafe(nil), Array) class Pry::Indent::UnparseableNestingError < ::StandardError; end class Pry::InputCompleter def initialize(input, pry = T.unsafe(nil)); end def build_path(input); end def call(str, options = T.unsafe(nil)); end def ignored_modules; end def select_message(path, receiver, message, candidates); end end Pry::InputCompleter::ARRAY_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::CONSTANT_OR_METHOD_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::CONSTANT_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::GLOBALVARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::HEX_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::NUMERIC_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::PROC_OR_HASH_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::REGEX_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::RESERVED_WORDS = T.let(T.unsafe(nil), Array) Pry::InputCompleter::SYMBOL_METHOD_CALL_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::SYMBOL_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::TOPLEVEL_LOOKUP_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::VARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp) Pry::InputCompleter::WORD_ESCAPE_STR = T.let(T.unsafe(nil), String) class Pry::InputLock def initialize; end def __with_ownership; end def enter_interruptible_region; end def interruptible_region; end def leave_interruptible_region; end def with_ownership(&block); end class << self def for(input); end def global_lock; end def global_lock=(_arg0); end def input_locks; end def input_locks=(_arg0); end end end class Pry::InputLock::Interrupt < ::Exception; end class Pry::Inspector; end Pry::Inspector::MAP = T.let(T.unsafe(nil), Hash) Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String) class Pry::LastException < ::BasicObject def initialize(exception); end def bt_index; end def bt_index=(_arg0); end def bt_source_location_for(index); end def file; end def inc_bt_index; end def line; end def method_missing(name, *args, &block); end def wrapped_exception; end private def respond_to_missing?(name, include_all = T.unsafe(nil)); end end class Pry::Method include ::Pry::Helpers::BaseHelpers include ::Pry::Helpers::DocumentationHelpers include ::Pry::CodeObject::Helpers extend ::Pry::Helpers::BaseHelpers extend ::Forwardable extend ::Pry::Forwardable def initialize(method, known_info = T.unsafe(nil)); end def ==(other); end def alias?; end def aliases; end def bound_method?; end def comment; end def doc; end def dynamically_defined?; end def is_a?(klass); end def kind_of?(klass); end def method_missing(method_name, *args, &block); end def name; end def name_with_owner; end def original_name; end def owner(*args, &block); end def parameters(*args, &block); end def pry_method?; end def receiver(*args, &block); end def redefine(source); end def respond_to?(method_name, include_all = T.unsafe(nil)); end def signature; end def singleton_method?; end def source; end def source?; end def source_file; end def source_line; end def source_range; end def source_type; end def super(times = T.unsafe(nil)); end def unbound_method?; end def undefined?; end def visibility; end def wrapped; end def wrapped_owner; end private def c_source; end def method_name_from_first_line(first_ln); end def pry_doc_info; end def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end def ruby_source; end def super_using_ancestors(ancestors, times = T.unsafe(nil)); end class << self def all_from_class(klass, include_super = T.unsafe(nil)); end def all_from_obj(obj, include_super = T.unsafe(nil)); end def from_binding(binding); end def from_class(klass, name, target = T.unsafe(nil)); end def from_module(klass, name, target = T.unsafe(nil)); end def from_obj(obj, name, target = T.unsafe(nil)); end def from_str(name, target = T.unsafe(nil), options = T.unsafe(nil)); end def instance_method_definition?(name, definition_line); end def instance_resolution_order(klass); end def lookup_method_via_binding(obj, method_name, method_type, target = T.unsafe(nil)); end def method_definition?(name, definition_line); end def resolution_order(obj); end def singleton_class_of(obj); end def singleton_class_resolution_order(klass); end def singleton_method_definition?(name, definition_line); end end end class Pry::Method::Disowned < ::Pry::Method def initialize(receiver, method_name); end def method_missing(method_name, *args, &block); end def name; end def owner; end def receiver; end def source?; end def undefined?; end private def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end end class Pry::Method::Patcher def initialize(method); end def method; end def method=(_arg0); end def patch_in_ram(source); end private def cache_key; end def definition_for_owner(line); end def redefine(source); end def with_method_transaction; end def wrap(source); end def wrap_for_nesting(source); end def wrap_for_owner(source); end class << self def code_for(filename); end end end class Pry::Method::WeirdMethodLocator def initialize(method, target); end def find_method; end def lost_method?; end def method; end def method=(_arg0); end def target; end def target=(_arg0); end private def all_methods_for(obj); end def expanded_source_location(source_location); end def find_method_in_superclass; end def find_renamed_method; end def index_to_line_number(index); end def lines_for_file(file); end def normal_method?(method); end def pry_file?; end def renamed_method_source_location; end def skip_superclass_search?; end def target_file; end def target_line; end def target_self; end def valid_file?(file); end class << self def normal_method?(method, binding); end def weird_method?(method, binding); end end end class Pry::MethodNotFound < ::Pry::CommandError; end class Pry::NoCommandError < ::StandardError def initialize(match, owner); end end class Pry::ObjectPath def initialize(path_string, current_stack); end def resolve; end private def complete?(segment); end def handle_failure(context, err); end end Pry::ObjectPath::SPECIAL_TERMS = T.let(T.unsafe(nil), Array) class Pry::ObsoleteError < ::StandardError; end class Pry::Output def initialize(pry_instance); end def <<(*objs); end def decolorize_maybe(str); end def height; end def method_missing(method_name, *args, &block); end def print(*objs); end def pry_instance; end def puts(*objs); end def size; end def tty?; end def width; end def write(*objs); end private def actual_screen_size; end def ansicon_env_size; end def env_size; end def io_console_size; end def nonzero_column?(size); end def readline_size; end def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end end Pry::Output::DEFAULT_SIZE = T.let(T.unsafe(nil), Array) class Pry::Pager def initialize(pry_instance); end def open; end def page(text); end def pry_instance; end private def best_available; end def enabled?; end def output; end end class Pry::Pager::NullPager def initialize(out); end def <<(str); end def close; end def print(str); end def puts(str); end def write(str); end private def height; end def width; end end class Pry::Pager::PageTracker def initialize(rows, cols); end def page?; end def record(str); end def reset; end private def line_length(line); end end class Pry::Pager::SimplePager < ::Pry::Pager::NullPager def initialize(*_arg0); end def write(str); end end class Pry::Pager::StopPaging < ::StandardError; end class Pry::Pager::SystemPager < ::Pry::Pager::NullPager def initialize(*_arg0); end def close; end def write(str); end private def invoked_pager?; end def pager; end def write_to_pager(text); end class << self def available?; end def default_pager; end end end class Pry::Prompt def initialize(name, description, prompt_procs); end def [](key); end def description; end def incomplete_proc; end def name; end def prompt_procs; end def wait_proc; end class << self def [](name); end def add(name, description = T.unsafe(nil), separators = T.unsafe(nil)); end def all; end end end class Pry::REPL extend ::Forwardable extend ::Pry::Forwardable def initialize(pry, options = T.unsafe(nil)); end def input(*args, &block); end def output(*args, &block); end def pry; end def pry=(_arg0); end def start; end private def calculate_overhang(current_prompt, original_val, indented_val); end def coolline_available?; end def epilogue; end def handle_read_errors; end def input_readline(*args); end def piping?; end def prologue; end def read; end def read_line(current_prompt); end def readline_available?; end def repl; end def set_readline_output; end class << self def start(options); end end end class Pry::REPLFileLoader def initialize(file_name); end def define_additional_commands; end def interactive_mode(pry_instance); end def load; end def non_interactive_mode(pry_instance, content); end end module Pry::RescuableException class << self def ===(exception); end end end class Pry::Result def initialize(is_command, retval = T.unsafe(nil)); end def command?; end def retval; end def void_command?; end end class Pry::Ring def initialize(max_size); end def <<(value); end def [](index); end def clear; end def count; end def max_size; end def size; end def to_a; end private def transpose_buffer_tail; end end class Pry::Slop include ::Enumerable def initialize(config = T.unsafe(nil), &block); end def [](key); end def add_callback(label, &block); end def banner(banner = T.unsafe(nil)); end def banner=(banner); end def command(command, options = T.unsafe(nil), &block); end def config; end def description(desc = T.unsafe(nil)); end def description=(desc); end def each(&block); end def fetch_command(command); end def fetch_option(key); end def get(key); end def help; end def missing; end def on(*objects, &block); end def opt(*objects, &block); end def option(*objects, &block); end def options; end def parse(items = T.unsafe(nil), &block); end def parse!(items = T.unsafe(nil), &block); end def present?(*keys); end def run(callable = T.unsafe(nil), &block); end def separator(text); end def strict?; end def to_h(include_commands = T.unsafe(nil)); end def to_hash(include_commands = T.unsafe(nil)); end def to_s; end private def autocreate(items, index); end def build_option(objects, &block); end def clean(object); end def commands_to_help; end def execute_multiple_switches(option, argument, index); end def execute_option(option, argument, index, item = T.unsafe(nil)); end def extract_long_flag(objects, config); end def extract_option(flag); end def extract_short_flag(objects, config); end def method_missing(method, *args, &block); end def process_item(items, index, &block); end def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end class << self def optspec(string, config = T.unsafe(nil)); end def parse(items = T.unsafe(nil), config = T.unsafe(nil), &block); end def parse!(items = T.unsafe(nil), config = T.unsafe(nil), &block); end end end class Pry::Slop::Commands include ::Enumerable def initialize(config = T.unsafe(nil), &block); end def [](key); end def arguments; end def banner(banner = T.unsafe(nil)); end def banner=(_arg0); end def commands; end def config; end def default(config = T.unsafe(nil), &block); end def each(&block); end def get(key); end def global(config = T.unsafe(nil), &block); end def help; end def inspect; end def on(command, config = T.unsafe(nil), &block); end def parse(items = T.unsafe(nil)); end def parse!(items = T.unsafe(nil)); end def present?(key); end def to_hash; end def to_s; end private def execute_arguments!(items); end def execute_global_opts!(items); end end Pry::Slop::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) class Pry::Slop::Error < ::StandardError; end class Pry::Slop::InvalidArgumentError < ::Pry::Slop::Error; end class Pry::Slop::InvalidCommandError < ::Pry::Slop::Error; end class Pry::Slop::InvalidOptionError < ::Pry::Slop::Error; end class Pry::Slop::MissingArgumentError < ::Pry::Slop::Error; end class Pry::Slop::MissingOptionError < ::Pry::Slop::Error; end class Pry::Slop::Option def initialize(slop, short, long, description, config = T.unsafe(nil), &block); end def accepts_optional_argument?; end def argument_in_value; end def argument_in_value=(_arg0); end def call(*objects); end def config; end def count; end def count=(_arg0); end def description; end def expects_argument?; end def help; end def inspect; end def key; end def long; end def short; end def to_s; end def types; end def value; end def value=(new_value); end private def value_to_float(value); end def value_to_integer(value); end def value_to_range(value); end end Pry::Slop::Option::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) Pry::Slop::VERSION = T.let(T.unsafe(nil), String) class Pry::SyntaxHighlighter class << self def highlight(code, language = T.unsafe(nil)); end def keyword_token_color; end def overwrite_coderay_comment_token!; end def tokenize(code, language = T.unsafe(nil)); end end end module Pry::SystemCommandHandler class << self def default(output, command, _pry_instance); end end end module Pry::TooSafeException class << self def ===(exception); end end end module Pry::UserError; end Pry::VERSION = T.let(T.unsafe(nil), String) module Pry::Warning class << self def warn(message); end end end class Pry::WrappedModule include ::Pry::Helpers::BaseHelpers include ::Pry::CodeObject::Helpers def initialize(mod); end def candidate(rank); end def candidates; end def class?; end def constants(inherit = T.unsafe(nil)); end def doc; end def file; end def line; end def method_missing(method_name, *args, &block); end def method_prefix; end def module?; end def nonblank_name; end def number_of_candidates; end def singleton_class?; end def singleton_instance; end def source; end def source_file; end def source_line; end def source_location; end def super(times = T.unsafe(nil)); end def wrapped; end def yard_doc; end def yard_docs?; end def yard_file; end def yard_line; end private def all_methods_for(mod); end def all_relevant_methods_for(mod); end def all_source_locations_by_popularity; end def lines_for_file(file); end def method_candidates; end def method_defined_by_forwardable_module?(method); end def nested_module?(parent, name); end def primary_candidate; end def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end class << self def from_str(mod_name, target = T.unsafe(nil)); end private def safe_to_evaluate?(str, target); end end end class Pry::WrappedModule::Candidate include ::Pry::Helpers::DocumentationHelpers include ::Pry::CodeObject::Helpers extend ::Forwardable extend ::Pry::Forwardable def initialize(wrapper, rank); end def class?(*args, &block); end def doc; end def file; end def line; end def module?(*args, &block); end def nonblank_name(*args, &block); end def number_of_candidates(*args, &block); end def source; end def source_file; end def source_line; end def source_location; end def wrapped(*args, &block); end private def class_regexes; end def first_line_of_module_definition(file, line); end def first_method_source_location; end def last_method_source_location; end def lines_for_file(*a, &b); end def method_candidates(*a, &b); end def name(*a, &b); end def number_of_lines_in_first_chunk; end def yard_docs?(*a, &b); end end