ruby-lsp 0.0.3 → 0.0.4

data/sorbet/rbi/gems/thor@1.2.1.rbi

@@ -0,0 +1,2921 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `thor` gem.
+# Please instead update this file by running `bin/tapioca gem thor`.
+
+class Thor
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  class << self
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options = T.unsafe(nil)); end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    #
+    # @return [Boolean]
+    def check_unknown_options?(config); end
+
+    # Prints help information for the given command.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # command_name<String>
+    def command_help(shell, command_name); end
+
+    # Sets the default command when thor is executed without an explicit command to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the default command
+    def default_command(meth = T.unsafe(nil)); end
+
+    # Sets the default command when thor is executed without an explicit command to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the default command
+    def default_task(meth = T.unsafe(nil)); end
+
+    def deprecation_warning(message); end
+
+    # Defines the usage and the description of the next command.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    def desc(usage, description, options = T.unsafe(nil)); end
+
+    # Disable the check for required options for the given commands.
+    # This is useful if you have a command that does not need the required options
+    # to work, like help.
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of commands that should be affected.
+    def disable_required_check!(*command_names); end
+
+    # @return [Boolean]
+    def disable_required_check?(command); end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    def help(shell, subcommand = T.unsafe(nil)); end
+
+    # Defines the long description of the next command.
+    #
+    # ==== Parameters
+    # long description<String>
+    def long_desc(long_description, options = T.unsafe(nil)); end
+
+    # Maps an input to a command. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list command.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given command.
+    def map(mappings = T.unsafe(nil), **kw); end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined command.
+    #
+    #   def previous_command
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_command
+    #
+    #   def next_command
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    def method_option(name, options = T.unsafe(nil)); end
+
+    # Declares the options for the next command to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    def method_options(options = T.unsafe(nil)); end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined command.
+    #
+    #   def previous_command
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_command
+    #
+    #   def next_command
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    def option(name, options = T.unsafe(nil)); end
+
+    # Declares the options for the next command to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    def options(options = T.unsafe(nil)); end
+
+    # Allows for custom "Command" package naming.
+    #
+    # === Parameters
+    # name<String>
+    # options<Hash>
+    def package_name(name, _ = T.unsafe(nil)); end
+
+    # Returns commands ready to be printed.
+    def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+    # Returns commands ready to be printed.
+    def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
+
+    # Stop parsing of options as soon as an unknown option or a regular
+    # argument is encountered.  All remaining arguments are passed to the command.
+    # This is useful if you have a command that can receive arbitrary additional
+    # options, and where those additional options should not be handled by
+    # Thor.
+    #
+    # ==== Example
+    #
+    # To better understand how this is useful, let's consider a command that calls
+    # an external command.  A user may want to pass arbitrary options and
+    # arguments to that command.  The command itself also accepts some options,
+    # which should be handled by Thor.
+    #
+    #   class_option "verbose",  :type => :boolean
+    #   stop_on_unknown_option! :exec
+    #   check_unknown_options!  :except => :exec
+    #
+    #   desc "exec", "Run a shell command"
+    #   def exec(*args)
+    #     puts "diagnostic output" if options[:verbose]
+    #     Kernel.exec(*args)
+    #   end
+    #
+    # Here +exec+ can be called with +--verbose+ to get diagnostic output,
+    # e.g.:
+    #
+    #   $ thor exec --verbose echo foo
+    #   diagnostic output
+    #   foo
+    #
+    # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead:
+    #
+    #   $ thor exec echo --verbose foo
+    #   --verbose foo
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of commands that should be affected.
+    def stop_on_unknown_option!(*command_names); end
+
+    # @return [Boolean]
+    def stop_on_unknown_option?(command); end
+
+    def subcommand(subcommand, subcommand_class); end
+    def subcommand_classes; end
+    def subcommands; end
+    def subtask(subcommand, subcommand_class); end
+    def subtasks; end
+
+    # Prints help information for the given command.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # command_name<String>
+    def task_help(shell, command_name); end
+
+    protected
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Thor::Runner. It receives
+    # the command that is going to be invoked and a boolean which indicates if
+    # the namespace should be displayed as arguments.
+    def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+
+    # help command has the required check disabled by default.
+    def disable_required_check; end
+
+    # The method responsible for dispatching given the args.
+    #
+    # @yield [instance]
+    def dispatch(meth, given_args, given_opts, config); end
+
+    def dynamic_command_class; end
+
+    # this is the logic that takes the command name passed in by the user
+    # and determines whether it is an unambiguous substrings of a command or
+    # alias name.
+    def find_command_possibilities(meth); end
+
+    # this is the logic that takes the command name passed in by the user
+    # and determines whether it is an unambiguous substrings of a command or
+    # alias name.
+    def find_task_possibilities(meth); end
+
+    def initialize_added; end
+
+    # receives a (possibly nil) command name and returns a name that is in
+    # the commands hash. In addition to normalizing aliases, this logic
+    # will determine if a shortened command is an unambiguous substring of
+    # a command or alias.
+    #
+    # +normalize_command_name+ also converts names like +animal-prison+
+    # into +animal_prison+.
+    #
+    # @raise [AmbiguousTaskError]
+    def normalize_command_name(meth); end
+
+    # receives a (possibly nil) command name and returns a name that is in
+    # the commands hash. In addition to normalizing aliases, this logic
+    # will determine if a shortened command is an unambiguous substring of
+    # a command or alias.
+    #
+    # +normalize_command_name+ also converts names like +animal-prison+
+    # into +animal_prison+.
+    #
+    # @raise [AmbiguousTaskError]
+    def normalize_task_name(meth); end
+
+    # Retrieve the command name from given args.
+    def retrieve_command_name(args); end
+
+    # Retrieve the command name from given args.
+    def retrieve_task_name(args); end
+
+    def stop_on_unknown_option; end
+    def subcommand_help(cmd); end
+    def subtask_help(cmd); end
+  end
+end
+
+module Thor::Actions
+  mixes_in_class_methods ::Thor::Actions::ClassMethods
+
+  # Extends initializer to add more configuration options.
+  #
+  # ==== Configuration
+  # behavior<Symbol>:: The actions default behavior. Can be :invoke or :revoke.
+  #                    It also accepts :force, :skip and :pretend to set the behavior
+  #                    and the respective option.
+  #
+  # destination_root<String>:: The root directory needed for some actions.
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # Wraps an action object and call it accordingly to the thor class behavior.
+  def action(instance); end
+
+  # Create a new file relative to the destination root with the given data,
+  # which is the return value of a block or a data string.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # data<String|NilClass>:: the data to append to the file.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   create_file "lib/fun_party.rb" do
+  #     hostname = ask("What is the virtual hostname I should use?")
+  #     "vhost.name = #{hostname}"
+  #   end
+  #
+  #   create_file "config/apache.conf", "your apache config"
+  def add_file(destination, *args, &block); end
+
+  # Create a new file relative to the destination root from the given source.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # source<String|NilClass>:: the relative path to the source root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #   :: give :symbolic => false for hard link.
+  #
+  # ==== Examples
+  #
+  #   create_link "config/apache.conf", "/etc/apache.conf"
+  def add_link(destination, *args); end
+
+  # Append text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to append to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   append_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  def append_file(path, *args, &block); end
+
+  # Append text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to append to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   append_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  def append_to_file(path, *args, &block); end
+
+  # Loads an external file and execute it in the instance binding.
+  #
+  # ==== Parameters
+  # path<String>:: The path to the file to execute. Can be a web address or
+  #                a relative path from the source root.
+  #
+  # ==== Examples
+  #
+  #   apply "http://gist.github.com/103208"
+  #
+  #   apply "recipes/jquery.rb"
+  def apply(path, config = T.unsafe(nil)); end
+
+  # Returns the value of attribute behavior.
+  def behavior; end
+
+  # Sets the attribute behavior
+  #
+  # @param value the value to set the attribute behavior to.
+  def behavior=(_arg0); end
+
+  # Changes the mode of the given file or directory.
+  #
+  # ==== Parameters
+  # mode<Integer>:: the file mode
+  # path<String>:: the name of the file to change mode
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   chmod "script/server", 0755
+  def chmod(path, mode, config = T.unsafe(nil)); end
+
+  # Comment all lines matching a given regex.  It will leave the space
+  # which existed before the beginning of the line in tact and will insert
+  # a single space after the comment hash.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # flag<Regexp|String>:: the regexp or string used to decide which lines to comment
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   comment_lines 'config/initializers/session_store.rb', /cookie_store/
+  def comment_lines(path, flag, *args); end
+
+  # ==== Examples
+  #
+  #   copy_file "README", "doc/README"
+  #
+  #   copy_file "doc/README"
+  def copy_file(source, *args, &block); end
+
+  # Create a new file relative to the destination root with the given data,
+  # which is the return value of a block or a data string.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # data<String|NilClass>:: the data to append to the file.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   create_file "lib/fun_party.rb" do
+  #     hostname = ask("What is the virtual hostname I should use?")
+  #     "vhost.name = #{hostname}"
+  #   end
+  #
+  #   create_file "config/apache.conf", "your apache config"
+  def create_file(destination, *args, &block); end
+
+  # Create a new file relative to the destination root from the given source.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # source<String|NilClass>:: the relative path to the source root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #   :: give :symbolic => false for hard link.
+  #
+  # ==== Examples
+  #
+  #   create_link "config/apache.conf", "/etc/apache.conf"
+  def create_link(destination, *args); end
+
+  # Returns the root for this thor class (also aliased as destination root).
+  def destination_root; end
+
+  # Sets the root for this thor class. Relatives path are added to the
+  # directory where the script was invoked and expanded.
+  def destination_root=(root); end
+
+  # Copies recursively the files from source directory to root directory.
+  # If any of the files finishes with .tt, it's considered to be a template
+  # and is placed in the destination without the extension .tt. If any
+  # empty directory is found, it's copied and all .empty_directory files are
+  # ignored. If any file name is wrapped within % signs, the text within
+  # the % signs will be executed as a method and replaced with the returned
+  # value. Let's suppose a doc directory with the following files:
+  #
+  #   doc/
+  #     components/.empty_directory
+  #     README
+  #     rdoc.rb.tt
+  #     %app_name%.rb
+  #
+  # When invoked as:
+  #
+  #   directory "doc"
+  #
+  # It will create a doc directory in the destination with the following
+  # files (assuming that the `app_name` method returns the value "blog"):
+  #
+  #   doc/
+  #     components/
+  #     README
+  #     rdoc.rb
+  #     blog.rb
+  #
+  # <b>Encoded path note:</b> Since Thor internals use Object#respond_to? to check if it can
+  # expand %something%, this `something` should be a public method in the class calling
+  # #directory. If a method is private, Thor stack raises PrivateMethodEncodedError.
+  #
+  # ==== Parameters
+  # source<String>:: the relative path to the source root.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #                If :recursive => false, does not look for paths recursively.
+  #                If :mode => :preserve, preserve the file mode from the source.
+  #                If :exclude_pattern => /regexp/, prevents copying files that match that regexp.
+  #
+  # ==== Examples
+  #
+  #   directory "doc"
+  #   directory "doc", "docs", :recursive => false
+  def directory(source, *args, &block); end
+
+  # Creates an empty directory.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   empty_directory "doc"
+  def empty_directory(destination, config = T.unsafe(nil)); end
+
+  # Receives a file or directory and search for it in the source paths.
+  #
+  # @raise [Error]
+  def find_in_source_paths(file); end
+
+  # Gets the content at the given address and places it at the given relative
+  # destination. If a block is given instead of destination, the content of
+  # the url is yielded and used as location.
+  #
+  # +get+ relies on open-uri, so passing application user input would provide
+  # a command injection attack vector.
+  #
+  # ==== Parameters
+  # source<String>:: the address of the given content.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   get "http://gist.github.com/103208", "doc/README"
+  #
+  #   get "http://gist.github.com/103208" do |content|
+  #     content.split("\n").first
+  #   end
+  def get(source, *args, &block); end
+
+  # Run a regular expression replacement on a file.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # flag<Regexp|String>:: the regexp or string to be replaced
+  # replacement<String>:: the replacement, can be also given as a block
+  # config<Hash>:: give :verbose => false to not log the status, and
+  #                :force => true, to force the replacement regardles of runner behavior.
+  #
+  # ==== Example
+  #
+  #   gsub_file 'app/controllers/application_controller.rb', /#\s*(filter_parameter_logging :password)/, '\1'
+  #
+  #   gsub_file 'README', /rake/, :green do |match|
+  #     match << " no more. Use thor!"
+  #   end
+  def gsub_file(path, flag, *args, &block); end
+
+  # Goes to the root and execute the given block.
+  def in_root; end
+
+  # Injects text right after the class definition. Since it depends on
+  # insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # klass<String|Class>:: the class to be manipulated
+  # data<String>:: the data to append to the class, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController", "  filter_parameter :password\n"
+  #
+  #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do
+  #     "  filter_parameter :password\n"
+  #   end
+  def inject_into_class(path, klass, *args, &block); end
+
+  def inject_into_file(destination, *args, &block); end
+
+  # Injects text right after the module definition. Since it depends on
+  # insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # module_name<String|Class>:: the module to be manipulated
+  # data<String>:: the data to append to the class, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper", "  def help; 'help'; end\n"
+  #
+  #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper" do
+  #     "  def help; 'help'; end\n"
+  #   end
+  def inject_into_module(path, module_name, *args, &block); end
+
+  def insert_into_file(destination, *args, &block); end
+
+  # Do something in the root or on a provided subfolder. If a relative path
+  # is given it's referenced from the current root. The full path is yielded
+  # to the block you provide. The path is set back to the previous path when
+  # the method exits.
+  #
+  # Returns the value yielded by the block.
+  #
+  # ==== Parameters
+  # dir<String>:: the directory to move to.
+  # config<Hash>:: give :verbose => true to log and use padding.
+  def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+  # Links the file from the relative source to the relative destination. If
+  # the destination is not given it's assumed to be equal to the source.
+  #
+  # ==== Parameters
+  # source<String>:: the relative path to the source root.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   link_file "README", "doc/README"
+  #
+  #   link_file "doc/README"
+  def link_file(source, *args); end
+
+  # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to prepend to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   prepend_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  def prepend_file(path, *args, &block); end
+
+  # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to prepend to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   prepend_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  def prepend_to_file(path, *args, &block); end
+
+  # Returns the given path relative to the absolute root (ie, root where
+  # the script started).
+  def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
+
+  # Removes a file at the given location.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   remove_file 'README'
+  #   remove_file 'app/controllers/application_controller.rb'
+  def remove_dir(path, config = T.unsafe(nil)); end
+
+  # Removes a file at the given location.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   remove_file 'README'
+  #   remove_file 'app/controllers/application_controller.rb'
+  def remove_file(path, config = T.unsafe(nil)); end
+
+  # Executes a command returning the contents of the command.
+  #
+  # ==== Parameters
+  # command<String>:: the command to be executed.
+  # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output. Specify :with
+  #                to append an executable to command execution.
+  #
+  # ==== Example
+  #
+  #   inside('vendor') do
+  #     run('ln -s ~/edge rails')
+  #   end
+  def run(command, config = T.unsafe(nil)); end
+
+  # Executes a ruby script (taking into account WIN32 platform quirks).
+  #
+  # ==== Parameters
+  # command<String>:: the command to be executed.
+  # config<Hash>:: give :verbose => false to not log the status.
+  def run_ruby_script(command, config = T.unsafe(nil)); end
+
+  # Holds source paths in instance so they can be manipulated.
+  def source_paths; end
+
+  # Gets an ERB template at the relative source, executes it and makes a copy
+  # at the relative destination. If the destination is not given it's assumed
+  # to be equal to the source removing .tt from the filename.
+  #
+  # ==== Parameters
+  # source<String>:: the relative path to the source root.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   template "README", "doc/README"
+  #
+  #   template "doc/README"
+  def template(source, *args, &block); end
+
+  # Run a thor command. A hash of options can be given and it's converted to
+  # switches.
+  #
+  # ==== Parameters
+  # command<String>:: the command to be invoked
+  # args<Array>:: arguments to the command
+  # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output.
+  #                Other options are given as parameter to Thor.
+  #
+  #
+  # ==== Examples
+  #
+  #   thor :install, "http://gist.github.com/103208"
+  #   #=> thor install http://gist.github.com/103208
+  #
+  #   thor :list, :all => true, :substring => 'rails'
+  #   #=> thor list --all --substring=rails
+  def thor(command, *args); end
+
+  # Uncomment all lines matching a given regex.  It will leave the space
+  # which existed before the comment hash in tact but will remove any spacing
+  # between the comment hash and the beginning of the line.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # flag<Regexp|String>:: the regexp or string used to decide which lines to uncomment
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   uncomment_lines 'config/initializers/session_store.rb', /active_record/
+  def uncomment_lines(path, flag, *args); end
+
+  protected
+
+  def _cleanup_options_and_set(options, key); end
+
+  # Allow current root to be shared between invocations.
+  def _shared_configuration; end
+
+  private
+
+  def capture(*args); end
+  def concat(string); end
+
+  # Returns the value of attribute output_buffer.
+  def output_buffer; end
+
+  # Sets the attribute output_buffer
+  #
+  # @param value the value to set the attribute output_buffer to.
+  def output_buffer=(_arg0); end
+
+  def with_output_buffer(buf = T.unsafe(nil)); end
+
+  class << self
+    def included(base); end
+  end
+end
+
+# Thor::Actions#capture depends on what kind of buffer is used in ERB.
+# Thus CapturableERB fixes ERB to use String buffer.
+class Thor::Actions::CapturableERB < ::ERB
+  def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
+end
+
+module Thor::Actions::ClassMethods
+  # Add runtime options that help actions execution.
+  def add_runtime_options!; end
+
+  # Hold source paths for one Thor instance. source_paths_for_search is the
+  # method responsible to gather source_paths from this current class,
+  # inherited paths and the source root.
+  def source_paths; end
+
+  # Returns the source paths in the following order:
+  #
+  #   1) This class source paths
+  #   2) Source root
+  #   3) Parents source paths
+  def source_paths_for_search; end
+
+  # Stores and return the source root for this class
+  def source_root(path = T.unsafe(nil)); end
+end
+
+# CreateFile is a subset of Template, which instead of rendering a file with
+# ERB, it gets the content from the user.
+class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
+  # @return [CreateFile] a new instance of CreateFile
+  def initialize(base, destination, data, config = T.unsafe(nil)); end
+
+  def data; end
+
+  # Checks if the content of the file at the destination is identical to the rendered result.
+  #
+  # ==== Returns
+  # Boolean:: true if it is identical, false otherwise.
+  #
+  # @return [Boolean]
+  def identical?; end
+
+  def invoke!; end
+
+  # Holds the content to be added to the file.
+  def render; end
+
+  protected
+
+  # Shows the file collision menu to the user and gets the result.
+  #
+  # @return [Boolean]
+  def force_on_collision?; end
+
+  # If force is true, run the action, otherwise check if it's not being
+  # skipped. If both are false, show the file_collision menu, if the menu
+  # returns true, force it, otherwise skip.
+  def force_or_skip_or_conflict(force, skip, &block); end
+
+  # Now on conflict we check if the file is identical or not.
+  def on_conflict_behavior(&block); end
+end
+
+# CreateLink is a subset of CreateFile, which instead of taking a block of
+# data, just takes a source string from the user.
+class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
+  def data; end
+
+  # @return [Boolean]
+  def exists?; end
+
+  # Checks if the content of the file at the destination is identical to the rendered result.
+  #
+  # ==== Returns
+  # Boolean:: true if it is identical, false otherwise.
+  #
+  # @return [Boolean]
+  def identical?; end
+
+  def invoke!; end
+end
+
+class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
+  # @return [Directory] a new instance of Directory
+  def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+  def invoke!; end
+  def revoke!; end
+
+  # Returns the value of attribute source.
+  def source; end
+
+  protected
+
+  def execute!; end
+  def file_level_lookup(previous_lookup); end
+  def files(lookup); end
+end
+
+class Thor::Actions::EmptyDirectory
+  # Initializes given the source and destination.
+  #
+  # ==== Parameters
+  # base<Thor::Base>:: A Thor::Base instance
+  # source<String>:: Relative path to the source of this file
+  # destination<String>:: Relative path to the destination of this file
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # @return [EmptyDirectory] a new instance of EmptyDirectory
+  def initialize(base, destination, config = T.unsafe(nil)); end
+
+  def base; end
+  def config; end
+  def destination; end
+
+  # Checks if the destination file already exists.
+  #
+  # ==== Returns
+  # Boolean:: true if the file exists, false otherwise.
+  #
+  # @return [Boolean]
+  def exists?; end
+
+  def given_destination; end
+  def invoke!; end
+  def relative_destination; end
+  def revoke!; end
+
+  protected
+
+  # Filenames in the encoded form are converted. If you have a file:
+  #
+  #   %file_name%.rb
+  #
+  # It calls #file_name from the base and replaces %-string with the
+  # return value (should be String) of #file_name:
+  #
+  #   user.rb
+  #
+  # The method referenced can be either public or private.
+  def convert_encoded_instructions(filename); end
+
+  # Sets the absolute destination value from a relative destination value.
+  # It also stores the given and relative destination. Let's suppose our
+  # script is being executed on "dest", it sets the destination root to
+  # "dest". The destination, given_destination and relative_destination
+  # are related in the following way:
+  #
+  #   inside "bar" do
+  #     empty_directory "baz"
+  #   end
+  #
+  #   destination          #=> dest/bar/baz
+  #   relative_destination #=> bar/baz
+  #   given_destination    #=> baz
+  def destination=(destination); end
+
+  # Receives a hash of options and just execute the block if some
+  # conditions are met.
+  def invoke_with_conflict_check(&block); end
+
+  # What to do when the destination file already exists.
+  def on_conflict_behavior; end
+
+  def on_file_clash_behavior; end
+
+  # Shortcut for pretend.
+  #
+  # @return [Boolean]
+  def pretend?; end
+
+  # Shortcut to say_status shell method.
+  def say_status(status, color); end
+end
+
+class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
+  # @return [InjectIntoFile] a new instance of InjectIntoFile
+  def initialize(base, destination, data, config); end
+
+  # Returns the value of attribute behavior.
+  def behavior; end
+
+  # Returns the value of attribute flag.
+  def flag; end
+
+  def invoke!; end
+
+  # Returns the value of attribute replacement.
+  def replacement; end
+
+  def revoke!; end
+
+  protected
+
+  # Adds the content to the file.
+  def replace!(regexp, string, force); end
+
+  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
+end
+
+# Injects the given content into a file. Different from gsub_file, this
+# method is reversible.
+#
+# ==== Parameters
+# destination<String>:: Relative path to the destination root
+# data<String>:: Data to add to the file. Can be given as a block.
+# config<Hash>:: give :verbose => false to not log the status and the flag
+#                for injection (:after or :before) or :force => true for
+#                insert two or more times the same content.
+#
+# ==== Examples
+#
+#   insert_into_file "config/environment.rb", "config.gem :thor", :after => "Rails::Initializer.run do |config|\n"
+#
+#   insert_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do
+#     gems = ask "Which gems would you like to add?"
+#     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
+#   end
+Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
+
+class Thor::AmbiguousCommandError < ::Thor::Error; end
+Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
+
+class Thor::Argument
+  # @raise [ArgumentError]
+  # @return [Argument] a new instance of Argument
+  def initialize(name, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute banner.
+  def banner; end
+
+  # Returns the value of attribute default.
+  def default; end
+
+  # Returns the value of attribute description.
+  def description; end
+
+  # Returns the value of attribute enum.
+  def enum; end
+
+  # Returns the value of attribute name.
+  def human_name; end
+
+  # Returns the value of attribute name.
+  def name; end
+
+  # Returns the value of attribute required.
+  def required; end
+
+  # @return [Boolean]
+  def required?; end
+
+  # @return [Boolean]
+  def show_default?; end
+
+  # Returns the value of attribute type.
+  def type; end
+
+  def usage; end
+
+  protected
+
+  def default_banner; end
+
+  # @return [Boolean]
+  def valid_type?(type); end
+
+  # @raise [ArgumentError]
+  def validate!; end
+end
+
+Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+class Thor::Arguments
+  # Takes an array of Thor::Argument objects.
+  #
+  # @return [Arguments] a new instance of Arguments
+  def initialize(arguments = T.unsafe(nil)); end
+
+  def parse(args); end
+  def remaining; end
+
+  private
+
+  # Raises an error if @non_assigned_required array is not empty.
+  #
+  # @raise [RequiredArgumentMissingError]
+  def check_requirement!; end
+
+  # @return [Boolean]
+  def current_is_value?; end
+
+  # @return [Boolean]
+  def last?; end
+
+  # @return [Boolean]
+  def no_or_skip?(arg); end
+
+  # Runs through the argument array getting all strings until no string is
+  # found or a switch is found.
+  #
+  #   ["a", "b", "c"]
+  #
+  # And returns it as an array:
+  #
+  #   ["a", "b", "c"]
+  def parse_array(name); end
+
+  # Runs through the argument array getting strings that contains ":" and
+  # mark it as a hash:
+  #
+  #   [ "name:string", "age:integer" ]
+  #
+  # Becomes:
+  #
+  #   { "name" => "string", "age" => "integer" }
+  def parse_hash(name); end
+
+  # Check if the peek is numeric format and return a Float or Integer.
+  # Check if the peek is included in enum if enum is provided.
+  # Otherwise raises an error.
+  def parse_numeric(name); end
+
+  # Parse string:
+  # for --string-arg, just return the current value in the pile
+  # for --no-string-arg, nil
+  # Check if the peek is included in enum if enum is provided. Otherwise raises an error.
+  def parse_string(name); end
+
+  def peek; end
+  def shift; end
+  def unshift(arg); end
+
+  class << self
+    def parse(*args); end
+
+    # Receives an array of args and returns two arrays, one with arguments
+    # and one with switches.
+    def split(args); end
+  end
+end
+
+Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
+
+module Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+
+  mixes_in_class_methods ::Thor::Base::ClassMethods
+  mixes_in_class_methods ::Thor::Invocation::ClassMethods
+
+  # It receives arguments in an Array and two hashes, one for options and
+  # other for configuration.
+  #
+  # Notice that it does not check if all required arguments were supplied.
+  # It should be done by the parser.
+  #
+  # ==== Parameters
+  # args<Array[Object]>:: An array of objects. The objects are applied to their
+  #                       respective accessors declared with <tt>argument</tt>.
+  #
+  # options<Hash>:: An options hash that will be available as self.options.
+  #                 The hash given is converted to a hash with indifferent
+  #                 access, magic predicates (options.skip?) and then frozen.
+  #
+  # config<Hash>:: Configuration for this Thor class.
+  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # Returns the value of attribute args.
+  def args; end
+
+  # Sets the attribute args
+  #
+  # @param value the value to set the attribute args to.
+  def args=(_arg0); end
+
+  # Returns the value of attribute options.
+  def options; end
+
+  # Sets the attribute options
+  #
+  # @param value the value to set the attribute options to.
+  def options=(_arg0); end
+
+  # Returns the value of attribute parent_options.
+  def parent_options; end
+
+  # Sets the attribute parent_options
+  #
+  # @param value the value to set the attribute parent_options to.
+  def parent_options=(_arg0); end
+
+  class << self
+    def included(base); end
+
+    # Whenever a class inherits from Thor or Thor::Group, we should track the
+    # class and the file on Thor::Base. This is the method responsible for it.
+    def register_klass_file(klass); end
+
+    # Returns the shell used in all Thor classes. If you are in a Unix platform
+    # it will use a colored log, otherwise it will use a basic one without color.
+    def shell; end
+
+    # Sets the attribute shell
+    #
+    # @param value the value to set the attribute shell to.
+    def shell=(_arg0); end
+
+    # Returns the files where the subclasses are kept.
+    #
+    # ==== Returns
+    # Hash[path<String> => Class]
+    def subclass_files; end
+
+    # Returns the classes that inherits from Thor or Thor::Group.
+    #
+    # ==== Returns
+    # Array[Class]
+    def subclasses; end
+  end
+end
+
+module Thor::Base::ClassMethods
+  # Returns the commands for this Thor class and all subclasses.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  def all_commands; end
+
+  # Returns the commands for this Thor class and all subclasses.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  def all_tasks; end
+
+  # If you want to use defaults that don't match the type of an option,
+  # either specify `check_default_type: false` or call `allow_incompatible_default_type!`
+  def allow_incompatible_default_type!; end
+
+  # Adds an argument to the class and creates an attr_accessor for it.
+  #
+  # Arguments are different from options in several aspects. The first one
+  # is how they are parsed from the command line, arguments are retrieved
+  # from position:
+  #
+  #   thor command NAME
+  #
+  # Instead of:
+  #
+  #   thor command --name=NAME
+  #
+  # Besides, arguments are used inside your code as an accessor (self.argument),
+  # while options are all kept in a hash (self.options).
+  #
+  # Finally, arguments cannot have type :default or :boolean but can be
+  # optional (supplying :optional => :true or :required => false), although
+  # you cannot have a required argument after a non-required argument. If you
+  # try it, an error is raised.
+  #
+  # ==== Parameters
+  # name<Symbol>:: The name of the argument.
+  # options<Hash>:: Described below.
+  #
+  # ==== Options
+  # :desc     - Description for the argument.
+  # :required - If the argument is required or not.
+  # :optional - If the argument is optional or not.
+  # :type     - The type of the argument, can be :string, :hash, :array, :numeric.
+  # :default  - Default value for this argument. It cannot be required and have default values.
+  # :banner   - String to show on usage notes.
+  #
+  # ==== Errors
+  # ArgumentError:: Raised if you supply a required argument after a non required one.
+  def argument(name, options = T.unsafe(nil)); end
+
+  # Returns this class arguments, looking up in the ancestors chain.
+  #
+  # ==== Returns
+  # Array[Thor::Argument]
+  def arguments; end
+
+  def attr_accessor(*_arg0); end
+  def attr_reader(*_arg0); end
+  def attr_writer(*_arg0); end
+  def check_default_type; end
+
+  # If you want to raise an error when the default value of an option does not match
+  # the type call check_default_type!
+  # This will be the default; for compatibility a deprecation warning is issued if necessary.
+  def check_default_type!; end
+
+  def check_unknown_options; end
+
+  # If you want to raise an error for unknown options, call check_unknown_options!
+  # This is disabled by default to allow dynamic invocations.
+  def check_unknown_options!; end
+
+  # @return [Boolean]
+  def check_unknown_options?(config); end
+
+  # Adds an option to the set of class options
+  #
+  # ==== Parameters
+  # name<Symbol>:: The name of the argument.
+  # options<Hash>:: Described below.
+  #
+  # ==== Options
+  # :desc::     -- Description for the argument.
+  # :required:: -- If the argument is required or not.
+  # :default::  -- Default value for this argument.
+  # :group::    -- The group for this options. Use by class options to output options in different levels.
+  # :aliases::  -- Aliases for this option. <b>Note:</b> Thor follows a convention of one-dash-one-letter options. Thus aliases like "-something" wouldn't be parsed; use either "\--something" or "-s" instead.
+  # :type::     -- The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+  # :banner::   -- String to show on usage notes.
+  # :hide::     -- If you want to hide this option from the help.
+  def class_option(name, options = T.unsafe(nil)); end
+
+  # Adds a bunch of options to the set of class options.
+  #
+  #   class_options :foo => false, :bar => :required, :baz => :string
+  #
+  # If you prefer more detailed declaration, check class_option.
+  #
+  # ==== Parameters
+  # Hash[Symbol => Object]
+  def class_options(options = T.unsafe(nil)); end
+
+  # Returns the commands for this Thor class.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  def commands; end
+
+  # If true, option set will not suspend the execution of the command when
+  # a required option is not provided.
+  #
+  # @return [Boolean]
+  def disable_required_check?(command_name); end
+
+  # A flag that makes the process exit with status 1 if any error happens.
+  #
+  # @return [Boolean]
+  def exit_on_failure?; end
+
+  # Defines the group. This is used when thor list is invoked so you can specify
+  # that only commands from a pre-defined group will be shown. Defaults to standard.
+  #
+  # ==== Parameters
+  # name<String|Symbol>
+  def group(name = T.unsafe(nil)); end
+
+  # @raise [InvocationError]
+  def handle_argument_error(command, error, args, arity); end
+
+  # @raise [UndefinedCommandError]
+  def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
+
+  # @raise [UndefinedCommandError]
+  def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
+
+  # Sets the namespace for the Thor or Thor::Group class. By default the
+  # namespace is retrieved from the class name. If your Thor class is named
+  # Scripts::MyScript, the help method, for example, will be called as:
+  #
+  #   thor scripts:my_script -h
+  #
+  # If you change the namespace:
+  #
+  #   namespace :my_scripts
+  #
+  # You change how your commands are invoked:
+  #
+  #   thor my_scripts -h
+  #
+  # Finally, if you change your namespace to default:
+  #
+  #   namespace :default
+  #
+  # Your commands can be invoked with a shortcut. Instead of:
+  #
+  #   thor :my_command
+  def namespace(name = T.unsafe(nil)); end
+
+  # All methods defined inside the given block are not added as commands.
+  #
+  # So you can do:
+  #
+  #   class MyScript < Thor
+  #     no_commands do
+  #       def this_is_not_a_command
+  #       end
+  #     end
+  #   end
+  #
+  # You can also add the method and remove it from the command list:
+  #
+  #   class MyScript < Thor
+  #     def this_is_not_a_command
+  #     end
+  #     remove_command :this_is_not_a_command
+  #   end
+  def no_commands(&block); end
+
+  # @return [Boolean]
+  def no_commands?; end
+
+  def no_commands_context; end
+
+  # All methods defined inside the given block are not added as commands.
+  #
+  # So you can do:
+  #
+  #   class MyScript < Thor
+  #     no_commands do
+  #       def this_is_not_a_command
+  #       end
+  #     end
+  #   end
+  #
+  # You can also add the method and remove it from the command list:
+  #
+  #   class MyScript < Thor
+  #     def this_is_not_a_command
+  #     end
+  #     remove_command :this_is_not_a_command
+  #   end
+  def no_tasks(&block); end
+
+  # Allows to use private methods from parent in child classes as commands.
+  #
+  # ==== Parameters
+  #   names<Array>:: Method names to be used as commands
+  #
+  # ==== Examples
+  #
+  #   public_command :foo
+  #   public_command :foo, :bar, :baz
+  def public_command(*names); end
+
+  # Allows to use private methods from parent in child classes as commands.
+  #
+  # ==== Parameters
+  #   names<Array>:: Method names to be used as commands
+  #
+  # ==== Examples
+  #
+  #   public_command :foo
+  #   public_command :foo, :bar, :baz
+  def public_task(*names); end
+
+  # Removes a previous defined argument. If :undefine is given, undefine
+  # accessors as well.
+  #
+  # ==== Parameters
+  # names<Array>:: Arguments to be removed
+  #
+  # ==== Examples
+  #
+  #   remove_argument :foo
+  #   remove_argument :foo, :bar, :baz, :undefine => true
+  def remove_argument(*names); end
+
+  # Removes a previous defined class option.
+  #
+  # ==== Parameters
+  # names<Array>:: Class options to be removed
+  #
+  # ==== Examples
+  #
+  #   remove_class_option :foo
+  #   remove_class_option :foo, :bar, :baz
+  def remove_class_option(*names); end
+
+  # Removes a given command from this Thor class. This is usually done if you
+  # are inheriting from another class and don't want it to be available
+  # anymore.
+  #
+  # By default it only remove the mapping to the command. But you can supply
+  # :undefine => true to undefine the method from the class as well.
+  #
+  # ==== Parameters
+  # name<Symbol|String>:: The name of the command to be removed
+  # options<Hash>:: You can give :undefine => true if you want commands the method
+  #                 to be undefined from the class as well.
+  def remove_command(*names); end
+
+  # Removes a given command from this Thor class. This is usually done if you
+  # are inheriting from another class and don't want it to be available
+  # anymore.
+  #
+  # By default it only remove the mapping to the command. But you can supply
+  # :undefine => true to undefine the method from the class as well.
+  #
+  # ==== Parameters
+  # name<Symbol|String>:: The name of the command to be removed
+  # options<Hash>:: You can give :undefine => true if you want commands the method
+  #                 to be undefined from the class as well.
+  def remove_task(*names); end
+
+  # Parses the command and options from the given args, instantiate the class
+  # and invoke the command. This method is used when the arguments must be parsed
+  # from an array. If you are inside Ruby and want to use a Thor class, you
+  # can simply initialize it:
+  #
+  #   script = MyScript.new(args, options, config)
+  #   script.invoke(:command, first_arg, second_arg, third_arg)
+  def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # If true, option parsing is suspended as soon as an unknown option or a
+  # regular argument is encountered.  All remaining arguments are passed to
+  # the command as regular arguments.
+  #
+  # @return [Boolean]
+  def stop_on_unknown_option?(command_name); end
+
+  def strict_args_position; end
+
+  # If you want only strict string args (useful when cascading thor classes),
+  # call strict_args_position! This is disabled by default to allow dynamic
+  # invocations.
+  def strict_args_position!; end
+
+  # @return [Boolean]
+  def strict_args_position?(config); end
+
+  # Returns the commands for this Thor class.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  def tasks; end
+
+  protected
+
+  # SIGNATURE: Sets the baseclass. This is where the superclass lookup
+  # finishes.
+  def baseclass; end
+
+  # The basename of the program invoking the thor class.
+  def basename; end
+
+  # Build an option and adds it to the given scope.
+  #
+  # ==== Parameters
+  # name<Symbol>:: The name of the argument.
+  # options<Hash>:: Described in both class_option and method_option.
+  # scope<Hash>:: Options hash that is being built up
+  def build_option(name, options, scope); end
+
+  # Receives a hash of options, parse them and add to the scope. This is a
+  # fast way to set a bunch of options:
+  #
+  #   build_options :foo => true, :bar => :required, :baz => :string
+  #
+  # ==== Parameters
+  # Hash[Symbol => Object]
+  def build_options(options, scope); end
+
+  # Prints the class options per group. If an option does not belong to
+  # any group, it's printed as Class option.
+  def class_options_help(shell, groups = T.unsafe(nil)); end
+
+  # SIGNATURE: Creates a new command if valid_command? is true. This method is
+  # called when a new method is added to the class.
+  def create_command(meth); end
+
+  # SIGNATURE: Creates a new command if valid_command? is true. This method is
+  # called when a new method is added to the class.
+  def create_task(meth); end
+
+  # SIGNATURE: The hook invoked by start.
+  #
+  # @raise [NotImplementedError]
+  def dispatch(command, given_args, given_opts, config); end
+
+  # Finds a command with the given name. If the command belongs to the current
+  # class, just return it, otherwise dup it and add the fresh copy to the
+  # current command hash.
+  def find_and_refresh_command(name); end
+
+  # Finds a command with the given name. If the command belongs to the current
+  # class, just return it, otherwise dup it and add the fresh copy to the
+  # current command hash.
+  def find_and_refresh_task(name); end
+
+  # Retrieves a value from superclass. If it reaches the baseclass,
+  # returns default.
+  def from_superclass(method, default = T.unsafe(nil)); end
+
+  # Everytime someone inherits from a Thor class, register the klass
+  # and file into baseclass.
+  def inherited(klass); end
+
+  # SIGNATURE: Defines behavior when the initialize method is added to the
+  # class.
+  def initialize_added; end
+
+  # Raises an error if the word given is a Thor reserved word.
+  #
+  # @return [Boolean]
+  def is_thor_reserved_word?(word, type); end
+
+  # Fire this callback whenever a method is added. Added methods are
+  # tracked as commands by invoking the create_command method.
+  def method_added(meth); end
+
+  # Receives a set of options and print them.
+  def print_options(shell, options, group_name = T.unsafe(nil)); end
+end
+
+class Thor::Command < ::Struct
+  # @return [Command] a new instance of Command
+  def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end
+
+  # Returns the formatted usage by injecting given required arguments
+  # and required options into the given usage.
+  def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  def hidden?; end
+
+  # By default, a command invokes a method in the thor class. You can change this
+  # implementation to create custom commands.
+  def run(instance, args = T.unsafe(nil)); end
+
+  protected
+
+  # @return [Boolean]
+  def handle_argument_error?(instance, error, caller); end
+
+  # @return [Boolean]
+  def handle_no_method_error?(instance, error, caller); end
+
+  # @return [Boolean]
+  def local_method?(instance, name); end
+
+  # @return [Boolean]
+  def not_debugging?(instance); end
+
+  # @return [Boolean]
+  def private_method?(instance); end
+
+  # Given a target, checks if this class name is a public method.
+  #
+  # @return [Boolean]
+  def public_method?(instance); end
+
+  # Add usage with required arguments
+  def required_arguments_for(klass, usage); end
+
+  def required_options; end
+  def sans_backtrace(backtrace, caller); end
+
+  private
+
+  def initialize_copy(other); end
+end
+
+Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
+module Thor::CoreExt; end
+
+# A hash with indifferent access and magic predicates.
+#
+#   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+#
+#   hash[:foo]  #=> 'bar'
+#   hash['foo'] #=> 'bar'
+#   hash.foo?   #=> true
+class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
+  # @return [HashWithIndifferentAccess] a new instance of HashWithIndifferentAccess
+  def initialize(hash = T.unsafe(nil)); end
+
+  def [](key); end
+  def []=(key, value); end
+  def delete(key); end
+  def except(*keys); end
+  def fetch(key, *args); end
+
+  # @return [Boolean]
+  def key?(key); end
+
+  def merge(other); end
+  def merge!(other); end
+  def replace(other_hash); end
+  def reverse_merge(other); end
+  def reverse_merge!(other_hash); end
+
+  # Convert to a Hash with String keys.
+  def to_hash; end
+
+  def values_at(*indices); end
+
+  protected
+
+  def convert_key(key); end
+
+  # Magic predicates. For instance:
+  #
+  #   options.force?                  # => !!options['force']
+  #   options.shebang                 # => "/usr/lib/local/ruby"
+  #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+  def method_missing(method, *args); end
+end
+
+Thor::Correctable = DidYouMean::Correctable
+
+# A dynamic command that handles method missing scenarios.
+class Thor::DynamicCommand < ::Thor::Command
+  # @return [DynamicCommand] a new instance of DynamicCommand
+  def initialize(name, options = T.unsafe(nil)); end
+
+  def run(instance, args = T.unsafe(nil)); end
+end
+
+Thor::DynamicTask = Thor::DynamicCommand
+
+# Thor::Error is raised when it's caused by wrong usage of thor classes. Those
+# errors have their backtrace suppressed and are nicely shown to the user.
+#
+# Errors that are caused by the developer, like declaring a method which
+# overwrites a thor keyword, SHOULD NOT raise a Thor::Error. This way, we
+# ensure that developer errors are shown with full backtrace.
+class Thor::Error < ::StandardError; end
+
+# Thor has a special class called Thor::Group. The main difference to Thor class
+# is that it invokes all commands at once. It also include some methods that allows
+# invocations to be done at the class method, which are not available to Thor
+# commands.
+class Thor::Group
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  protected
+
+  # Shortcut to invoke with padding and block handling. Use internally by
+  # invoke and invoke_from_option class methods.
+  def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
+
+  class << self
+    # Overwrite class options help to allow invoked generators options to be
+    # shown recursively when invoking a generator.
+    def class_options_help(shell, groups = T.unsafe(nil)); end
+
+    # The description for this Thor::Group. If none is provided, but a source root
+    # exists, tries to find the USAGE one folder above it, otherwise searches
+    # in the superclass.
+    #
+    # ==== Parameters
+    # description<String>:: The description for this Thor::Group.
+    def desc(description = T.unsafe(nil)); end
+
+    # Get invocations array and merge options from invocations. Those
+    # options are added to group_options hash. Options that already exists
+    # in base_options are not added twice.
+    def get_options_from_invocations(group_options, base_options); end
+
+    # @raise [error]
+    def handle_argument_error(command, error, _args, arity); end
+
+    # Prints help information.
+    #
+    # ==== Options
+    # short:: When true, shows only usage.
+    def help(shell); end
+
+    # Stores invocation blocks used on invoke_from_option.
+    def invocation_blocks; end
+
+    # Stores invocations for this class merging with superclass values.
+    def invocations; end
+
+    # Invoke the given namespace or class given. It adds an instance
+    # method that will invoke the klass and command. You can give a block to
+    # configure how it will be invoked.
+    #
+    # The namespace/class given will have its options showed on the help
+    # usage. Check invoke_from_option for more information.
+    def invoke(*names, &block); end
+
+    # Invoke a thor class based on the value supplied by the user to the
+    # given option named "name". A class option must be created before this
+    # method is invoked for each name given.
+    #
+    # ==== Examples
+    #
+    #   class GemGenerator < Thor::Group
+    #     class_option :test_framework, :type => :string
+    #     invoke_from_option :test_framework
+    #   end
+    #
+    # ==== Boolean options
+    #
+    # In some cases, you want to invoke a thor class if some option is true or
+    # false. This is automatically handled by invoke_from_option. Then the
+    # option name is used to invoke the generator.
+    #
+    # ==== Preparing for invocation
+    #
+    # In some cases you want to customize how a specified hook is going to be
+    # invoked. You can do that by overwriting the class method
+    # prepare_for_invocation. The class method must necessarily return a klass
+    # and an optional command.
+    #
+    # ==== Custom invocations
+    #
+    # You can also supply a block to customize how the option is going to be
+    # invoked. The block receives two parameters, an instance of the current
+    # class and the klass to be invoked.
+    def invoke_from_option(*names, &block); end
+
+    # Returns commands ready to be printed.
+    def printable_commands(*_arg0); end
+
+    # Returns commands ready to be printed.
+    def printable_tasks(*_arg0); end
+
+    # Remove a previously added invocation.
+    #
+    # ==== Examples
+    #
+    #   remove_invocation :test_framework
+    def remove_invocation(*names); end
+
+    protected
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Thor::Runner.
+    def banner; end
+
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+
+    # The method responsible for dispatching given the args.
+    #
+    # @yield [instance]
+    def dispatch(command, given_args, given_opts, config); end
+
+    # Represents the whole class as a command.
+    def self_command; end
+
+    # Represents the whole class as a command.
+    def self_task; end
+  end
+end
+
+# Shortcuts for help.
+Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
+
+# A command that is hidden in help messages but still invocable.
+class Thor::HiddenCommand < ::Thor::Command
+  # @return [Boolean]
+  def hidden?; end
+end
+
+Thor::HiddenTask = Thor::HiddenCommand
+
+module Thor::Invocation
+  mixes_in_class_methods ::Thor::Invocation::ClassMethods
+
+  # Make initializer aware of invocations and the initialization args.
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+  # Make the current command chain accessible with in a Thor-(sub)command
+  def current_command_chain; end
+
+  # Receives a name and invokes it. The name can be a string (either "command" or
+  # "namespace:command"), a Thor::Command, a Class or a Thor instance. If the
+  # command cannot be guessed by name, it can also be supplied as second argument.
+  #
+  # You can also supply the arguments, options and configuration values for
+  # the command to be invoked, if none is given, the same values used to
+  # initialize the invoker are used to initialize the invoked.
+  #
+  # When no name is given, it will invoke the default command of the current class.
+  #
+  # ==== Examples
+  #
+  #   class A < Thor
+  #     def foo
+  #       invoke :bar
+  #       invoke "b:hello", ["Erik"]
+  #     end
+  #
+  #     def bar
+  #       invoke "b:hello", ["Erik"]
+  #     end
+  #   end
+  #
+  #   class B < Thor
+  #     def hello(name)
+  #       puts "hello #{name}"
+  #     end
+  #   end
+  #
+  # You can notice that the method "foo" above invokes two commands: "bar",
+  # which belongs to the same class and "hello" which belongs to the class B.
+  #
+  # By using an invocation system you ensure that a command is invoked only once.
+  # In the example above, invoking "foo" will invoke "b:hello" just once, even
+  # if it's invoked later by "bar" method.
+  #
+  # When class A invokes class B, all arguments used on A initialization are
+  # supplied to B. This allows lazy parse of options. Let's suppose you have
+  # some rspec commands:
+  #
+  #   class Rspec < Thor::Group
+  #     class_option :mock_framework, :type => :string, :default => :rr
+  #
+  #     def invoke_mock_framework
+  #       invoke "rspec:#{options[:mock_framework]}"
+  #     end
+  #   end
+  #
+  # As you noticed, it invokes the given mock framework, which might have its
+  # own options:
+  #
+  #   class Rspec::RR < Thor::Group
+  #     class_option :style, :type => :string, :default => :mock
+  #   end
+  #
+  # Since it's not rspec concern to parse mock framework options, when RR
+  # is invoked all options are parsed again, so RR can extract only the options
+  # that it's going to use.
+  #
+  # If you want Rspec::RR to be initialized with its own set of options, you
+  # have to do that explicitly:
+  #
+  #   invoke "rspec:rr", [], :style => :foo
+  #
+  # Besides giving an instance, you can also give a class to invoke:
+  #
+  #   invoke Rspec::RR, [], :style => :foo
+  def invoke(name = T.unsafe(nil), *args); end
+
+  # Invoke all commands for the current instance.
+  def invoke_all; end
+
+  # Invoke the given command if the given args.
+  def invoke_command(command, *args); end
+
+  # Invoke the given command if the given args.
+  def invoke_task(command, *args); end
+
+  # Invokes using shell padding.
+  def invoke_with_padding(*args); end
+
+  protected
+
+  # Initialize klass using values stored in the @_initializer.
+  def _parse_initialization_options(args, opts, config); end
+
+  # This method simply retrieves the class and command to be invoked.
+  # If the name is nil or the given name is a command in the current class,
+  # use the given name and return self as class. Otherwise, call
+  # prepare_for_invocation in the current class.
+  def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
+
+  # This method simply retrieves the class and command to be invoked.
+  # If the name is nil or the given name is a command in the current class,
+  # use the given name and return self as class. Otherwise, call
+  # prepare_for_invocation in the current class.
+  def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
+
+  # Configuration values that are shared between invocations.
+  def _shared_configuration; end
+
+  class << self
+    def included(base); end
+  end
+end
+
+module Thor::Invocation::ClassMethods
+  # This method is responsible for receiving a name and find the proper
+  # class and command for it. The key is an optional parameter which is
+  # available only in class methods invocations (i.e. in Thor::Group).
+  def prepare_for_invocation(key, name); end
+end
+
+# Raised when a command was found, but not invoked properly.
+class Thor::InvocationError < ::Thor::Error; end
+
+module Thor::LineEditor
+  class << self
+    def best_available; end
+    def readline(prompt, options = T.unsafe(nil)); end
+  end
+end
+
+class Thor::LineEditor::Basic
+  # @return [Basic] a new instance of Basic
+  def initialize(prompt, options); end
+
+  # Returns the value of attribute options.
+  def options; end
+
+  # Returns the value of attribute prompt.
+  def prompt; end
+
+  def readline; end
+
+  private
+
+  # @return [Boolean]
+  def echo?; end
+
+  def get_input; end
+
+  class << self
+    # @return [Boolean]
+    def available?; end
+  end
+end
+
+class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
+  def readline; end
+
+  private
+
+  # @return [Boolean]
+  def add_to_history?; end
+
+  def completion_options; end
+  def completion_proc; end
+
+  # @return [Boolean]
+  def use_path_completion?; end
+
+  class << self
+    # @return [Boolean]
+    def available?; end
+  end
+end
+
+class Thor::LineEditor::Readline::PathCompletion
+  # @return [PathCompletion] a new instance of PathCompletion
+  def initialize(text); end
+
+  def matches; end
+
+  private
+
+  def absolute_matches; end
+  def base_path; end
+  def glob_pattern; end
+  def relative_matches; end
+
+  # Returns the value of attribute text.
+  def text; end
+end
+
+class Thor::MalformattedArgumentError < ::Thor::InvocationError; end
+
+class Thor::NestedContext
+  # @return [NestedContext] a new instance of NestedContext
+  def initialize; end
+
+  def enter; end
+
+  # @return [Boolean]
+  def entered?; end
+
+  private
+
+  def pop; end
+  def push; end
+end
+
+class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker
+  def initialize(dictionary); end
+end
+
+class Thor::Option < ::Thor::Argument
+  # @return [Option] a new instance of Option
+  def initialize(name, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute aliases.
+  def aliases; end
+
+  def array?; end
+  def boolean?; end
+
+  # Returns the value of attribute group.
+  def group; end
+
+  def hash?; end
+
+  # Returns the value of attribute hide.
+  def hide; end
+
+  def human_name; end
+
+  # Returns the value of attribute lazy_default.
+  def lazy_default; end
+
+  def numeric?; end
+
+  # Returns the value of attribute repeatable.
+  def repeatable; end
+
+  def string?; end
+  def switch_name; end
+  def usage(padding = T.unsafe(nil)); end
+
+  protected
+
+  def dasherize(str); end
+
+  # @return [Boolean]
+  def dasherized?; end
+
+  def undasherize(str); end
+
+  # @raise [ArgumentError]
+  def validate!; end
+
+  def validate_default_type!; end
+
+  class << self
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    def parse(key, value); end
+  end
+end
+
+Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+class Thor::Options < ::Thor::Arguments
+  # Takes a hash of Thor::Option and a hash with defaults.
+  #
+  # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
+  # an unknown option or a regular argument.
+  #
+  # @return [Options] a new instance of Options
+  def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end
+
+  # @raise [UnknownArgumentError]
+  def check_unknown!; end
+
+  def parse(args); end
+  def peek; end
+  def remaining; end
+  def shift; end
+  def unshift(arg, is_value: T.unsafe(nil)); end
+
+  protected
+
+  def assign_result!(option, result); end
+
+  # Check if the current value in peek is a registered switch.
+  #
+  # Two booleans are returned.  The first is true if the current value
+  # starts with a hyphen; the second is true if it is a registered switch.
+  #
+  # @return [Boolean]
+  def current_is_switch?; end
+
+  # @return [Boolean]
+  def current_is_switch_formatted?; end
+
+  # @return [Boolean]
+  def current_is_value?; end
+
+  # Check if the given argument is actually a shortcut.
+  def normalize_switch(arg); end
+
+  # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+  def parse_boolean(switch); end
+
+  # Parse the value at the peek analyzing if it requires an input or not.
+  def parse_peek(switch, option); end
+
+  # @return [Boolean]
+  def parsing_options?; end
+
+  # @return [Boolean]
+  def switch?(arg); end
+
+  def switch_option(arg); end
+
+  class << self
+    # Receives a hash and makes it switches.
+    def to_switches(options); end
+  end
+end
+
+Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
+Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
+Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
+Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
+Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
+
+# Allow either -x -v or -xv style for single char args
+Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
+
+# Adds a compatibility layer to your Thor classes which allows you to use
+# rake package tasks. For example, to use rspec rake tasks, one can do:
+#
+#   require 'thor/rake_compat'
+#   require 'rspec/core/rake_task'
+#
+#   class Default < Thor
+#     include Thor::RakeCompat
+#
+#     RSpec::Core::RakeTask.new(:spec) do |t|
+#       t.spec_opts = ['--options', './.rspec']
+#       t.spec_files = FileList['spec/**/*_spec.rb']
+#     end
+#   end
+module Thor::RakeCompat
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils
+  include ::Rake::FileUtilsExt
+  include ::Rake::DSL
+
+  class << self
+    # @private
+    def included(base); end
+
+    def rake_classes; end
+  end
+end
+
+class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end
+module Thor::Sandbox; end
+
+module Thor::Shell
+  # Add shell to initialize config values.
+  #
+  # ==== Configuration
+  # shell<Object>:: An instance of the shell to be used.
+  #
+  # ==== Examples
+  #
+  #   class MyScript < Thor
+  #     argument :first, :type => :numeric
+  #   end
+  #
+  #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  def ask(*args, &block); end
+  def error(*args, &block); end
+  def file_collision(*args, &block); end
+  def no?(*args, &block); end
+  def print_in_columns(*args, &block); end
+  def print_table(*args, &block); end
+  def print_wrapped(*args, &block); end
+  def say(*args, &block); end
+  def say_error(*args, &block); end
+  def say_status(*args, &block); end
+  def set_color(*args, &block); end
+
+  # Holds the shell for the given Thor instance. If no shell is given,
+  # it gets a default shell from Thor::Base.shell.
+  def shell; end
+
+  # Sets the attribute shell
+  #
+  # @param value the value to set the attribute shell to.
+  def shell=(_arg0); end
+
+  def terminal_width(*args, &block); end
+
+  # Yields the given block with padding.
+  def with_padding; end
+
+  def yes?(*args, &block); end
+
+  protected
+
+  # Allow shell to be shared between invocations.
+  def _shared_configuration; end
+end
+
+class Thor::Shell::Basic
+  # Initialize base, mute and padding to nil.
+  #
+  # @return [Basic] a new instance of Basic
+  def initialize; end
+
+  # Asks something to the user and receives a response.
+  #
+  # If a default value is specified it will be presented to the user
+  # and allows them to select that value with an empty response. This
+  # option is ignored when limited answers are supplied.
+  #
+  # If asked to limit the correct responses, you can pass in an
+  # array of acceptable answers.  If one of those is not supplied,
+  # they will be shown a message stating that one of those answers
+  # must be given and re-asked the question.
+  #
+  # If asking for sensitive information, the :echo option can be set
+  # to false to mask user input from $stdin.
+  #
+  # If the required input is a path, then set the path option to
+  # true. This will enable tab completion for file paths relative
+  # to the current working directory on systems that support
+  # Readline.
+  #
+  # ==== Example
+  # ask("What is your name?")
+  #
+  # ask("What is the planet furthest from the sun?", :default => "Pluto")
+  #
+  # ask("What is your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])
+  #
+  # ask("What is your password?", :echo => false)
+  #
+  # ask("Where should the file be saved?", :path => true)
+  def ask(statement, *args); end
+
+  # Returns the value of attribute base.
+  def base; end
+
+  # Sets the attribute base
+  #
+  # @param value the value to set the attribute base to.
+  def base=(_arg0); end
+
+  # Called if something goes wrong during the execution. This is used by Thor
+  # internally and should not be used inside your scripts. If something went
+  # wrong, you can always raise an exception. If you raise a Thor::Error, it
+  # will be rescued and wrapped in the method below.
+  def error(statement); end
+
+  # Deals with file collision and returns true if the file should be
+  # overwritten and false otherwise. If a block is given, it uses the block
+  # response as the content for the diff.
+  #
+  # ==== Parameters
+  # destination<String>:: the destination file to solve conflicts
+  # block<Proc>:: an optional block that returns the value to be used in diff and merge
+  def file_collision(destination); end
+
+  # Sets the output padding while executing a block and resets it.
+  def indent(count = T.unsafe(nil)); end
+
+  # Mute everything that's inside given block
+  def mute; end
+
+  # Check if base is muted
+  #
+  # @return [Boolean]
+  def mute?; end
+
+  # Make a question the to user and returns true if the user replies "n" or
+  # "no".
+  #
+  # @return [Boolean]
+  def no?(statement, color = T.unsafe(nil)); end
+
+  # Returns the value of attribute padding.
+  def padding; end
+
+  # Sets the output padding, not allowing less than zero values.
+  def padding=(value); end
+
+  # Prints values in columns
+  #
+  # ==== Parameters
+  # Array[String, String, ...]
+  def print_in_columns(array); end
+
+  # Prints a table.
+  #
+  # ==== Parameters
+  # Array[Array[String, String, ...]]
+  #
+  # ==== Options
+  # indent<Integer>:: Indent the first column by indent value.
+  # colwidth<Integer>:: Force the first column to colwidth spaces wide.
+  def print_table(array, options = T.unsafe(nil)); end
+
+  # Prints a long string, word-wrapping the text to the current width of the
+  # terminal display. Ideal for printing heredocs.
+  #
+  # ==== Parameters
+  # String
+  #
+  # ==== Options
+  # indent<Integer>:: Indent each line of the printed paragraph by indent value.
+  def print_wrapped(message, options = T.unsafe(nil)); end
+
+  # Say (print) something to the user. If the sentence ends with a whitespace
+  # or tab character, a new line is not appended (print + flush). Otherwise
+  # are passed straight to puts (behavior got from Highline).
+  #
+  # ==== Example
+  # say("I know you knew that.")
+  def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
+
+  # Say (print) an error to the user. If the sentence ends with a whitespace
+  # or tab character, a new line is not appended (print + flush). Otherwise
+  # are passed straight to puts (behavior got from Highline).
+  #
+  # ==== Example
+  # say_error("error: something went wrong")
+  def say_error(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
+
+  # Say a status with the given color and appends the message. Since this
+  # method is used frequently by actions, it allows nil or false to be given
+  # in log_status, avoiding the message from being shown. If a Symbol is
+  # given in log_status, it's used as the color.
+  def say_status(status, message, log_status = T.unsafe(nil)); end
+
+  # Apply color to the given string with optional bold. Disabled in the
+  # Thor::Shell::Basic class.
+  def set_color(string, *_arg1); end
+
+  def terminal_width; end
+
+  # Make a question the to user and returns true if the user replies "y" or
+  # "yes".
+  #
+  # @return [Boolean]
+  def yes?(statement, color = T.unsafe(nil)); end
+
+  protected
+
+  def answer_match(possibilities, answer, case_insensitive); end
+  def as_unicode; end
+  def ask_filtered(statement, color, options); end
+  def ask_simply(statement, color, options); end
+
+  # @return [Boolean]
+  def can_display_colors?; end
+
+  # Calculate the dynamic width of the terminal
+  def dynamic_width; end
+
+  def dynamic_width_stty; end
+  def dynamic_width_tput; end
+  def file_collision_help; end
+  def git_merge_tool; end
+
+  # @return [Boolean]
+  def is?(value); end
+
+  def lookup_color(color); end
+  def merge(destination, content); end
+  def merge_tool; end
+  def prepare_message(message, *color); end
+
+  # @return [Boolean]
+  def quiet?; end
+
+  def show_diff(destination, content); end
+  def stderr; end
+  def stdout; end
+  def truncate(string, width); end
+
+  # @return [Boolean]
+  def unix?; end
+end
+
+Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# Inherit from Thor::Shell::Basic and add set_color behavior. Check
+# Thor::Shell::Basic to see all available methods.
+class Thor::Shell::Color < ::Thor::Shell::Basic
+  # Set color by using a string or one of the defined constants. If a third
+  # option is set to true, it also adds bold to the string. This is based
+  # on Highline implementation and it automatically appends CLEAR to the end
+  # of the returned String.
+  #
+  # Pass foreground, background and bold options to this method as
+  # symbols.
+  #
+  # Example:
+  #
+  #   set_color "Hi!", :red, :on_white, :bold
+  #
+  # The available colors are:
+  #
+  #   :bold
+  #   :black
+  #   :red
+  #   :green
+  #   :yellow
+  #   :blue
+  #   :magenta
+  #   :cyan
+  #   :white
+  #   :on_black
+  #   :on_red
+  #   :on_green
+  #   :on_yellow
+  #   :on_blue
+  #   :on_magenta
+  #   :on_cyan
+  #   :on_white
+  def set_color(string, *colors); end
+
+  protected
+
+  # @return [Boolean]
+  def are_colors_disabled?; end
+
+  # @return [Boolean]
+  def are_colors_supported?; end
+
+  # @return [Boolean]
+  def can_display_colors?; end
+
+  # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+  # for diff.
+  #
+  # @return [Boolean]
+  def diff_lcs_loaded?; end
+
+  def output_diff_line(diff); end
+
+  # Overwrite show_diff to show diff with colors if Diff::LCS is
+  # available.
+  def show_diff(destination, content); end
+end
+
+# Set the terminal's foreground ANSI color to black.
+Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to blue.
+Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String)
+
+# The start of an ANSI bold sequence.
+Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String)
+
+# Embed in a String to clear all previous ANSI sequences.
+Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to cyan.
+Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to green.
+Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to magenta.
+Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to black.
+Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to blue.
+Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to cyan.
+Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to green.
+Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to magenta.
+Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to red.
+Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to white.
+Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to yellow.
+Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to red.
+Thor::Shell::Color::RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to white.
+Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to yellow.
+Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
+
+# Inherit from Thor::Shell::Basic and add set_color behavior. Check
+# Thor::Shell::Basic to see all available methods.
+class Thor::Shell::HTML < ::Thor::Shell::Basic
+  # Ask something to the user and receives a response.
+  #
+  # ==== Example
+  # ask("What is your name?")
+  #
+  # TODO: Implement #ask for Thor::Shell::HTML
+  #
+  # @raise [NotImplementedError]
+  def ask(statement, color = T.unsafe(nil)); end
+
+  # Set color by using a string or one of the defined constants. If a third
+  # option is set to true, it also adds bold to the string. This is based
+  # on Highline implementation and it automatically appends CLEAR to the end
+  # of the returned String.
+  def set_color(string, *colors); end
+
+  protected
+
+  # @return [Boolean]
+  def can_display_colors?; end
+
+  # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+  # for diff.
+  #
+  # @return [Boolean]
+  def diff_lcs_loaded?; end
+
+  def output_diff_line(diff); end
+
+  # Overwrite show_diff to show diff with colors if Diff::LCS is
+  # available.
+  def show_diff(destination, content); end
+end
+
+# Set the terminal's foreground HTML color to black.
+Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to blue.
+Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String)
+
+# The start of an HTML bold sequence.
+Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to cyan.
+Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to green.
+Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to magenta.
+Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to black.
+Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to blue.
+Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to cyan.
+Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to green.
+Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to magenta.
+Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to red.
+Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to white.
+Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to yellow.
+Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to red.
+Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to white.
+Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to yellow.
+Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String)
+
+Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array)
+Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String)
+
+# Thor methods that should not be overwritten by the user.
+Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+
+Thor::Task = Thor::Command
+
+# Raised when a command was not found.
+class Thor::UndefinedCommandError < ::Thor::Error
+  include ::DidYouMean::Correctable
+
+  # @return [UndefinedCommandError] a new instance of UndefinedCommandError
+  def initialize(command, all_commands, namespace); end
+
+  # Returns the value of attribute all_commands.
+  def all_commands; end
+
+  # Returns the value of attribute command.
+  def command; end
+end
+
+class Thor::UndefinedCommandError::SpellChecker
+  # @return [SpellChecker] a new instance of SpellChecker
+  def initialize(error); end
+
+  def corrections; end
+
+  # Returns the value of attribute error.
+  def error; end
+
+  def spell_checker; end
+end
+
+Thor::UndefinedTaskError = Thor::UndefinedCommandError
+
+class Thor::UnknownArgumentError < ::Thor::Error
+  include ::DidYouMean::Correctable
+
+  # @return [UnknownArgumentError] a new instance of UnknownArgumentError
+  def initialize(switches, unknown); end
+
+  # Returns the value of attribute switches.
+  def switches; end
+
+  # Returns the value of attribute unknown.
+  def unknown; end
+end
+
+class Thor::UnknownArgumentError::SpellChecker
+  # @return [SpellChecker] a new instance of SpellChecker
+  def initialize(error); end
+
+  def corrections; end
+
+  # Returns the value of attribute error.
+  def error; end
+
+  def spell_checker; end
+end
+
+# This module holds several utilities:
+#
+# 1) Methods to convert thor namespaces to constants and vice-versa.
+#
+#   Thor::Util.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+#
+# 2) Loading thor files and sandboxing:
+#
+#   Thor::Util.load_thorfile("~/.thor/foo")
+module Thor::Util
+  class << self
+    # Receives a string and convert it to camel case. camel_case returns CamelCase.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    def camel_case(str); end
+
+    # Returns a string that has had any glob characters escaped.
+    # The glob characters are `* ? { } [ ]`.
+    #
+    # ==== Examples
+    #
+    #   Thor::Util.escape_globs('[apps]')   # => '\[apps\]'
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    def escape_globs(path); end
+
+    # Returns a string that has had any HTML characters escaped.
+    #
+    # ==== Examples
+    #
+    #   Thor::Util.escape_html('<div>')   # => "&lt;div&gt;"
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    def escape_html(string); end
+
+    # Receives a namespace and search for it in the Thor::Base subclasses.
+    #
+    # ==== Parameters
+    # namespace<String>:: The namespace to search for.
+    def find_by_namespace(namespace); end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default command
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default command
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end
+
+    # Where to look for Thor files.
+    def globs_for(path); end
+
+    # Receives a path and load the thor file in the path. The file is evaluated
+    # inside the sandbox to avoid namespacing conflicts.
+    def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end
+
+    # Receives a constant and converts it to a Thor namespace. Since Thor
+    # commands can be added to a sandbox, this method is also responsible for
+    # removing the sandbox namespace.
+    #
+    # This method should not be used in general because it's used to deal with
+    # older versions of Thor. On current versions, if you need to get the
+    # namespace from a class, just call namespace on it.
+    #
+    # ==== Parameters
+    # constant<Object>:: The constant to be converted to the thor path.
+    #
+    # ==== Returns
+    # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
+    def namespace_from_thor_class(constant); end
+
+    # Given the contents, evaluate it inside the sandbox and returns the
+    # namespaces defined in the sandbox.
+    #
+    # ==== Parameters
+    # contents<String>
+    #
+    # ==== Returns
+    # Array[Object]
+    def namespaces_in_content(contents, file = T.unsafe(nil)); end
+
+    # Return the path to the ruby interpreter taking into account multiple
+    # installations and windows extensions.
+    def ruby_command; end
+
+    # Receives a string and convert it to snake case. SnakeCase returns snake_case.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    def snake_case(str); end
+
+    # Returns the thor classes declared inside the given class.
+    def thor_classes_in(klass); end
+
+    # Returns the root where thor files are located, depending on the OS.
+    def thor_root; end
+
+    # Returns the files in the thor root. On Windows thor_root will be something
+    # like this:
+    #
+    #   C:\Documents and Settings\james\.thor
+    #
+    # If we don't #gsub the \ character, Dir.glob will fail.
+    def thor_root_glob; end
+
+    def user_home; end
+  end
+end