danger-packwerk 0.7.0 → 0.7.1

data/sorbet/rbi/gems/git@1.12.0.rbi

@@ -0,0 +1,1936 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `git` gem.
+# Please instead update this file by running `bin/tapioca gem git`.
+
+# The Git module provides the basic functions to open a git
+# reference to work with. You can open a working directory,
+# open a bare repository, initialize a new repo or clone an
+# existing remote repository.
+#
+# @author Scott Chacon (mailto:schacon@gmail.com)
+module Git
+  # g.config('user.name', 'Scott Chacon') # sets value
+  # g.config('user.email', 'email@email.com')  # sets value
+  # g.config('user.name')  # returns 'Scott Chacon'
+  # g.config # returns whole config hash
+  def config(name = T.unsafe(nil), value = T.unsafe(nil)); end
+
+  def global_config(name = T.unsafe(nil), value = T.unsafe(nil)); end
+
+  class << self
+    # Open a bare repository
+    #
+    # Opens a bare repository located in the `git_dir` directory.
+    # Since there is no working copy, you can not checkout or commit
+    # but you can do most read operations.
+    #
+    # @example Open a bare repository and retrieve the first commit SHA
+    #   repository = Git.bare('ruby-git.git')
+    #   puts repository.log[0].sha #=> "64c6fa011d3287bab9158049c85f3e85718854a0"
+    # @option options
+    # @param git_dir [Pathname] The path to the bare repository directory
+    #   containing an initialized Git repository. If a relative path is given, it
+    #   is converted to an absolute path using
+    #   [File.expand_path](https://www.rubydoc.info/stdlib/core/File.expand_path).
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the bare repository.
+    # @see https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefbarerepositoryabarerepository What is a bare repository?
+    def bare(git_dir, options = T.unsafe(nil)); end
+
+    # Clone a repository into an empty or newly created directory
+    #
+    # @example Clone into a different directory `my-ruby-git`
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', 'my-ruby-git')
+    #   # or:
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', path: 'my-ruby-git')
+    # @example Clone into the default directory `ruby-git`
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git')
+    # @example Create a bare repository in the directory `ruby-git.git`
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', bare: true)
+    # @example Clone and then checkout the `development` branch
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', branch: 'development')
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @param repository_url [URI, Pathname] The (possibly remote) repository url to clone
+    #   from. See [GIT URLS](https://git-scm.com/docs/git-clone#_git_urls_a_id_urls_a)
+    #   for more information.
+    # @param directory [Pathname, nil] The directory to clone into
+    #
+    #   If `directory` is a relative directory it is relative to the `path` option if
+    #   given. If `path` is not given, `directory` is relative to the current working
+    #   directory.
+    #
+    #   If `nil`, `directory` will be set to the basename of the last component of
+    #   the path from the `repository_url`. For example, for the URL:
+    #   `https://github.com/org/repo.git`, `directory` will be set to `repo`.
+    #
+    #   If the last component of the path is `.git`, the next-to-last component of
+    #   the path is used. For example, for the URL `/Users/me/foo/.git`, `directory`
+    #   will be set to `foo`.
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the cloned local working copy or cloned repository.
+    # @see https://git-scm.com/docs/git-clone git clone
+    # @see https://git-scm.com/docs/git-clone#_git_urls_a_id_urls_a GIT URLs
+    def clone(repository_url, directory = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    def config; end
+
+    # @yield [Base.config]
+    def configure; end
+
+    # Export the current HEAD (or a branch, if <tt>options[:branch]</tt>
+    # is specified) into the +name+ directory, then remove all traces of git from the
+    # directory.
+    #
+    # See +clone+ for options.  Does not obey the <tt>:remote</tt> option,
+    # since the .git info will be deleted anyway; always uses the default
+    # remote, 'origin.'
+    def export(repository, name, options = T.unsafe(nil)); end
+
+    # Same as g.config, but forces it to be at the global level
+    #
+    # g.config('user.name', 'Scott Chacon') # sets value
+    # g.config('user.email', 'email@email.com')  # sets value
+    # g.config('user.name')  # returns 'Scott Chacon'
+    # g.config # returns whole config hash
+    def global_config(name = T.unsafe(nil), value = T.unsafe(nil)); end
+
+    # Create an empty Git repository or reinitialize an existing Git repository
+    #
+    # @example Initialize a repository in some other directory
+    #   git = Git.init '~/code/ruby-git'
+    # @example Initialize a bare repository
+    #   git = Git.init '~/code/ruby-git.git', bare: true
+    # @example Initialize a repository in the current directory
+    #   git = Git.init
+    # @example Initialize a repository in a non-default location (outside of the working copy)
+    #   git = Git.init '~/code/ruby-git', repository: '~/code/ruby-git.git'
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @param directory [Pathname] If the `:bare` option is NOT given or is not
+    #   `true`, the repository will be created in `"#{directory}/.git"`.
+    #   Otherwise, the repository is created in `"#{directory}"`.
+    #
+    #   All directories along the path to `directory` are created if they do not exist.
+    #
+    #   A relative path is referenced from the current working directory of the process
+    #   and converted to an absolute path using
+    #   [File.expand_path](https://www.rubydoc.info/stdlib/core/File.expand_path).
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the newly initialized repository
+    # @see https://git-scm.com/docs/git-init git init
+    def init(directory = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    # returns a Hash containing information about the references
+    # of the target repository
+    #
+    # options
+    #   :refs
+    #
+    # @param location [String|NilClass] the target repository location or nil for '.'
+    # @return [{String=>Hash}] the available references of the target repo.
+    def ls_remote(location = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    # Open a an existing Git working directory
+    #
+    # Git.open will most likely be the most common way to create
+    # a git reference, referring to an existing working directory.
+    #
+    # If not provided in the options, the library will assume
+    # the repository and index are in the default places (`.git/`, `.git/index`).
+    #
+    # @example Open a Git working directory in some other directory
+    #   git = Git.open('~/Projects/ruby-git')
+    # @example Open the Git working directory in the current directory
+    #   git = Git.open
+    # @example Use a logger to see what is going on
+    #   logger = Logger.new(STDOUT)
+    #   git = Git.open('~/Projects/ruby-git', log: logger)
+    # @example Open a working copy whose repository is in a non-standard directory
+    #   git = Git.open('~/Projects/ruby-git', repository: '~/Project/ruby-git.git')
+    # @option options
+    # @option options
+    # @option options
+    # @param working_dir [Pathname] the path to the working directory to use
+    #   for git commands.
+    #
+    #   A relative path is referenced from the current working directory of the process
+    #   and converted to an absolute path using
+    #   [File.expand_path](https://www.rubydoc.info/stdlib/core/File.expand_path).
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the opened working copy
+    def open(working_dir, options = T.unsafe(nil)); end
+  end
+end
+
+class Git::Author
+  # @return [Author] a new instance of Author
+  def initialize(author_string); end
+
+  # Returns the value of attribute date.
+  def date; end
+
+  # Sets the attribute date
+  #
+  # @param value the value to set the attribute date to.
+  def date=(_arg0); end
+
+  # Returns the value of attribute email.
+  def email; end
+
+  # Sets the attribute email
+  #
+  # @param value the value to set the attribute email to.
+  def email=(_arg0); end
+
+  # Returns the value of attribute name.
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value the value to set the attribute name to.
+  def name=(_arg0); end
+end
+
+# Git::Base is the main public interface for interacting with Git commands.
+#
+# Instead of creating a Git::Base directly, obtain a Git::Base instance by
+# calling one of the follow {Git} class methods: {Git.open}, {Git.init},
+# {Git.clone}, or {Git.bare}.
+class Git::Base
+  include ::Git::Base::Factory
+
+  # Create an object that executes Git commands in the context of a working
+  # copy or a bare repository.
+  #
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @param options [Hash] The options for this command (see list of valid
+  #   options below)
+  # @return [Git::Base] an object that can execute git commands in the context
+  #   of the opened working copy or bare repository
+  def initialize(options = T.unsafe(nil)); end
+
+  # updates the repository index using the working directory content
+  #
+  # options:
+  #   :all => true
+  #
+  # @example
+  #   git.add
+  #   git.add('path/to/file')
+  #   git.add(['path/to/file1','path/to/file2'])
+  #   git.add(:all => true)
+  # @option options
+  # @param paths [String, Array] files paths to be added (optional, default='.')
+  # @param options [Hash]
+  def add(paths = T.unsafe(nil), **options); end
+
+  # adds a new remote to this repository
+  # url can be a git url or a Git::Base object if it's a local reference
+  #
+  #  @git.add_remote('scotts_git', 'git://repo.or.cz/rubygit.git')
+  #  @git.fetch('scotts_git')
+  #  @git.merge('scotts_git/master')
+  #
+  # Options:
+  #   :fetch => true
+  #   :track => <branch_name>
+  def add_remote(name, url, opts = T.unsafe(nil)); end
+
+  # Creates a new git tag (Git::Tag)
+  #
+  # @example
+  #   repo.add_tag('tag_name', object_reference)
+  #   repo.add_tag('tag_name', object_reference, {:options => 'here'})
+  #   repo.add_tag('tag_name', {:options => 'here'})
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @param name [String] The name of the tag to add
+  # @param options [Hash] Opstions to pass to `git tag`.
+  #   See [git-tag](https://git-scm.com/docs/git-tag) for more details.
+  def add_tag(name, *options); end
+
+  def apply(file); end
+  def apply_mail(file); end
+
+  # creates an archive file of the given tree-ish
+  def archive(treeish, file = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  def cat_file(objectish); end
+
+  # changes current working directory for a block
+  # to the git working directory
+  #
+  # example
+  #  @git.chdir do
+  #    # write files
+  #    @git.add
+  #    @git.commit('message')
+  #  end
+  def chdir; end
+
+  # checks out a branch as the new git working directory
+  def checkout(branch = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # checks out an old version of a file
+  def checkout_file(version, file); end
+
+  def checkout_index(opts = T.unsafe(nil)); end
+
+  # cleans the working directory
+  #
+  # options:
+  #  :force
+  #  :d
+  #  :ff
+  def clean(opts = T.unsafe(nil)); end
+
+  # commits all pending changes in the index file to the git repository
+  #
+  # options:
+  #   :all
+  #   :allow_empty
+  #   :amend
+  #   :author
+  def commit(message, opts = T.unsafe(nil)); end
+
+  # commits all pending changes in the index file to the git repository,
+  # but automatically adds all modified files without having to explicitly
+  # calling @git.add() on them.
+  def commit_all(message, opts = T.unsafe(nil)); end
+
+  # g.config('user.name', 'Scott Chacon') # sets value
+  # g.config('user.email', 'email@email.com')  # sets value
+  # g.config('user.email', 'email@email.com', file: 'path/to/custom/config)  # sets value in file
+  # g.config('user.name')  # returns 'Scott Chacon'
+  # g.config # returns whole config hash
+  def config(name = T.unsafe(nil), value = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # returns the name of the branch the working directory is currently on
+  def current_branch; end
+
+  # deletes a tag
+  def delete_tag(name); end
+
+  # returns the most recent tag that is reachable from a commit
+  #
+  # options:
+  #  :all
+  #  :tags
+  #  :contains
+  #  :debug
+  #  :exact_match
+  #  :dirty
+  #  :abbrev
+  #  :candidates
+  #  :long
+  #  :always
+  #  :match
+  def describe(committish = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # returns a reference to the working directory
+  #  @git.dir.path
+  #  @git.dir.writeable?
+  def dir; end
+
+  # iterates over the files which are unmerged
+  def each_conflict(&block); end
+
+  # fetches changes from a remote branch - this does not modify the working directory,
+  # it just gets the changes from the remote if there are any
+  def fetch(remote = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  def gc; end
+
+  # Run a grep for 'string' on the HEAD of the git repository
+  #
+  # @example Limit grep's scope by calling grep() from a specific object:
+  #   git.object("v2.3").grep('TODO')
+  # @example Using grep results:
+  #   git.grep("TODO").each do |sha, arr|
+  #   puts "in blob #{sha}:"
+  #   arr.each do |line_no, match_string|
+  #   puts "\t line #{line_no}: '#{match_string}'"
+  #   end
+  #   end
+  # @return [Hash<String, Array>] a hash of arrays
+  #   ```Ruby
+  #   {
+  #   'tree-ish1' => [[line_no1, match_string1], ...],
+  #   'tree-ish2' => [[line_no1, match_string1], ...],
+  #   ...
+  #   }
+  #   ```
+  def grep(string, path_limiter = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # returns reference to the git index file
+  def index; end
+
+  # returns +true+ if the branch exists
+  #
+  # @return [Boolean]
+  def is_branch?(branch); end
+
+  # returns +true+ if the branch exists locally
+  #
+  # @return [Boolean]
+  def is_local_branch?(branch); end
+
+  # returns +true+ if the branch exists remotely
+  #
+  # @return [Boolean]
+  def is_remote_branch?(branch); end
+
+  # this is a convenience method for accessing the class that wraps all the
+  # actual 'git' forked system calls.  At some point I hope to replace the Git::Lib
+  # class with one that uses native methods or libgit C bindings
+  def lib; end
+
+  def ls_files(location = T.unsafe(nil)); end
+  def ls_tree(objectish); end
+
+  # merges one or more branches into the current working branch
+  #
+  # you can specify more than one branch to merge by passing an array of branches
+  def merge(branch, message = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # Use git-merge-base https://git-scm.com/docs/git-merge-base to
+  # find as good common ancestors as possible for a merge
+  def merge_base(commit1, commit2, *other_commits); end
+
+  # pulls the given branch from the given remote into the current branch
+  #
+  #  @git.pull                          # pulls from origin/master
+  #  @git.pull('upstream')              # pulls from upstream/master
+  #  @git.pull('upstream', 'develope')  # pulls from upstream/develop
+  def pull(remote = T.unsafe(nil), branch = T.unsafe(nil)); end
+
+  # pushes changes to a remote repository - easiest if this is a cloned repository,
+  # otherwise you may have to run something like this first to setup the push parameters:
+  #
+  #  @git.config('remote.remote-name.push', 'refs/heads/master:refs/heads/master')
+  def push(remote = T.unsafe(nil), branch = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  def read_tree(treeish, opts = T.unsafe(nil)); end
+
+  # returns an array of Git:Remote objects
+  def remotes; end
+
+  # removes file(s) from the git repository
+  def remove(path = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # removes a remote from this repository
+  #
+  # @git.remove_remote('scott_git')
+  def remove_remote(name); end
+
+  # repacks the repository
+  def repack; end
+
+  # returns reference to the git repository directory
+  #  @git.dir.path
+  def repo; end
+
+  # returns the repository size in bytes
+  def repo_size; end
+
+  # resets the working directory to the provided commitish
+  def reset(commitish = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # resets the working directory to the commitish with '--hard'
+  def reset_hard(commitish = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # reverts the working directory to the provided commitish.
+  # Accepts a range, such as comittish..HEAD
+  #
+  # options:
+  #   :no_edit
+  def revert(commitish = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # runs git rev-parse to convert the objectish to a full sha
+  #
+  # @example
+  #   git.revparse("HEAD^^")
+  #   git.revparse('v2.4^{tree}')
+  #   git.revparse('v2.4:/doc/index.html')
+  def revparse(objectish); end
+
+  def set_index(index_file, check = T.unsafe(nil)); end
+
+  # sets the url for a remote
+  # url can be a git url or a Git::Base object if it's a local reference
+  #
+  #  @git.set_remote_url('scotts_git', 'git://repo.or.cz/rubygit.git')
+  def set_remote_url(name, url); end
+
+  def set_working(work_dir, check = T.unsafe(nil)); end
+
+  # Shows objects
+  #
+  # @param objectish [String|NilClass] the target object reference (nil == HEAD)
+  # @param path [String|NilClass] the path of the file to be shown
+  # @return [String] the object information
+  def show(objectish = T.unsafe(nil), path = T.unsafe(nil)); end
+
+  # returns an array of all Git::Tag objects for this repository
+  def tags; end
+
+  def update_ref(branch, commit); end
+
+  # LOWER LEVEL INDEX OPERATIONS ##
+  def with_index(new_index); end
+
+  def with_temp_index(&blk); end
+  def with_temp_working(&blk); end
+
+  # :yields: the Git::WorkingDirectory
+  def with_working(work_dir); end
+
+  def write_and_commit_tree(opts = T.unsafe(nil)); end
+  def write_tree; end
+
+  class << self
+    # Open a bare repository
+    #
+    # Opens a bare repository located in the `git_dir` directory.
+    # Since there is no working copy, you can not checkout or commit
+    # but you can do most read operations.
+    #
+    # @example Open a bare repository and retrieve the first commit SHA
+    #   repository = Git.bare('ruby-git.git')
+    #   puts repository.log[0].sha #=> "64c6fa011d3287bab9158049c85f3e85718854a0"
+    # @option options
+    # @param git_dir [Pathname] The path to the bare repository directory
+    #   containing an initialized Git repository. If a relative path is given, it
+    #   is converted to an absolute path using
+    #   [File.expand_path](https://www.rubydoc.info/stdlib/core/File.expand_path).
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the bare repository.
+    # @see https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefbarerepositoryabarerepository What is a bare repository?
+    def bare(git_dir, options = T.unsafe(nil)); end
+
+    # Clone a repository into an empty or newly created directory
+    #
+    # @example Clone into a different directory `my-ruby-git`
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', 'my-ruby-git')
+    #   # or:
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', path: 'my-ruby-git')
+    # @example Clone into the default directory `ruby-git`
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git')
+    # @example Create a bare repository in the directory `ruby-git.git`
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', bare: true)
+    # @example Clone and then checkout the `development` branch
+    #   git = Git.clone('https://github.com/ruby-git/ruby-git.git', branch: 'development')
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @param repository_url [URI, Pathname] The (possibly remote) repository url to clone
+    #   from. See [GIT URLS](https://git-scm.com/docs/git-clone#_git_urls_a_id_urls_a)
+    #   for more information.
+    # @param directory [Pathname, nil] The directory to clone into
+    #
+    #   If `directory` is a relative directory it is relative to the `path` option if
+    #   given. If `path` is not given, `directory` is relative to the current working
+    #   directory.
+    #
+    #   If `nil`, `directory` will be set to the basename of the last component of
+    #   the path from the `repository_url`. For example, for the URL:
+    #   `https://github.com/org/repo.git`, `directory` will be set to `repo`.
+    #
+    #   If the last component of the path is `.git`, the next-to-last component of
+    #   the path is used. For example, for the URL `/Users/me/foo/.git`, `directory`
+    #   will be set to `foo`.
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the cloned local working copy or cloned repository.
+    # @see https://git-scm.com/docs/git-clone git clone
+    # @see https://git-scm.com/docs/git-clone#_git_urls_a_id_urls_a GIT URLs
+    def clone(repository_url, directory, options = T.unsafe(nil)); end
+
+    # Returns (and initialize if needed) a Git::Config instance
+    #
+    # @return [Git::Config] the current config instance.
+    def config; end
+
+    # Create an empty Git repository or reinitialize an existing Git repository
+    #
+    # @example Initialize a repository in some other directory
+    #   git = Git.init '~/code/ruby-git'
+    # @example Initialize a bare repository
+    #   git = Git.init '~/code/ruby-git.git', bare: true
+    # @example Initialize a repository in the current directory
+    #   git = Git.init
+    # @example Initialize a repository in a non-default location (outside of the working copy)
+    #   git = Git.init '~/code/ruby-git', repository: '~/code/ruby-git.git'
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @param directory [Pathname] If the `:bare` option is NOT given or is not
+    #   `true`, the repository will be created in `"#{directory}/.git"`.
+    #   Otherwise, the repository is created in `"#{directory}"`.
+    #
+    #   All directories along the path to `directory` are created if they do not exist.
+    #
+    #   A relative path is referenced from the current working directory of the process
+    #   and converted to an absolute path using
+    #   [File.expand_path](https://www.rubydoc.info/stdlib/core/File.expand_path).
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the newly initialized repository
+    # @see https://git-scm.com/docs/git-init git init
+    def init(directory = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    # Open a an existing Git working directory
+    #
+    # Git.open will most likely be the most common way to create
+    # a git reference, referring to an existing working directory.
+    #
+    # If not provided in the options, the library will assume
+    # the repository and index are in the default places (`.git/`, `.git/index`).
+    #
+    # @example Open a Git working directory in some other directory
+    #   git = Git.open('~/Projects/ruby-git')
+    # @example Open the Git working directory in the current directory
+    #   git = Git.open
+    # @example Use a logger to see what is going on
+    #   logger = Logger.new(STDOUT)
+    #   git = Git.open('~/Projects/ruby-git', log: logger)
+    # @example Open a working copy whose repository is in a non-standard directory
+    #   git = Git.open('~/Projects/ruby-git', repository: '~/Project/ruby-git.git')
+    # @option options
+    # @option options
+    # @option options
+    # @param working_dir [Pathname] the path to the working directory to use
+    #   for git commands.
+    #
+    #   A relative path is referenced from the current working directory of the process
+    #   and converted to an absolute path using
+    #   [File.expand_path](https://www.rubydoc.info/stdlib/core/File.expand_path).
+    # @param options [Hash] The options for this command (see list of valid
+    #   options below)
+    # @return [Git::Base] an object that can execute git commands in the context
+    #   of the opened working copy
+    def open(working_dir, options = T.unsafe(nil)); end
+
+    private
+
+    # Normalize options[:index]
+    #
+    # If options[:index] is a relative directory, convert it to an absolute
+    # directory relative to the repository directory
+    def normalize_index(options); end
+
+    # Normalize options before they are sent to Git::Base.new
+    #
+    # Updates the options parameter by setting appropriate values for the following keys:
+    #   * options[:working_directory]
+    #   * options[:repository]
+    #   * options[:index]
+    #
+    # All three values will be set to absolute paths. An exception is that
+    # :working_directory will be set to nil if bare is true.
+    def normalize_paths(options, default_working_directory: T.unsafe(nil), default_repository: T.unsafe(nil), bare: T.unsafe(nil)); end
+
+    # Normalize options[:repository]
+    #
+    # If working with a bare repository, set to the first non-nil value out of:
+    #   1. `options[:repository]`
+    #   2. the `default` parameter
+    #   3. the current working directory
+    #
+    # Otherwise, set to the first non-nil value of:
+    #   1. `options[:repository]`
+    #   2. `.git`
+    #
+    # Next, if options[:repository] refers to a *file* and not a *directory*, set
+    # options[:repository] to the contents of that file.  This is the case when
+    # working with a submodule or a secondary working tree (created with git worktree
+    # add). In these cases the repository is actually contained/nested within the
+    # parent's repository directory.
+    #
+    # Finally, if options[:repository] is a relative path, convert it to an absolute
+    # path relative to:
+    #   1. the current directory if working with a bare repository or
+    #   2. the working directory if NOT working with a bare repository
+    def normalize_repository(options, default:, bare: T.unsafe(nil)); end
+
+    # Normalize options[:working_directory]
+    #
+    # If working with a bare repository, set to `nil`.
+    # Otherwise, set to the first non-nil value of:
+    #   1. `options[:working_directory]`,
+    #   2. the `default` parameter, or
+    #   3. the current working directory
+    #
+    # Finally, if options[:working_directory] is a relative path, convert it to an absoluite
+    # path relative to the current directory.
+    def normalize_working_directory(options, default:, bare: T.unsafe(nil)); end
+  end
+end
+
+module Git::Base::Factory
+  # @return [Git::Branch] an object for branch_name
+  def branch(branch_name = T.unsafe(nil)); end
+
+  # @return [Git::Branches] a collection of all the branches in the repository.
+  #   Each branch is represented as a {Git::Branch}.
+  def branches; end
+
+  # @return [Git::Object::Commit] a commit object
+  def commit_tree(tree = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # @return [Git::Diff] a Git::Diff object
+  def diff(objectish = T.unsafe(nil), obj2 = T.unsafe(nil)); end
+
+  # @return [Git::Object] a Git object
+  def gblob(objectish); end
+
+  # @return [Git::Object] a Git object
+  def gcommit(objectish); end
+
+  # @return [Git::Object] a Git object
+  def gtree(objectish); end
+
+  # @return [Git::Log] a log with the specified number of commits
+  def log(count = T.unsafe(nil)); end
+
+  # Find as good common ancestors as possible for a merge
+  # example: g.merge_base('master', 'some_branch', 'some_sha', octopus: true)
+  #
+  # @return [Array<Git::Object::Commit>] a collection of common ancestors
+  def merge_base(*args); end
+
+  # returns a Git::Object of the appropriate type
+  # you can also call @git.gtree('tree'), but that's
+  # just for readability.  If you call @git.gtree('HEAD') it will
+  # still return a Git::Object::Commit object.
+  #
+  # object calls a factory method that will run a rev-parse
+  # on the objectish and determine the type of the object and return
+  # an appropriate object for that type
+  #
+  # @return [Git::Object] an instance of the appropriate type of Git::Object
+  def object(objectish); end
+
+  # @return [Git::Remote] a remote of the specified name
+  def remote(remote_name = T.unsafe(nil)); end
+
+  # @return [Git::Status] a status object
+  def status; end
+
+  # @return [Git::Object::Tag] a tag object
+  def tag(tag_name); end
+
+  # returns a Git::Worktree object for dir, commitish
+  def worktree(dir, commitish = T.unsafe(nil)); end
+
+  # returns a Git::worktrees object of all the Git::Worktrees
+  # objects for this repo
+  def worktrees; end
+end
+
+class Git::Branch < ::Git::Path
+  # @return [Branch] a new instance of Branch
+  def initialize(base, name); end
+
+  def archive(file, opts = T.unsafe(nil)); end
+  def checkout; end
+
+  # @return [Boolean]
+  def contains?(commit); end
+
+  def create; end
+  def current; end
+  def delete; end
+
+  # Returns the value of attribute full.
+  def full; end
+
+  # Sets the attribute full
+  #
+  # @param value the value to set the attribute full to.
+  def full=(_arg0); end
+
+  def gcommit; end
+
+  # g.branch('new_branch').in_branch do
+  #   # create new file
+  #   # do other stuff
+  #   return true # auto commits and switches back
+  # end
+  def in_branch(message = T.unsafe(nil)); end
+
+  def merge(branch = T.unsafe(nil), message = T.unsafe(nil)); end
+
+  # Returns the value of attribute name.
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value the value to set the attribute name to.
+  def name=(_arg0); end
+
+  # Returns the value of attribute remote.
+  def remote; end
+
+  # Sets the attribute remote
+  #
+  # @param value the value to set the attribute remote to.
+  def remote=(_arg0); end
+
+  def stashes; end
+  def to_a; end
+  def to_s; end
+  def update_ref(commit); end
+
+  private
+
+  def check_if_create; end
+  def determine_current; end
+
+  # Given a full branch name return an Array containing the remote and branch names.
+  #
+  # Removes 'remotes' from the beggining of the name (if present).
+  # Takes the second part (splittign by '/') as the remote name.
+  # Takes the rest as the repo name (can also hold one or more '/').
+  #
+  # Example:
+  #   parse_name('master') #=> [nil, 'master']
+  #   parse_name('origin/master') #=> ['origin', 'master']
+  #   parse_name('remotes/origin/master') #=> ['origin', 'master']
+  #   parse_name('origin/master/v2') #=> ['origin', 'master/v2']
+  #
+  # param [String] name branch full name.
+  # return [<Git::Remote,NilClass,String>] an Array containing the remote and branch names.
+  def parse_name(name); end
+end
+
+# object that holds all the available branches
+class Git::Branches
+  include ::Enumerable
+
+  # @return [Branches] a new instance of Branches
+  def initialize(base); end
+
+  # Returns the target branch
+  #
+  # Example:
+  #   Given (git branch -a):
+  #    master
+  #    remotes/working/master
+  #
+  #   g.branches['master'].full #=> 'master'
+  #   g.branches['working/master'].full => 'remotes/working/master'
+  #   g.branches['remotes/working/master'].full => 'remotes/working/master'
+  #
+  # @param branch_name [#to_s] the target branch name.
+  # @return [Git::Branch] the target branch.
+  def [](branch_name); end
+
+  def each(&block); end
+  def local; end
+  def remote; end
+
+  # array like methods
+  def size; end
+
+  def to_s; end
+end
+
+class Git::Config
+  # @return [Config] a new instance of Config
+  def initialize; end
+
+  def binary_path; end
+
+  # Sets the attribute binary_path
+  #
+  # @param value the value to set the attribute binary_path to.
+  def binary_path=(_arg0); end
+
+  def git_ssh; end
+
+  # Sets the attribute git_ssh
+  #
+  # @param value the value to set the attribute git_ssh to.
+  def git_ssh=(_arg0); end
+end
+
+# object that holds the last X commits on given branch
+class Git::Diff
+  include ::Enumerable
+
+  # @return [Diff] a new instance of Diff
+  def initialize(base, from = T.unsafe(nil), to = T.unsafe(nil)); end
+
+  # enumerable methods
+  def [](key); end
+
+  def deletions; end
+
+  # :yields: each Git::DiffFile in turn
+  def each(&block); end
+
+  # Returns the value of attribute from.
+  def from; end
+
+  def insertions; end
+  def lines; end
+  def name_status; end
+
+  # if file is provided and is writable, it will write the patch into the file
+  def patch(file = T.unsafe(nil)); end
+
+  def path(path); end
+  def size; end
+  def stats; end
+
+  # Returns the value of attribute to.
+  def to; end
+
+  # if file is provided and is writable, it will write the patch into the file
+  def to_s(file = T.unsafe(nil)); end
+
+  private
+
+  def cache_full; end
+  def cache_name_status; end
+  def cache_stats; end
+  def process_full; end
+
+  # break up @diff_full
+  def process_full_diff; end
+end
+
+class Git::Diff::DiffFile
+  # @return [DiffFile] a new instance of DiffFile
+  def initialize(base, hash); end
+
+  # @return [Boolean]
+  def binary?; end
+
+  def blob(type = T.unsafe(nil)); end
+
+  # Returns the value of attribute dst.
+  def dst; end
+
+  # Sets the attribute dst
+  #
+  # @param value the value to set the attribute dst to.
+  def dst=(_arg0); end
+
+  # Returns the value of attribute mode.
+  def mode; end
+
+  # Sets the attribute mode
+  #
+  # @param value the value to set the attribute mode to.
+  def mode=(_arg0); end
+
+  # Returns the value of attribute patch.
+  def patch; end
+
+  # Sets the attribute patch
+  #
+  # @param value the value to set the attribute patch to.
+  def patch=(_arg0); end
+
+  # Returns the value of attribute path.
+  def path; end
+
+  # Sets the attribute path
+  #
+  # @param value the value to set the attribute path to.
+  def path=(_arg0); end
+
+  # Returns the value of attribute src.
+  def src; end
+
+  # Sets the attribute src
+  #
+  # @param value the value to set the attribute src to.
+  def src=(_arg0); end
+
+  # Returns the value of attribute type.
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value the value to set the attribute type to.
+  def type=(_arg0); end
+end
+
+Git::Diff::DiffFile::NIL_BLOB_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# Method that can be used to detect and normalize string encoding
+module Git::EncodingUtils
+  class << self
+    def best_guess_encoding; end
+    def default_encoding; end
+    def detected_encoding(str); end
+    def encoding_options; end
+    def normalize_encoding(str); end
+  end
+end
+
+# Represents an escaped Git path string
+#
+# Git commands that output paths (e.g. ls-files, diff), will escape usual
+# characters in the path with backslashes in the same way C escapes control
+# characters (e.g. \t for TAB, \n for LF, \\ for backslash) or bytes with values
+# larger than 0x80 (e.g. octal \302\265 for "micro" in UTF-8).
+#
+# @example
+#   Git::GitPath.new('\302\265').unescape # => "µ"
+class Git::EscapedPath
+  # @return [EscapedPath] a new instance of EscapedPath
+  def initialize(path); end
+
+  # Returns the value of attribute path.
+  def path; end
+
+  # Convert an escaped path to an unescaped path
+  def unescape; end
+
+  private
+
+  def escaped_path_to_bytes(path); end
+  def extract_escape(path, index); end
+  def extract_octal(path, index); end
+  def extract_single_char(path, index); end
+  def next_byte(path, index); end
+end
+
+Git::EscapedPath::UNESCAPES = T.let(T.unsafe(nil), Hash)
+
+# The URI for git's alternative scp-like syntax
+#
+# This class is necessary to ensure that #to_s returns the same string
+# that was passed to the initializer.
+#
+# @api public
+class Git::GitAltURI < ::Addressable::URI
+  # Create a new GitAltURI object
+  #
+  # @api public
+  # @example
+  #   uri = Git::GitAltURI.new(user: 'james', host: 'github.com', path: 'james/ruby-git')
+  #   uri.to_s #=> 'james@github.com/james/ruby-git'
+  # @param user [String, nil] the user from the URL or nil
+  # @param host [String] the host from the URL
+  # @param path [String] the path from the URL
+  # @return [GitAltURI] a new instance of GitAltURI
+  def initialize(user:, host:, path:); end
+
+  # Convert the URI to a String
+  #
+  # Addressible::URI forces path to be absolute by prepending a '/' to the
+  # path. This method removes the '/' when converting back to a string
+  # since that is what is expected by git. The following is a valid git URL:
+  #
+  #  `james@github.com:ruby-git/ruby-git.git`
+  #
+  # and the following (with the initial '/'' in the path) is NOT a valid git URL:
+  #
+  #  `james@github.com:/ruby-git/ruby-git.git`
+  #
+  # @api public
+  # @example
+  #   uri = Git::GitAltURI.new(user: 'james', host: 'github.com', path: 'james/ruby-git')
+  #   uri.path #=> '/james/ruby-git'
+  #   uri.to_s #=> 'james@github.com:james/ruby-git'
+  # @return [String] the URI as a String
+  def to_s; end
+end
+
+class Git::GitExecuteError < ::StandardError; end
+class Git::GitTagNameDoesNotExist < ::StandardError; end
+class Git::Index < ::Git::Path; end
+
+class Git::Lib
+  # Create a new Git::Lib object
+  #
+  # @option base
+  # @option base
+  # @option base
+  # @param base [Git::Base, Hash] An object that passes in values for
+  #   @git_work_dir, @git_dir, and @git_index_file
+  # @param logger [Logger]
+  # @return [Lib] a new instance of Lib
+  def initialize(base = T.unsafe(nil), logger = T.unsafe(nil)); end
+
+  # updates the repository index using the working directory content
+  #
+  #    lib.add('path/to/file')
+  #    lib.add(['path/to/file1','path/to/file2'])
+  #    lib.add(:all => true)
+  #
+  # options:
+  #   :all => true
+  #   :force => true
+  #
+  # @param paths [String, Array] files paths to be added to the repository
+  # @param options [Hash]
+  def add(paths = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  def apply(patch_file); end
+  def apply_mail(patch_file); end
+
+  # creates an archive file
+  #
+  # options
+  #  :format  (zip, tar)
+  #  :prefix
+  #  :remote
+  #  :path
+  def archive(sha, file = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  def branch_contains(commit, branch_name = T.unsafe(nil)); end
+  def branch_current; end
+  def branch_delete(branch); end
+  def branch_new(branch); end
+  def branches_all; end
+  def change_head_branch(branch_name); end
+  def checkout(branch, opts = T.unsafe(nil)); end
+  def checkout_file(version, file); end
+  def checkout_index(opts = T.unsafe(nil)); end
+  def clean(opts = T.unsafe(nil)); end
+
+  # tries to clone the given repo
+  #
+  # accepts options:
+  #  :bare::      no working directory
+  #  :branch::    name of branch to track (rather than 'master')
+  #  :depth::     the number of commits back to pull
+  #  :origin::    name of remote (same as remote)
+  #  :path::      directory where the repo will be cloned
+  #  :remote::    name of remote (rather than 'origin')
+  #  :recursive:: after the clone is created, initialize all submodules within, using their default settings.
+  #
+  # TODO - make this work with SSH password or auth_key
+  #
+  # @return [Hash] the options to pass to {Git::Base.new}
+  def clone(repository_url, directory, opts = T.unsafe(nil)); end
+
+  # Takes the commit message with the options and executes the commit command
+  #
+  # accepts options:
+  #  :amend
+  #  :all
+  #  :allow_empty
+  #  :author
+  #  :date
+  #  :no_verify
+  #  :allow_empty_message
+  #  :gpg_sign (accepts true or a gpg key ID as a String)
+  #  :no_gpg_sign (conflicts with :gpg_sign)
+  #
+  # @param message [String] the commit message to be used
+  # @param opts [Hash] the commit options to be used
+  def commit(message, opts = T.unsafe(nil)); end
+
+  # returns useful array of raw commit object data
+  def commit_data(sha); end
+
+  def commit_tree(tree, opts = T.unsafe(nil)); end
+  def config_get(name); end
+  def config_list; end
+  def config_remote(name); end
+
+  # WRITE COMMANDS ##
+  def config_set(name, value, options = T.unsafe(nil)); end
+
+  # :yields: file, your, their
+  def conflicts; end
+
+  # returns the current version of git, as an Array of Fixnums.
+  def current_command_version; end
+
+  # Returns most recent tag that is reachable from a commit
+  #
+  # accepts options:
+  #  :all
+  #  :tags
+  #  :contains
+  #  :debug
+  #  :exact_match
+  #  :dirty
+  #  :abbrev
+  #  :candidates
+  #  :long
+  #  :always
+  #  :math
+  #
+  #  @param [String|NilClass] committish target commit sha or object name
+  #  @param [{Symbol=>Object}] opts the given options
+  #  @return [String] the tag name
+  def describe(committish = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # compares the index and the working directory
+  def diff_files; end
+
+  def diff_full(obj1 = T.unsafe(nil), obj2 = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # compares the index and the repository
+  def diff_index(treeish); end
+
+  def diff_name_status(reference1 = T.unsafe(nil), reference2 = T.unsafe(nil), opts = T.unsafe(nil)); end
+  def diff_stats(obj1 = T.unsafe(nil), obj2 = T.unsafe(nil), opts = T.unsafe(nil)); end
+  def fetch(remote, opts); end
+  def full_log_commits(opts = T.unsafe(nil)); end
+  def full_tree(sha); end
+  def gc; end
+
+  # The path to the Git repository directory.  The default is
+  # `"#{git_work_dir}/.git"`.
+  #
+  # @return [Pathname] the Git repository directory.
+  # @see [Git repository](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefrepositoryarepository)
+  def git_dir; end
+
+  # The Git index file used to stage changes (using `git add`) before they
+  # are committed.
+  #
+  # @return [Pathname] the Git index file
+  # @see [Git index file](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefindexaindex)
+  def git_index_file; end
+
+  # The path to the Git working copy.  The default is '"./.git"'.
+  #
+  # @return [Pathname] the path to the Git working copy.
+  # @see [Git working tree](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefworkingtreeaworkingtree)
+  def git_work_dir; end
+
+  def global_config_get(name); end
+  def global_config_list; end
+  def global_config_set(name, value); end
+
+  # returns hash
+  # [tree-ish] = [[line_no, match], [line_no, match2]]
+  # [tree-ish] = [[line_no, match], [line_no, match2]]
+  def grep(string, opts = T.unsafe(nil)); end
+
+  def ignored_files; end
+
+  # creates or reinitializes the repository
+  #
+  # options:
+  #   :bare
+  #   :working_directory
+  #   :initial_branch
+  def init(opts = T.unsafe(nil)); end
+
+  def list_files(ref_dir); end
+  def log_commits(opts = T.unsafe(nil)); end
+  def ls_files(location = T.unsafe(nil)); end
+  def ls_remote(location = T.unsafe(nil), opts = T.unsafe(nil)); end
+  def ls_tree(sha); end
+
+  # @return [Boolean]
+  def meets_required_version?; end
+
+  def merge(branch, message = T.unsafe(nil), opts = T.unsafe(nil)); end
+  def merge_base(*args); end
+  def mv(file1, file2); end
+  def namerev(string); end
+  def object_contents(sha, &block); end
+  def object_size(sha); end
+  def object_type(sha); end
+  def parse_config(file); end
+  def parse_config_list(lines); end
+  def process_commit_data(data, sha = T.unsafe(nil), indent = T.unsafe(nil)); end
+  def process_commit_log_data(data); end
+  def process_tag_data(data, name, indent = T.unsafe(nil)); end
+  def pull(remote = T.unsafe(nil), branch = T.unsafe(nil)); end
+  def push(remote, branch = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # reads a tree into the current index file
+  def read_tree(treeish, opts = T.unsafe(nil)); end
+
+  def remote_add(name, url, opts = T.unsafe(nil)); end
+  def remote_remove(name); end
+  def remote_set_url(name, url); end
+  def remotes; end
+  def remove(path = T.unsafe(nil), opts = T.unsafe(nil)); end
+  def repack; end
+  def required_command_version; end
+  def reset(commit, opts = T.unsafe(nil)); end
+  def return_base_opts_from_clone(clone_dir, opts); end
+  def revert(commitish, opts = T.unsafe(nil)); end
+  def revparse(string); end
+
+  # Shows objects
+  #
+  # @param objectish [String|NilClass] the target object reference (nil == HEAD)
+  # @param path [String|NilClass] the path of the file to be shown
+  # @return [String] the object information
+  def show(objectish = T.unsafe(nil), path = T.unsafe(nil)); end
+
+  def stash_apply(id = T.unsafe(nil)); end
+  def stash_clear; end
+  def stash_list; end
+  def stash_save(message); end
+  def stashes_all; end
+  def tag(name, *opts); end
+  def tag_data(name); end
+  def tag_sha(tag_name); end
+  def tags; end
+  def tree_depth(sha); end
+  def unmerged; end
+  def update_ref(branch, commit); end
+  def worktree_add(dir, commitish = T.unsafe(nil)); end
+  def worktree_prune; end
+  def worktree_remove(dir); end
+  def worktrees_all; end
+  def write_tree; end
+
+  private
+
+  # @raise [Git::GitExecuteError]
+  def command(cmd, *opts, &block); end
+
+  def command_lines(cmd, *opts); end
+
+  # Takes the diff command line output (as Array) and parse it into a Hash
+  #
+  # @param diff_command [String] the diff commadn to be used
+  # @param opts [Array] the diff options to be used
+  # @return [Hash] the diff as Hash
+  def diff_as_hash(diff_command, opts = T.unsafe(nil)); end
+
+  def escape(s); end
+  def escape_for_sh(s); end
+  def escape_for_windows(s); end
+
+  # Returns an array holding the common options for the log commands
+  #
+  # @param opts [Hash] the given options
+  # @return [Array] the set of common options that the log command will use
+  def log_common_options(opts); end
+
+  # Retrurns an array holding path options for the log commands
+  #
+  # @param opts [Hash] the given options
+  # @return [Array] the set of path options that the log command will use
+  def log_path_options(opts); end
+
+  # Takes the previously stored git's ENV variables and set them again on ENV.
+  def restore_git_system_env_variables; end
+
+  def run_command(git_cmd, &block); end
+
+  # Sets git's ENV variables to the custom values for the current instance.
+  def set_custom_git_env_variables; end
+
+  # Takes the current git's system ENV variables and store them.
+  def store_git_system_env_variables; end
+
+  # @return [Boolean]
+  def windows_platform?; end
+
+  # Runs a block inside an environment with customized ENV variables.
+  # It restores the ENV after execution.
+  #
+  # @param block [Proc] block to be executed within the customized environment
+  def with_custom_env_variables(&block); end
+end
+
+# Systen ENV variables involved in the git commands.
+#
+# @return [<String>] the names of the EVN variables involved in the git commands
+Git::Lib::ENV_VARIABLE_NAMES = T.let(T.unsafe(nil), Array)
+
+# object that holds the last X commits on given branch
+class Git::Log
+  include ::Enumerable
+
+  # @return [Log] a new instance of Log
+  def initialize(base, count = T.unsafe(nil)); end
+
+  def [](index); end
+  def author(regex); end
+  def between(sha1, sha2 = T.unsafe(nil)); end
+  def cherry; end
+  def each(&block); end
+  def first; end
+  def grep(regex); end
+  def last; end
+  def object(objectish); end
+  def path(path); end
+  def since(date); end
+
+  # forces git log to run
+  def size; end
+
+  def skip(num); end
+  def to_s; end
+  def until(date); end
+
+  private
+
+  def check_log; end
+  def dirty_log; end
+
+  # actually run the 'git log' command
+  def run_log; end
+end
+
+# represents a git object
+class Git::Object
+  class << self
+    # if we're calling this, we don't know what type it is yet
+    # so this is our little factory method
+    def new(base, objectish, type = T.unsafe(nil), is_tag = T.unsafe(nil)); end
+  end
+end
+
+class Git::Object::AbstractObject
+  # @return [AbstractObject] a new instance of AbstractObject
+  def initialize(base, objectish); end
+
+  # creates an archive of this object (tree)
+  def archive(file = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  def blob?; end
+
+  # @return [Boolean]
+  def commit?; end
+
+  # Get the object's contents.
+  # If no block is given, the contents are cached in memory and returned as a string.
+  # If a block is given, it yields an IO object (via IO::popen) which could be used to
+  # read a large file in chunks.
+  #
+  # Use this for large files so that they are not held in memory.
+  def contents(&block); end
+
+  def contents_array; end
+  def diff(objectish); end
+  def grep(string, path_limiter = T.unsafe(nil), opts = T.unsafe(nil)); end
+  def log(count = T.unsafe(nil)); end
+
+  # Returns the value of attribute mode.
+  def mode; end
+
+  # Sets the attribute mode
+  #
+  # @param value the value to set the attribute mode to.
+  def mode=(_arg0); end
+
+  # Returns the value of attribute objectish.
+  def objectish; end
+
+  # Sets the attribute objectish
+  #
+  # @param value the value to set the attribute objectish to.
+  def objectish=(_arg0); end
+
+  def sha; end
+  def size; end
+
+  # Sets the attribute size
+  #
+  # @param value the value to set the attribute size to.
+  def size=(_arg0); end
+
+  # @return [Boolean]
+  def tag?; end
+
+  def to_s; end
+
+  # @return [Boolean]
+  def tree?; end
+
+  # Returns the value of attribute type.
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value the value to set the attribute type to.
+  def type=(_arg0); end
+end
+
+class Git::Object::Blob < ::Git::Object::AbstractObject
+  # @return [Blob] a new instance of Blob
+  def initialize(base, sha, mode = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  def blob?; end
+end
+
+class Git::Object::Commit < ::Git::Object::AbstractObject
+  # @return [Commit] a new instance of Commit
+  def initialize(base, sha, init = T.unsafe(nil)); end
+
+  # git author
+  def author; end
+
+  def author_date; end
+
+  # @return [Boolean]
+  def commit?; end
+
+  # git author
+  def committer; end
+
+  def committer_date; end
+  def date; end
+  def diff_parent; end
+  def gtree; end
+  def message; end
+  def name; end
+  def parent; end
+
+  # array of all parent commits
+  def parents; end
+
+  def set_commit(data); end
+
+  private
+
+  # see if this object has been initialized and do so if not
+  def check_commit; end
+end
+
+class Git::Object::Tag < ::Git::Object::AbstractObject
+  # @return [Tag] a new instance of Tag
+  def initialize(base, sha, name); end
+
+  # @return [Boolean]
+  def annotated?; end
+
+  def message; end
+
+  # Returns the value of attribute name.
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value the value to set the attribute name to.
+  def name=(_arg0); end
+
+  # @return [Boolean]
+  def tag?; end
+
+  def tagger; end
+
+  private
+
+  def check_tag; end
+end
+
+class Git::Object::Tree < ::Git::Object::AbstractObject
+  # @return [Tree] a new instance of Tree
+  def initialize(base, sha, mode = T.unsafe(nil)); end
+
+  def blobs; end
+  def children; end
+  def depth; end
+  def files; end
+  def full_tree; end
+  def subdirectories; end
+  def subtrees; end
+
+  # @return [Boolean]
+  def tree?; end
+
+  def trees; end
+
+  private
+
+  # actually run the git command
+  def check_tree; end
+end
+
+class Git::Path
+  # @return [Path] a new instance of Path
+  def initialize(path, check_path = T.unsafe(nil)); end
+
+  # Returns the value of attribute path.
+  def path; end
+
+  # Sets the attribute path
+  #
+  # @param value the value to set the attribute path to.
+  def path=(_arg0); end
+
+  # @return [Boolean]
+  def readable?; end
+
+  def to_s; end
+
+  # @return [Boolean]
+  def writable?; end
+end
+
+class Git::Remote < ::Git::Path
+  # @return [Remote] a new instance of Remote
+  def initialize(base, name); end
+
+  def branch(branch = T.unsafe(nil)); end
+  def fetch(opts = T.unsafe(nil)); end
+
+  # Returns the value of attribute fetch_opts.
+  def fetch_opts; end
+
+  # Sets the attribute fetch_opts
+  #
+  # @param value the value to set the attribute fetch_opts to.
+  def fetch_opts=(_arg0); end
+
+  # merge this remote locally
+  def merge(branch = T.unsafe(nil)); end
+
+  # Returns the value of attribute name.
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value the value to set the attribute name to.
+  def name=(_arg0); end
+
+  def remove; end
+  def to_s; end
+
+  # Returns the value of attribute url.
+  def url; end
+
+  # Sets the attribute url
+  #
+  # @param value the value to set the attribute url to.
+  def url=(_arg0); end
+end
+
+class Git::Repository < ::Git::Path; end
+
+class Git::Stash
+  # @return [Stash] a new instance of Stash
+  def initialize(base, message, existing = T.unsafe(nil)); end
+
+  def message; end
+  def save; end
+
+  # @return [Boolean]
+  def saved?; end
+
+  def to_s; end
+end
+
+# object that holds all the available stashes
+class Git::Stashes
+  include ::Enumerable
+
+  # @return [Stashes] a new instance of Stashes
+  def initialize(base); end
+
+  def [](index); end
+
+  # Returns an multi-dimensional Array of elements that have been stash saved.
+  # Array is based on position and name. See Example
+  #
+  # @example Returns Array of items that have been stashed
+  #   .all - [0, "testing-stash-all"]]
+  # @return [Array]
+  def all; end
+
+  def apply(index = T.unsafe(nil)); end
+  def clear; end
+  def each(&block); end
+  def save(message); end
+  def size; end
+end
+
+# A class for git status
+class Git::Status
+  include ::Enumerable
+
+  # @return [Status] a new instance of Status
+  def initialize(base); end
+
+  # enumerable method
+  def [](file); end
+
+  # Returns an Enumerable containing files that have been added.
+  # File path starts at git base directory
+  #
+  # @return [Enumerable]
+  def added; end
+
+  # Determines whether the given file has been added to the repository
+  # File path starts at git base directory
+  #
+  # @example Check if lib/git.rb is added.
+  #   added?('lib/git.rb')
+  # @param file [String] The name of the file.
+  # @return [Boolean]
+  def added?(file); end
+
+  # Returns an Enumerable containing files that have changed from the
+  # git base directory
+  #
+  # @return [Enumerable]
+  def changed; end
+
+  # Determines whether the given file has been changed.
+  # File path starts at git base directory
+  #
+  # @example Check if lib/git.rb has changed.
+  #   changed?('lib/git.rb')
+  # @param file [String] The name of the file.
+  # @return [Boolean]
+  def changed?(file); end
+
+  # Returns an Enumerable containing files that have been deleted.
+  # File path starts at git base directory
+  #
+  # @return [Enumerable]
+  def deleted; end
+
+  # Determines whether the given file has been deleted from the repository
+  # File path starts at git base directory
+  #
+  # @example Check if lib/git.rb is deleted.
+  #   deleted?('lib/git.rb')
+  # @param file [String] The name of the file.
+  # @return [Boolean]
+  def deleted?(file); end
+
+  def each(&block); end
+  def pretty; end
+  def pretty_file(file); end
+
+  # Returns an Enumerable containing files that are not tracked in git.
+  # File path starts at git base directory
+  #
+  # @return [Enumerable]
+  def untracked; end
+
+  # Determines whether the given file has is tracked by git.
+  # File path starts at git base directory
+  #
+  # @example Check if lib/git.rb is an untracked file.
+  #   untracked?('lib/git.rb')
+  # @param file [String] The name of the file.
+  # @return [Boolean]
+  def untracked?(file); end
+
+  private
+
+  def construct_status; end
+  def fetch_added; end
+  def fetch_modified; end
+  def fetch_untracked; end
+end
+
+# subclass that does heavy lifting
+class Git::Status::StatusFile
+  # @return [StatusFile] a new instance of StatusFile
+  def initialize(base, hash); end
+
+  def blob(type = T.unsafe(nil)); end
+
+  # Returns the value of attribute mode_index.
+  def mode_index; end
+
+  # Sets the attribute mode_index
+  #
+  # @param value the value to set the attribute mode_index to.
+  def mode_index=(_arg0); end
+
+  # Returns the value of attribute mode_repo.
+  def mode_repo; end
+
+  # Sets the attribute mode_repo
+  #
+  # @param value the value to set the attribute mode_repo to.
+  def mode_repo=(_arg0); end
+
+  # Returns the value of attribute path.
+  def path; end
+
+  # Sets the attribute path
+  #
+  # @param value the value to set the attribute path to.
+  def path=(_arg0); end
+
+  # Returns the value of attribute sha_index.
+  def sha_index; end
+
+  # Sets the attribute sha_index
+  #
+  # @param value the value to set the attribute sha_index to.
+  def sha_index=(_arg0); end
+
+  # Returns the value of attribute sha_repo.
+  def sha_repo; end
+
+  # Sets the attribute sha_repo
+  #
+  # @param value the value to set the attribute sha_repo to.
+  def sha_repo=(_arg0); end
+
+  # Returns the value of attribute stage.
+  def stage; end
+
+  # Sets the attribute stage
+  #
+  # @param value the value to set the attribute stage to.
+  def stage=(_arg0); end
+
+  # Returns the value of attribute type.
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value the value to set the attribute type to.
+  def type=(_arg0); end
+
+  # Returns the value of attribute untracked.
+  def untracked; end
+
+  # Sets the attribute untracked
+  #
+  # @param value the value to set the attribute untracked to.
+  def untracked=(_arg0); end
+end
+
+# Methods for parsing a Git URL
+#
+# Any URL that can be passed to `git clone` can be parsed by this class.
+#
+# @api public
+# @see https://git-scm.com/docs/git-clone#_git_urls GIT URLs
+# @see https://github.com/sporkmonger/addressable Addresable::URI
+class Git::URL
+  class << self
+    # The directory `git clone` would use for the repository directory for the given URL
+    #
+    # @api public
+    # @example
+    #   Git::URL.clone_to('https://github.com/ruby-git/ruby-git.git') #=> 'ruby-git'
+    # @param url [String] the Git URL containing the repository directory
+    # @return [String] the name of the repository directory
+    def clone_to(url, bare: T.unsafe(nil), mirror: T.unsafe(nil)); end
+
+    # Parse a Git URL and return an Addressable::URI object
+    #
+    # The URI returned can be converted back to a string with 'to_s'. This is
+    # guaranteed to return the same URL string that was parsed.
+    #
+    # @api public
+    # @example
+    #   uri = Git::URL.parse('https://github.com/ruby-git/ruby-git.git')
+    #   #=> #<Addressable::URI:0x44c URI:https://github.com/ruby-git/ruby-git.git>
+    #   uri.scheme #=> "https"
+    #   uri.host #=> "github.com"
+    #   uri.path #=> "/ruby-git/ruby-git.git"
+    #
+    #   Git::URL.parse('/Users/James/projects/ruby-git')
+    #   #=> #<Addressable::URI:0x438 URI:/Users/James/projects/ruby-git>
+    # @param url [String] the Git URL to parse
+    # @return [Addressable::URI] the parsed URI
+    def parse(url); end
+  end
+end
+
+# Regexp used to match a Git URL with an alternative SSH syntax
+# such as `user@host:path`
+#
+# @api public
+Git::URL::GIT_ALTERNATIVE_SSH_SYNTAX = T.let(T.unsafe(nil), Regexp)
+
+# The current gem version
+#
+# @return [String] the current gem version.
+Git::VERSION = T.let(T.unsafe(nil), String)
+
+class Git::WorkingDirectory < ::Git::Path; end
+
+class Git::Worktree < ::Git::Path
+  # @return [Worktree] a new instance of Worktree
+  def initialize(base, dir, gcommit = T.unsafe(nil)); end
+
+  def add; end
+
+  # Returns the value of attribute dir.
+  def dir; end
+
+  # Sets the attribute dir
+  #
+  # @param value the value to set the attribute dir to.
+  def dir=(_arg0); end
+
+  # Returns the value of attribute full.
+  def full; end
+
+  # Sets the attribute full
+  #
+  # @param value the value to set the attribute full to.
+  def full=(_arg0); end
+
+  # Returns the value of attribute gcommit.
+  def gcommit; end
+
+  # Sets the attribute gcommit
+  #
+  # @param value the value to set the attribute gcommit to.
+  def gcommit=(_arg0); end
+
+  def remove; end
+  def to_a; end
+  def to_s; end
+end
+
+# object that holds all the available worktrees
+class Git::Worktrees
+  include ::Enumerable
+
+  # @return [Worktrees] a new instance of Worktrees
+  def initialize(base); end
+
+  def [](worktree_name); end
+  def each(&block); end
+  def prune; end
+
+  # array like methods
+  def size; end
+
+  def to_s; end
+end