# This file is autogenerated. Do not edit it by hand. Regenerate it with:
#   srb rbi gems

# typed: true
#
# If you would like to make changes to this file, great! Please create the gem's shim here:
#
#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pry/all/pry.rbi
#
# pry-0.9.12.6

class Pry
  def add_sticky_local(name, &block); end
  def backtrace; end
  def backtrace=(arg0); end
  def binding_stack; end
  def binding_stack=(arg0); end
  def command_state; end
  def commands; end
  def commands=(arg0); end
  def current_context; end
  def custom_completions; end
  def custom_completions=(arg0); end
  def evaluate_ruby(code, target = nil); end
  def exception_handler; end
  def exception_handler=(arg0); end
  def exec_hook(name, *args, &block); end
  def extra_sticky_locals; end
  def extra_sticky_locals=(arg0); end
  def generate_prompt(prompt_proc, conf); end
  def handle_read_errors; end
  def hooks; end
  def hooks=(v); end
  def initialize(options = nil); end
  def inject_local(name, value, b); end
  def inject_sticky_locals(target); end
  def input; end
  def input=(arg0); end
  def input_array; end
  def input_stack; end
  def input_stack=(arg0); end
  def last_dir; end
  def last_dir=(arg0); end
  def last_exception; end
  def last_exception=(ex); 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=(arg0); end
  def output_array; end
  def pop_prompt; end
  def print; end
  def print=(arg0); end
  def process_command(val, eval_string = nil, target = nil); end
  def prompt; end
  def prompt=(new_prompt); end
  def prompt_stack; end
  def push_prompt(new_prompt); end
  def quiet; end
  def quiet=(arg0); end
  def quiet?; end
  def r(target = nil, eval_string = nil); end
  def raise_up!(*args); end
  def raise_up(*args); end
  def raise_up_common(force, *args); end
  def re(target = nil); end
  def readline(current_prompt = nil, completion_proc = nil); end
  def refresh(options = nil); end
  def rep(target = nil); end
  def repl(target = nil); end
  def repl_epilogue(target); end
  def repl_prologue(target); end
  def retrieve_line(eval_string, target); end
  def run_command(val, eval_string = nil, target = nil); end
  def select_prompt(eval_string, target); end
  def self.Code(obj); end
  def self.Method(obj); end
  def self.WrappedModule(obj); end
  def self.auto_resize!; end
  def self.binding_for(target); end
  def self.cli; end
  def self.cli=(arg0); end
  def self.color(*args, &block); end
  def self.color=(*args, &block); end
  def self.commands(*args, &block); end
  def self.commands=(*args, &block); end
  def self.config; end
  def self.config=(arg0); end
  def self.critical_section(&block); end
  def self.current; end
  def self.current_line; end
  def self.current_line=(arg0); end
  def self.custom_completions; end
  def self.custom_completions=(arg0); end
  def self.default_editor_for_platform; end
  def self.editor(*args, &block); end
  def self.editor=(*args, &block); end
  def self.eval_path; end
  def self.eval_path=(arg0); end
  def self.exception_handler(*args, &block); end
  def self.exception_handler=(*args, &block); end
  def self.extra_sticky_locals(*args, &block); end
  def self.extra_sticky_locals=(*args, &block); end
  def self.fix_coderay_colors; end
  def self.history; end
  def self.history=(arg0); end
  def self.hooks(*args, &block); end
  def self.hooks=(*args, &block); end
  def self.in_critical_section?; end
  def self.init; end
  def self.initial_session?; end
  def self.initial_session_setup; end
  def self.input(*args, &block); end
  def self.input=(*args, &block); end
  def self.input_stack(*args, &block); end
  def self.input_stack=(*args, &block); end
  def self.last_internal_error; end
  def self.last_internal_error=(arg0); end
  def self.line_buffer; end
  def self.line_buffer=(arg0); end
  def self.load_file_at_toplevel(file_name); end
  def self.load_file_through_repl(file_name); end
  def self.load_history; end
  def self.load_local_rc; end
  def self.load_plugins(*args, &block); end
  def self.load_rc; end
  def self.load_requires; end
  def self.load_traps; end
  def self.locate_plugins(*args, &block); end
  def self.memory_size(*args, &block); end
  def self.memory_size=(*args, &block); end
  def self.output(*args, &block); end
  def self.output=(*args, &block); end
  def self.output_with_default_format(output, value, options = nil); end
  def self.pager(*args, &block); end
  def self.pager=(*args, &block); end
  def self.plugins(*args, &block); end
  def self.print(*args, &block); end
  def self.print=(*args, &block); end
  def self.prompt(*args, &block); end
  def self.prompt=(*args, &block); end
  def self.quiet; end
  def self.quiet=(arg0); end
  def self.require_readline; end
  def self.reset_defaults; end
  def self.run_command(command_string, options = nil); end
  def self.save_history; end
  def self.set_config_defaults; end
  def self.start(target = nil, options = nil); end
  def self.toplevel_binding; end
  def self.toplevel_binding=(arg0); end
  def self.view_clip(obj, max_length = nil); end
  def set_last_result(result, target, code = nil); end
  def should_force_encoding?(eval_string, val); 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
end
module Pry::Helpers
  def self.tablify(things, line_length); end
  def self.tablify_or_one_line(heading, things); end
  def self.tablify_to_screen_width(things, options = nil); end
end
module Pry::Helpers::BaseHelpers
  def colorize_code(code); end
  def command_dependencies_met?(options); end
  def context_from_object_path(arg_string, _pry_ = nil, old_stack = nil); end
  def find_command(name, set = nil); end
  def heading(text); end
  def highlight(string, regexp, highlight_color = nil); end
  def jruby?; end
  def jruby_19?; end
  def mri_18?; end
  def mri_19?; end
  def not_a_real_file?(file); end
  def rbx?; end
  def safe_send(obj, method, *args, &block); end
  def self.colorize_code(code); end
  def self.command_dependencies_met?(options); end
  def self.context_from_object_path(arg_string, _pry_ = nil, old_stack = nil); end
  def self.find_command(name, set = nil); end
  def self.heading(text); end
  def self.highlight(string, regexp, highlight_color = nil); end
  def self.jruby?; end
  def self.jruby_19?; end
  def self.mri_18?; end
  def self.mri_19?; end
  def self.not_a_real_file?(file); end
  def self.rbx?; end
  def self.safe_send(obj, method, *args, &block); end
  def self.set_file_and_dir_locals(file_name, _pry_ = nil, target = nil); end
  def self.silence_warnings; end
  def self.stagger_output(text, out = nil); end
  def self.use_ansi_codes?; end
  def self.windows?; end
  def self.windows_ansi?; end
  def set_file_and_dir_locals(file_name, _pry_ = nil, target = nil); end
  def silence_warnings; end
  def stagger_output(text, out = nil); end
  def use_ansi_codes?; end
  def windows?; end
  def windows_ansi?; end
end
class Pry::Hooks
  def [](event_name); end
  def []=(event_name, callable); end
  def add_hook(event_name, hook_name, callable = nil, &block); end
  def clear(event_name); end
  def clear_all; end
  def delete_hook(event_name, hook_name); end
  def delete_hooks(event_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 hooks; end
  def initialize; end
  def initialize_copy(orig); end
  def merge!(other); end
  def merge(other); end
  def merge_arrays(array1, array2); end
  def self.from_hash(hash); end
  def uniq_keeping_last(input, &block); end
end
module Pry::RbxMethod
  def core_code; end
  def core_doc; end
end
module Pry::RbxPath
  def convert_path_to_full(path); end
  def is_core_path?(path); end
  def rvm_ruby?(path); end
  def self.convert_path_to_full(path); end
  def self.is_core_path?(path); end
  def self.rvm_ruby?(path); end
end
class Pry::Code
  def <<(line, lineno = nil); end
  def ==(other); end
  def after(lineno, lines = nil); end
  def alter(&block); end
  def around(lineno, lines = nil); end
  def before(lineno, lines = nil); end
  def between(start_line, end_line = nil); end
  def code_type; end
  def code_type=(arg0); end
  def comment_describing(line_number); end
  def expression_at(line_number, consume = nil); end
  def grep(pattern); end
  def initialize(lines = nil, start_line = nil, code_type = nil); end
  def inspect; end
  def length; end
  def max_lineno_width; end
  def method_missing(name, *args, &block); end
  def nesting_at(line_number, top_module = nil); end
  def push(line, lineno = nil); end
  def raw; end
  def select(&block); end
  def self.abs_path(filename); end
  def self.from_file(filename, code_type = nil); end
  def self.from_method(meth, start_line = nil); end
  def self.from_module(mod, candidate_rank = nil, start_line = nil); end
  def self.type_from_filename(filename, default = nil); end
  def take_lines(start_line, num_lines); end
  def to_s; end
  def with_indentation(spaces = nil); end
  def with_line_numbers(y_n = nil); end
  def with_marker(lineno = nil); end
end
class Pry::Code::LOC
  def ==(other); end
  def add_line_number(max_width = nil); end
  def add_marker(marker_lineno); end
  def colorize(code_type); end
  def dup; end
  def indent(distance); end
  def initialize(line, lineno); end
  def line; end
  def lineno; end
  def tuple; end
end
class Pry::Code::CodeRange
  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 indices_range(lines); end
  def initialize(start_line, end_line = nil); end
  def set_end_line_from_range; end
  def start_line; end
end
class Pry::HistoryArray
  def <<(value); end
  def [](index_or_range, size = nil); end
  def convert_index(n); end
  def convert_range(range); end
  def count; end
  def each; end
  def empty?; end
  def initialize(size); end
  def inspect; end
  def length; end
  def max_size; end
  def pop!; end
  def size; end
  def to_a; end
  include Enumerable
end
module Pry::Helpers::OptionsHelpers
  def method_object; end
  def method_options(opt); end
  def self.method_object; end
  def self.method_options(opt); end
end
module Pry::Helpers::CommandHelpers
  def absolute_index_number(line_number, array_length); end
  def absolute_index_range(range_or_number, array_length); end
  def command_error(message, omit_help, klass = nil); end
  def get_method_or_raise(name, target, opts = nil, omit_help = nil); end
  def internal_binding?(target); 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 render_output(str, opts = nil); end
  def restrict_to_lines(content, lines); end
  def self.absolute_index_number(line_number, array_length); end
  def self.absolute_index_range(range_or_number, array_length); end
  def self.command_error(message, omit_help, klass = nil); end
  def self.get_method_or_raise(name, target, opts = nil, omit_help = nil); end
  def self.internal_binding?(target); end
  def self.one_index_number(line_number); end
  def self.one_index_range(range); end
  def self.one_index_range_or_number(range_or_number); end
  def self.render_output(str, opts = nil); end
  def self.restrict_to_lines(content, lines); end
  def self.temp_file(ext = nil); end
  def self.unindent(text, left_padding = nil); end
  def temp_file(ext = nil); end
  def unindent(text, left_padding = nil); end
  include Pry::Helpers::OptionsHelpers
end
module Pry::Helpers::Text
  def self.black(text); end
  def self.blue(text); end
  def self.bold(text); end
  def self.bright_black(text); end
  def self.bright_blue(text); end
  def self.bright_cyan(text); end
  def self.bright_default(text); end
  def self.bright_green(text); end
  def self.bright_magenta(text); end
  def self.bright_purple(text); end
  def self.bright_red(text); end
  def self.bright_white(text); end
  def self.bright_yellow(text); end
  def self.cyan(text); end
  def self.default(text); end
  def self.green(text); end
  def self.indent(text, chars); end
  def self.magenta(text); end
  def self.no_color(&block); end
  def self.no_pager(&block); end
  def self.purple(text); end
  def self.red(text); end
  def self.strip_color(text); end
  def self.white(text); end
  def self.with_line_numbers(text, offset, color = nil); end
  def self.yellow(text); end
end
class Pry::Helpers::Table
  def ==(other); end
  def _max_width(things); end
  def _rebuild_colorless_cache; end
  def _recall_color_for(thing); end
  def _recolumn; end
  def column_count; end
  def column_count=(n); end
  def columns; end
  def fits_on_line?(line_length); end
  def initialize(items, args = nil); end
  def items; end
  def items=(items); end
  def rows_to_s(style = nil); end
  def to_a; end
  def to_s; end
end
class Pry::CodeObject
  def command_lookup; end
  def default_lookup; end
  def empty_lookup; end
  def initialize(str, _pry_, options = nil); end
  def looks_like_an_instance_method?(str); end
  def lookup_super(obj, super_level); end
  def method_or_class_lookup; end
  def pry; end
  def pry=(arg0); end
  def safe_to_evaluate?(str); end
  def self.lookup(str, _pry_, options = nil); end
  def sourcable_object?(obj); end
  def str; end
  def str=(arg0); end
  def super_level; end
  def super_level=(arg0); end
  def target; end
  def target=(arg0); end
  def target_self; end
  include Pry::Helpers::CommandHelpers
end
module Pry::CodeObject::Helpers
  def c_method?; end
  def command?; end
  def module_with_yard_docs?; end
  def real_method_object?; end
end
module Pry::Helpers::DocumentationHelpers
  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 self.get_comment_content(comment); end
  def self.process_comment_markup(comment); end
  def self.process_rdoc(comment); end
  def self.process_yardoc(comment); end
  def self.process_yardoc_tag(comment, tag); end
  def self.strip_comments_from_c_code(code); end
  def self.strip_leading_whitespace(text); end
  def strip_comments_from_c_code(code); end
  def strip_leading_whitespace(text); end
end
class Pry::Method
  def ==(obj); end
  def alias?; end
  def aliases; end
  def bound_method?; end
  def doc; end
  def doc_for_pry_method; end
  def dynamically_defined?; end
  def initialize(method, known_info = nil); end
  def is_a?(klass); end
  def kind_of?(klass); end
  def method_missing(method_name, *args, &block); end
  def method_name_from_first_line(first_ln); end
  def name; end
  def name_with_owner; end
  def original_name; end
  def pry_doc_info; end
  def pry_method?; end
  def respond_to?(method_name); end
  def self.all_from_class(klass, include_super = nil); end
  def self.all_from_common(obj, method_type, include_super = nil); end
  def self.all_from_obj(obj, include_super = nil); end
  def self.from_binding(b); end
  def self.from_class(klass, name, target = nil); end
  def self.from_module(klass, name, target = nil); end
  def self.from_obj(obj, name, target = nil); end
  def self.from_str(name, target = nil, options = nil); end
  def self.instance_method_definition?(name, definition_line); end
  def self.instance_resolution_order(klass); end
  def self.lookup_method_via_binding(obj, method_name, method_type, target = nil); end
  def self.method_definition?(name, definition_line); end
  def self.resolution_order(obj); end
  def self.singleton_class(obj); end
  def self.singleton_class_resolution_order(klass); end
  def self.singleton_method_definition?(name, definition_line); end
  def signature; end
  def singleton_method?; end
  def source; end
  def source?; end
  def source_file; end
  def source_line; end
  def source_location; end
  def source_range; end
  def source_type; end
  def super(times = nil); end
  def super_using_ancestors(ancestors, times = nil); end
  def unbound_method?; end
  def undefined?; end
  def visibility; end
  def wrapped; end
  def wrapped_owner; end
  extend Pry::Helpers::BaseHelpers
  include Pry::CodeObject::Helpers
  include Pry::Helpers::BaseHelpers
  include Pry::Helpers::DocumentationHelpers
end
class Pry::Method::WeirdMethodLocator
  def all_methods_for(obj); end
  def expanded_source_location(sl); end
  def find_method_in_superclass; end
  def find_renamed_method; end
  def get_method; end
  def index_to_line_number(index); end
  def initialize(method, target); end
  def lines_for_file(file); end
  def lost_method?; end
  def method; end
  def method=(arg0); end
  def normal_method?(method); end
  def pry_file?; end
  def renamed_method_source_location; end
  def self.normal_method?(method, b); end
  def self.weird_method?(method, b); end
  def target; end
  def target=(arg0); end
  def target_file; end
  def target_line; end
  def target_self; end
  def valid_file?(file); end
end
class Pry::Method::Disowned < Pry::Method
  def initialize(receiver, method_name, binding = nil); end
  def method_missing(meth_name, *args, &block); end
  def name; end
  def owner; end
  def receiver; end
  def source?; end
  def undefined?; end
end
class Pry::WrappedModule
  def all_from_common(mod, method_type); end
  def all_methods_for(mod); end
  def all_relevant_methods_for(mod); end
  def all_source_locations_by_popularity; end
  def candidate(rank); end
  def candidates; end
  def class?; end
  def constants(inherit = nil); end
  def doc; end
  def file; end
  def generator; end
  def initialize(mod); end
  def line; end
  def lines_for_file(file); end
  def method_candidates; end
  def method_defined_by_forwardable_module?(method); 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 primary_candidate; end
  def respond_to?(method_name); end
  def self.from_str(mod_name, target = nil); end
  def self.safe_to_evaluate?(str, target); 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 = nil); end
  def wrapped; end
  def yard_doc; end
  def yard_docs?; end
  def yard_file; end
  def yard_line; end
  include Pry::CodeObject::Helpers
  include Pry::Helpers::BaseHelpers
end
class Pry::WrappedModule::Candidate
  def adjusted_source_location(sl); end
  def class?(*args, &block); end
  def class_regexes; end
  def doc; end
  def file; end
  def first_line_of_module_definition(file, line); end
  def first_method_source_location; end
  def initialize(wrapper, rank); end
  def last_method_source_location; end
  def line; end
  def lines_for_file(*args, &block); end
  def method_candidates(*args, &block); end
  def module?(*args, &block); end
  def name(*args, &block); end
  def nonblank_name(*args, &block); end
  def number_of_candidates(*args, &block); end
  def number_of_lines_in_first_chunk; end
  def source; end
  def source_file; end
  def source_line; end
  def source_location; end
  def wrapped(*args, &block); end
  def yard_docs?(*args, &block); end
  extend Forwardable
  include Pry::CodeObject::Helpers
  include Pry::Helpers::DocumentationHelpers
end
class Pry::History
  def <<(line); end
  def clear; end
  def clear_readline; end
  def clearer; end
  def clearer=(arg0); end
  def history_line_count; end
  def initialize; end
  def load; end
  def loader; end
  def loader=(arg0); end
  def original_lines; end
  def push(line); end
  def push_to_readline(line); end
  def pusher; end
  def pusher=(arg0); end
  def read_from_file; end
  def restore_default_behavior; end
  def save; end
  def saver; end
  def saver=(arg0); end
  def session_line_count; end
  def to_a; end
  def write_to_file(lines); end
end
class Pry::Command
  def _pry_; end
  def _pry_=(arg0); end
  def arg_string; end
  def arg_string=(arg0); end
  def block; end
  def call_safely(*args); end
  def call_with_hooks(*args); 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 correct_arg_arity(arity, args); end
  def dependencies_met?; end
  def description; end
  def eval_string; end
  def eval_string=(arg0); end
  def initialize(context = nil); end
  def interpolate_string(str); end
  def match; end
  def name; end
  def output; end
  def output=(arg0); end
  def pass_block(arg_string); end
  def process_line(line); end
  def run(command_string, *args); end
  def self.banner(arg = nil); end
  def self.block; end
  def self.block=(arg0); end
  def self.command_name; end
  def self.command_options(arg = nil); end
  def self.command_options=(arg0); end
  def self.command_regex; end
  def self.convert_to_regex(obj); end
  def self.default_options(match); end
  def self.description(arg = nil); end
  def self.description=(arg0); end
  def self.doc; end
  def self.file; end
  def self.group(name = nil); end
  def self.hooks; end
  def self.inspect; end
  def self.line; end
  def self.match(arg = nil); end
  def self.match=(arg0); end
  def self.match_score(val); end
  def self.matches?(val); end
  def self.name; end
  def self.options(arg = nil); end
  def self.options=(arg0); end
  def self.source; end
  def self.source_file; end
  def self.source_line; end
  def self.source_location; end
  def self.subclass(match, description, options, helpers, &block); end
  def source; end
  def source_location; end
  def state; end
  def target; end
  def target=(arg0); end
  def target_self; end
  def text; end
  def tokenize(val); end
  def void; end
  extend Pry::CodeObject::Helpers
  extend Pry::Helpers::DocumentationHelpers
  include Pry::Helpers::BaseHelpers
  include Pry::Helpers::CommandHelpers
end
class Pry::BlockCommand < Pry::Command
  def call(*args); end
  def help; end
  def opts; end
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 self.doc; end
  def self.file; end
  def self.inherited(klass); end
  def self.line; end
  def self.source; end
  def self.source_file; end
  def self.source_line; end
  def self.source_location; end
  def self.source_object; end
  def setup; end
  def slop; end
  def subcommands(cmd); end
end
class Pry::NoCommandError < StandardError
  def initialize(match, owner); end
end
class Pry::CommandSet
  def [](val); end
  def add_command(command); end
  def after_command(search, &block); end
  def alias_command(match, action, options = nil); end
  def before_command(search, &block); end
  def block_command(match, description = nil, options = nil, &block); end
  def command(match, description = nil, options = nil, &block); end
  def commands; end
  def complete(search, context = nil); end
  def create_command(match, description = nil, options = nil, &block); end
  def delete(*searches); end
  def desc(search, description = nil); end
  def disabled_command(name_of_disabled_command, message, matcher = nil); end
  def each(&block); end
  def find_command(val); end
  def find_command_by_match_or_listing(match_or_listing); end
  def find_command_for_help(search); end
  def helper_module; end
  def helpers(&block); end
  def import(*sets); end
  def import_from(set, *matches); end
  def initialize(*imported_sets, &block); end
  def list_commands; end
  def process_line(val, context = nil); end
  def rename_command(new_match, search, options = nil); end
  def run_command(context, match, *args); end
  def valid_command?(val); end
  include Enumerable
  include Pry::Helpers::BaseHelpers
end
class Pry::Result
  def command?; end
  def initialize(is_command, retval = nil); end
  def retval; end
  def void_command?; end
end
class Pry::Command::Bang < Pry::ClassCommand
  def process; end
end
class Pry::Command::Whereami < Pry::ClassCommand
  def bad_option_combination?; end
  def class_code; end
  def code; end
  def code?; end
  def code_window; end
  def default_code; end
  def expand_path(f); end
  def handle_internal_binding; end
  def location; end
  def marker; end
  def method_code; end
  def nothing_to_do?; end
  def options(opt); end
  def process; end
  def self.method_size_cutoff; end
  def self.method_size_cutoff=(arg0); end
  def setup; end
  def small_method?; end
  def top_level?; end
  def use_line_numbers?; end
  def valid_method?; end
  def window_size; end
end
class Pry::Command::Cd < Pry::ClassCommand
  def process; end
end
class Pry::Command::ShowInput < Pry::ClassCommand
  def process; end
end
class Pry::Command::GemOpen < Pry::ClassCommand
  def complete(str); end
  def process(gem); end
end
class Pry::Command::ShellMode < 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::Exit < Pry::ClassCommand
  def process; end
  def process_pop_and_return; end
end
class Pry::Command::InstallCommand < Pry::ClassCommand
  def process(name); end
end
class Pry::Command::ExitAll < Pry::ClassCommand
  def process; end
end
class Pry::Command::Gist < Pry::ClassCommand
  def clipboard_content(content); end
  def comment_expression_result_for_gist(result); end
  def gist_content(content, filename); end
  def input_content; end
  def options(opt); end
  def process; end
  def setup; end
end
class Pry::Command::Stat < Pry::ClassCommand
  def options(opt); end
  def process; end
end
class Pry::Command::Version < Pry::ClassCommand
  def process; end
end
class Pry::Command::RaiseUp < Pry::ClassCommand
  def process; end
end
class Pry::Command::Ri < Pry::ClassCommand
  def process(spec); end
end
class Pry::Command::Edit < Pry::ClassCommand
  def apply_runtime_patch; end
  def bad_option_combination?; end
  def code_object; end
  def complete(search); 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 probably_a_file?(str); end
  def process; end
  def pry_method?(code_object); end
  def reload?(file_name = nil); end
  def reloadable?; end
  def repl_edit; end
  def repl_edit?; end
  def repl_reload?; end
  def runtime_patch?; end
end
class Pry::Command::Edit::MethodPatcher
  def _pry_; end
  def _pry_=(arg0); end
  def adjusted_lines; end
  def code_object; end
  def code_object=(arg0); end
  def definition_line_for_owner(line); end
  def initialize(_pry_, code_object); end
  def patched_code; end
  def perform_patch; end
  def with_method_transaction; end
  def wrap(source); end
  def wrap_for_nesting(source); end
  def wrap_for_owner(source); end
end
class Pry::Command::Edit::ExceptionPatcher
  def _pry_; end
  def _pry_=(arg0); end
  def file_and_line; end
  def file_and_line=(arg0); end
  def initialize(_pry_, state, exception_file_and_line); end
  def perform_patch; end
  def state; end
  def state=(arg0); end
end
module Pry::Command::Edit::FileAndLineLocator
  def self.from_binding(target); end
  def self.from_code_object(code_object, filename_argument); end
  def self.from_exception(exception, backtrace_level); end
  def self.from_filename_argument(filename_argument); end
end
class Pry::Command::SimplePrompt < Pry::ClassCommand
  def process; end
end
class Pry::Command::CodeCollector
  def _pry_; end
  def _pry_=(arg0); end
  def args; end
  def args=(arg0); end
  def bad_option_combination?; end
  def code_object; end
  def code_object_doc; end
  def code_object_source_or_file; end
  def content; end
  def convert_to_range(n); end
  def could_not_locate(name); end
  def file; end
  def file=(arg0); end
  def file_content; end
  def initialize(args, opts, _pry_); end
  def line_range; end
  def obj_name; end
  def opts; end
  def opts=(arg0); end
  def pry_array_content_as_string(array, ranges, &block); end
  def pry_input_content; end
  def pry_output_content; end
  def restrict_to_lines(content, range); end
  def self.inject_options(opt); end
  def self.input_expression_ranges; end
  def self.input_expression_ranges=(arg0); end
  def self.output_result_ranges; end
  def self.output_result_ranges=(arg0); end
  include Pry::Helpers::CommandHelpers
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::Play < Pry::ClassCommand
  def content; 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
end
class Pry::Command::ToggleColor < Pry::ClassCommand
  def process; end
end
class Pry::Command::FindMethod < Pry::ClassCommand
  def additional_info(header, method); end
  def content_search(namespace); end
  def matched_method_lines(header, method); end
  def name_search(namespace); end
  def options(opti); end
  def pattern; end
  def print_matches(matches); end
  def print_matches_for_class(klass, grouped); end
  def process; end
  def recurse_namespace(klass, done = nil, &block); end
  def search_all_methods(namespace); end
  def search_class; end
  def setup; end
  def show_search_results(matches); end
  extend Pry::Helpers::BaseHelpers
end
class Pry::Command::ShowInfo < Pry::ClassCommand
  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 setup; 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
  extend Pry::Helpers::BaseHelpers
end
class Pry::Command::ShowSource < Pry::Command::ShowInfo
  def content_for(code_object); end
end
class Pry::Command::Ls < Pry::ClassCommand
  def all_methods(obj, instance_methods = nil); end
  def below_ceiling(obj); end
  def color(type, str); end
  def colorized_assignment_style(lhs, rhs, desired_width = nil); end
  def format_constants(mod, constants); end
  def format_globals(globals); end
  def format_local_names(locals); end
  def format_locals(name_value_pairs); end
  def format_methods(methods); end
  def format_value(value); end
  def format_variables(type, vars); end
  def grep; end
  def grep_regex; end
  def has_user_specified_any_options; end
  def interrogating_a_module?; end
  def object_to_interrogate; end
  def options(opt); end
  def output_section(heading, body); end
  def process; end
  def raise_errors_if_arguments_are_weird; end
  def resolution_order(obj); end
  def rubbishness(name); end
  def trim_jruby_aliases(methods); end
  def write_out_constants; end
  def write_out_globals; end
  def write_out_ivars; end
  def write_out_local_names; end
  def write_out_locals; end
  def write_out_methods; end
  def write_out_self_methods; end
end
class Pry::Command::Cat < Pry::ClassCommand
  def complete(search); end
  def options(opt); end
  def process; end
end
class Pry::Command::Cat::AbstractFormatter
  def between_lines; end
  def code_type; end
  def decorate(content); end
  def use_line_numbers?; end
  include Pry::Helpers::BaseHelpers
  include Pry::Helpers::CommandHelpers
end
class Pry::Command::Cat::InputExpressionFormatter < Pry::Command::Cat::AbstractFormatter
  def format; end
  def initialize(input_expressions, opts); end
  def input_expressions; end
  def input_expressions=(arg0); end
  def normalized_expression_range; end
  def numbered_input_items; end
  def opts; end
  def opts=(arg0); end
  def selected_input_items; end
end
class Pry::Command::Cat::ExceptionFormatter < Pry::Command::Cat::AbstractFormatter
  def _pry_; end
  def _pry_=(arg0); end
  def backtrace_file; end
  def backtrace_level; end
  def backtrace_line; end
  def check_for_errors; end
  def code_window_size; end
  def ex; end
  def ex=(arg0); end
  def format; end
  def header; end
  def increment_backtrace_level; end
  def initialize(exception, _pry_, opts); end
  def opts; end
  def opts=(arg0); end
  def start_and_end_line_for_code_window; end
end
class Pry::Command::Cat::FileFormatter < Pry::Command::Cat::AbstractFormatter
  def _pry_; end
  def _pry_=(arg0); end
  def code_type; end
  def code_window_size; end
  def decorate(content); end
  def detect_code_type_from_file(file_name); end
  def file_and_line; end
  def file_name; end
  def file_with_embedded_line; end
  def file_with_embedded_line=(arg0); end
  def format; end
  def initialize(file_with_embedded_line, _pry_, opts); end
  def line_number; end
  def opts; end
  def opts=(arg0); end
end
class Pry::Command::GemList < Pry::ClassCommand
  def process(pattern = nil); end
end
class Pry::Command::ExitProgram < Pry::ClassCommand
  def process; end
end
class Pry::Command::ShowDoc < Pry::Command::ShowInfo
  def content_for(code_object); end
  def docs_for(code_object); end
  def header_options; end
  def render_doc_markup_for(code_object); end
  def start_line_for(code_object); end
  include Pry::Helpers::DocumentationHelpers
end
class Pry::Command::Reset < Pry::ClassCommand
  def process; end
end
class Pry::Command::DisablePry < Pry::ClassCommand
  def process; end
end
class Pry::Command::ImportSet < Pry::ClassCommand
  def process(command_set_name); end
end
class Pry::Command::FixIndent < Pry::ClassCommand
  def process; end
end
class Pry::Command::Wtf < Pry::ClassCommand
  def backtrace; end
  def exception; end
  def options(opt); end
  def process; end
  def size_of_backtrace; end
  def with_line_numbers(bt); end
end
class Pry::Command::AmendLine < Pry::ClassCommand
  def amended_input(string); end
  def delete_from_array(array, range); end
  def insert_into_array(array, range); end
  def line_count; end
  def line_range; end
  def process; 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::BangPry < Pry::ClassCommand
  def process; end
end
class Pry::Command::ReloadCode < Pry::ClassCommand
  def check_for_reloadability(code_object); end
  def current_file; end
  def obj_name; end
  def process; end
  def reload_code_object(code_object); end
  def reload_current_file; end
end
class Pry::Command::Nesting < Pry::ClassCommand
  def process; end
end
class Pry::Command::ShellCommand < Pry::ClassCommand
  def complete(search); end
  def process(cmd); end
end
class Pry::Command::GemCd < Pry::ClassCommand
  def complete(str); end
  def process(gem); end
end
class Pry::Command::JumpTo < Pry::ClassCommand
  def process(break_level); end
end
class Pry::Command::SwitchTo < Pry::ClassCommand
  def process(selection); end
end
class Pry::Command::GemInstall < Pry::ClassCommand
  def process(gem); end
  def setup; end
end
class Pry::Command::Hist < Pry::ClassCommand
  def check_for_juxtaposed_replay(replay_sequence); end
  def options(opt); end
  def process; end
  def process_clear; end
  def process_display; end
  def process_replay; end
  def process_save; end
end
class Pry::Command::PryBacktrace < Pry::ClassCommand
  def process; end
end
module Pry::BondCompleter
  def self.build_completion_proc(target, pry = nil, commands = nil); end
  def self.start; end
end
module Pry::InputCompleter
  def self.build_completion_proc(target, pry = nil, commands = nil); end
  def self.build_path(input); end
  def self.initialize_readline; end
  def self.select_message(path, receiver, message, candidates); end
end
class Pry::PluginManager
  def gem_located?(gem_name); end
  def initialize; end
  def load_plugins; end
  def locate_plugins; end
  def plugins; end
end
class Pry::PluginManager::NoPlugin
  def initialize(name); end
  def method_missing(*args); end
end
class Pry::PluginManager::Plugin
  def activate!; end
  def active; end
  def active=(arg0); end
  def active?; end
  def disable!; end
  def enable!; end
  def enabled; end
  def enabled=(arg0); end
  def enabled?; end
  def gem_name; end
  def gem_name=(arg0); end
  def initialize(name, gem_name, spec, enabled); end
  def load_cli_options; end
  def name; end
  def name=(arg0); end
  def spec; end
  def spec=(arg0); end
end
class Object < BasicObject
  def __binding__; end
  def pry(object = nil, hash = nil); end
end
class Pry::Config < OpenStruct
  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_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=(arg0); 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 extra_sticky_locals; end
  def extra_sticky_locals=(arg0); end
  def gist; end
  def gist=(arg0); end
  def history; end
  def history=(arg0); end
  def hooks; end
  def hooks=(v); end
  def input; end
  def input=(input); end
  def input_stack; end
  def input_stack=(arg0); end
  def memory_size; end
  def memory_size=(arg0); end
  def output; end
  def output=(arg0); end
  def pager; end
  def pager=(arg0); end
  def plugins; end
  def plugins=(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 requires; end
  def requires=(arg0); end
  def should_load_local_rc; end
  def should_load_local_rc=(arg0); end
  def should_load_plugins; end
  def should_load_plugins=(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
end
class Pry::Indent
  def correct_indentation(prompt, code, overhang = 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 initialize; end
  def module_nesting; end
  def open_delimiters; end
  def open_delimiters_line; end
  def reset; end
  def self.indent(str); end
  def self.nesting_at(str, line_number); 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 = nil); end
  include Pry::Helpers::BaseHelpers
end
class Pry::Indent::UnparseableNestingError < StandardError
end
class Pry::CLI
  def self.add_options(&block); end
  def self.add_plugin_options; end
  def self.input_args; end
  def self.input_args=(arg0); end
  def self.option_processors; end
  def self.option_processors=(arg0); end
  def self.options; end
  def self.options=(arg0); end
  def self.parse_options(args = nil); end
  def self.process_options(&block); end
  def self.reset; end
end
class Pry::CLI::NoOptionsError < StandardError
end
class Slop::Option
  def argument?; end
  def as?; end
  def autocreated?; end
  def callback?; end
  def default?; end
  def delimiter?; end
  def limit?; end
  def match?; end
  def optional?; end
  def optional_argument?; end
  def required?; end
  def tail?; end
end
class Pry::Pager
  def initialize(text); end
  def self.page(text, pager = nil); end
  def self.page_size; end
end
class Pry::Pager::SimplePager < Pry::Pager
  def page; end
end
class Pry::Pager::SystemPager < Pry::Pager
  def initialize(*arg0); end
  def page; end
  def self.available?; end
  def self.default_pager; end
end
class Pry::Terminal
  def self.actual_screen_size; end
  def self.height!; end
  def self.nonzero_column?(size); end
  def self.screen_size; end
  def self.screen_size_according_to_ansicon_env; end
  def self.screen_size_according_to_env; end
  def self.screen_size_according_to_io_console; end
  def self.screen_size_according_to_readline; end
  def self.size!(default = nil); end
  def self.width!; end
end
class Pry::Editor
  def self.blocking_flag_for_editor(blocking); end
  def self.build_editor_invocation_string(file, line, blocking); end
  def self.edit_tempfile_with_content(initial_content, line = nil); end
  def self.editor_name; end
  def self.invoke_editor(file, line, blocking = nil); end
  def self.open_editor(editor_invocation); end
  def self.open_editor_on_jruby(editor_invocation); end
  def self.start_line_syntax_for_editor(file_name, line_number); end
  extend Pry::Helpers::BaseHelpers
  extend Pry::Helpers::CommandHelpers
end
module Pry::Rubygem
  def self.complete(so_far); end
  def self.install(name); end
  def self.installed?(name); end
  def self.list(pattern = nil); end
  def self.spec(name); end
end
module Pry::RescuableException
  def self.===(exception); end
end
module Pry::UserError
end
module Pry::TooSafeException
  def self.===(exception); end
end
class Pry::CommandError < StandardError
end
class Pry::MethodNotFound < Pry::CommandError
end
class Pry::ObsoleteError < StandardError
end
module Pry::ExtendCommandBundle
end