;;; magit-autoloads.el --- automatically extracted autoloads (do not edit)   -*- lexical-binding: t -*-
;; Generated by the `loaddefs-generate' function.

;; This file is part of GNU Emacs.

;;; Code:

(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))



;;; Generated autoloads from git-commit.el

(put 'git-commit-major-mode 'safe-local-variable
    (lambda (val)
      (memq val '(text-mode
                  markdown-mode
                  org-mode
                  fundamental-mode
                  log-edit-mode
                  git-commit-elisp-text-mode))))
(autoload 'git-commit-insert-changelog-gnu "git-commit" "\
Insert a GNU-style changelog at point while authorig a commit message.

The modified definitions are extracted from the diff in the message
buffer, which is only available if \"git commit\" was invoked with
\"--verbose\"." t)
(autoload 'git-commit-insert-changelog-plain "git-commit" "\
Insert a simple changelog at point while authorig a commit message.

Defuns are slightly indented and quoted like in elisp docstrings.
The exact format is still subject to change.

The modified definitions are extracted from the diff in the message
buffer, which is only available if \"git commit\" was invoked with
\"--verbose\"." t)
(register-definition-prefixes "git-commit" '("git-commit-" "global-git-commit-mode"))


;;; Generated autoloads from git-rebase.el

(autoload 'git-rebase-current-line "git-rebase" "\
Parse current line into a `git-rebase-action' instance.
If the current line isn't recognized as a rebase line, an
instance with all nil values is returned, unless optional
BATCH is non-nil, in which case nil is returned.  Non-nil
BATCH also ignores commented lines.

(fn &optional BATCH)")
(autoload 'git-rebase-mode "git-rebase" "\
Major mode for editing of a Git rebase file.

Rebase files are generated when you run \"git rebase -i\" or run
`magit-interactive-rebase'.  They describe how Git should perform
the rebase.  See the documentation for git-rebase (e.g., by
running \"man git-rebase\" at the command line) for details.

(fn)" t)
(defconst git-rebase-filename-regexp "/git-rebase-todo\\'")
(add-to-list 'auto-mode-alist (cons git-rebase-filename-regexp #'git-rebase-mode))
(register-definition-prefixes "git-rebase" '("git-rebase-" "magit-imenu--rebase-"))


;;; Generated autoloads from magit.el

(defvar magit-define-global-key-bindings 'default "\
Which set of key bindings to add to the global keymap, if any.

This option controls which set of Magit key bindings, if any, may
be added to the global keymap, even before Magit is first used in
the current Emacs session.

If the value is nil, no bindings are added.

If \\+`default', maybe add:

    \\`C-x' \\`g'     `magit-status'
    \\`C-x' \\`M-g'   `magit-dispatch'
    \\`C-c' \\`M-g'   `magit-file-dispatch'

If `recommended', maybe add:

    \\`C-x' \\`g'     `magit-status'
    \\`C-c' \\`g'     `magit-dispatch'
    \\`C-c' \\`f'     `magit-file-dispatch'

    These bindings are strongly recommended, but we cannot use
    them by default, because the \\`C-c <LETTER>' namespace is
    strictly reserved for bindings added by the user.

The bindings in the chosen set may be added when
`after-init-hook' is run.  Each binding is added if, and only
if, at that time no other key is bound to the same command,
and no other command is bound to the same key.  In other words
we try to avoid adding bindings that are unnecessary, as well
as bindings that conflict with other bindings.

Adding these bindings is delayed until `after-init-hook' is
run to allow users to set the variable anywhere in their init
file (without having to make sure to do so before `magit' is
loaded or autoloaded) and to increase the likelihood that all
the potentially conflicting user bindings have already been
added.

To set this variable use either `setq' or the Custom interface.
Do not use the function `customize-set-variable' because doing
that would cause Magit to be loaded immediately, when that form
is evaluated (this differs from `custom-set-variables', which
doesn't load the libraries that define the customized variables).

Setting this variable has no effect if `after-init-hook' has
already been run.")
(custom-autoload 'magit-define-global-key-bindings "magit" t)
(defun magit-maybe-define-global-key-bindings (&optional force) "\
See variable `magit-define-global-key-bindings'." (when magit-define-global-key-bindings (let ((map (current-global-map))) (pcase-dolist (`(,key \, def) (cond ((eq magit-define-global-key-bindings 'recommended) '(("C-x g" . magit-status) ("C-c g" . magit-dispatch) ("C-c f" . magit-file-dispatch))) ('(("C-x g" . magit-status) ("C-x M-g" . magit-dispatch) ("C-c M-g" . magit-file-dispatch))))) (when (or force (not (or (lookup-key map (kbd key)) (where-is-internal def (make-sparse-keymap) t)))) (define-key map (kbd key) def))))))
(if after-init-time (magit-maybe-define-global-key-bindings) (add-hook 'after-init-hook #'magit-maybe-define-global-key-bindings t))
(autoload 'magit-dispatch "magit" nil t)
(autoload 'magit-run "magit" nil t)
(autoload 'magit-git-command "magit" "\
Execute COMMAND asynchronously; display output.

Interactively, prompt for COMMAND in the minibuffer.  \"git \" is
used as initial input, but can be deleted to run another command.

With a prefix argument COMMAND is run in the top-level directory
of the current working tree, otherwise in `default-directory'.

(fn COMMAND)" t)
(autoload 'magit-git-command-topdir "magit" "\
Execute COMMAND asynchronously; display output.

Interactively, prompt for COMMAND in the minibuffer.  \"git \" is
used as initial input, but can be deleted to run another command.

COMMAND is run in the top-level directory of the current
working tree.

(fn COMMAND)" t)
(autoload 'magit-shell-command "magit" "\
Execute COMMAND asynchronously; display output.

Interactively, prompt for COMMAND in the minibuffer.  With a
prefix argument COMMAND is run in the top-level directory of
the current working tree, otherwise in `default-directory'.

(fn COMMAND)" t)
(autoload 'magit-shell-command-topdir "magit" "\
Execute COMMAND asynchronously; display output.

Interactively, prompt for COMMAND in the minibuffer.  COMMAND
is run in the top-level directory of the current working tree.

(fn COMMAND)" t)
(autoload 'magit-version "magit" "\
Return the version of Magit currently in use.

If optional argument PRINT-DEST is non-nil, also print the used
versions of Magit, Transient, Git and Emacs to the output stream
selected by that argument.  Interactively use the echo area, or
with a prefix argument use the current buffer.  Additionally put
the output in the kill ring.

(fn &optional PRINT-DEST)" t)
(register-definition-prefixes "magit" '("magit-"))


;;; Generated autoloads from magit-apply.el

(autoload 'magit-stage-files "magit-apply" "\
Read one or more files and stage all changes in those files.
With prefix argument FORCE, offer ignored files for completion.

(fn FILES &optional FORCE)" t)
(autoload 'magit-stage-modified "magit-apply" "\
Stage all changes to files modified in the worktree.
Stage all new content of tracked files and remove tracked files
that no longer exist in the working tree from the index also.
With a prefix argument also stage previously untracked (but not
ignored) files.

(fn &optional ALL)" t)
(autoload 'magit-run-post-stage-hook "magit-apply")
(autoload 'magit-unstage-files "magit-apply" "\
Read one or more files and unstage all changes to those files.

(fn FILES)" t)
(autoload 'magit-unstage-all "magit-apply" "\
Remove all changes from the staging area." t)
(autoload 'magit-run-post-unstage-hook "magit-apply")
(register-definition-prefixes "magit-apply" '("magit-"))


;;; Generated autoloads from magit-autorevert.el

(defun magit-auto-revert-mode--initialize (symbol value) (internal--define-uninitialized-variable symbol) (if (not load-file-name) (custom-initialize-set symbol value) (defalias 'magit-auto-revert-mode--after-load (apply-partially (lambda (symbol value mode-file file) (when (equal file mode-file) (remove-hook 'after-load-functions 'magit-auto-revert-mode--after-load) (fmakunbound 'magit-auto-revert-mode--after-load) (if after-init-time (custom-initialize-set symbol value) (defalias 'magit-auto-revert-mode--after-init (apply-partially (lambda (symbol value) (remove-hook 'after-init-hook 'magit-auto-revert-mode--after-init) (fmakunbound 'magit-auto-revert-mode--after-init) (custom-initialize-set symbol value)) symbol value)) (add-hook 'after-init-hook 'magit-auto-revert-mode--after-init)))) symbol value load-file-name)) (add-hook 'after-load-functions 'magit-auto-revert-mode--after-load)))
(put 'magit-auto-revert-mode 'globalized-minor-mode t)
(defcustom magit-auto-revert-mode (not (or global-auto-revert-mode noninteractive)) "\
Non-nil if Magit-Auto-Revert mode is enabled.
See the `magit-auto-revert-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `magit-auto-revert-mode'." :set #'custom-set-minor-mode :initialize #'magit-auto-revert-mode--initialize :type 'boolean :group 'magit-auto-revert :group 'magit-essentials :package-version '(magit . "2.4.0") :link '(info-link "(magit)Automatic Reverting of File-Visiting Buffers"))
(custom-autoload 'magit-auto-revert-mode "magit-autorevert" nil)
(autoload 'magit-auto-revert-mode "magit-autorevert" "\
Toggle Auto-Revert mode in all buffers.
With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive; otherwise,
disable it.

If called from Lisp, toggle the mode if ARG is `toggle'.
Enable the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.

Auto-Revert mode is enabled in all buffers where
`magit-turn-on-auto-revert-mode-if-desired' would do it.

See `auto-revert-mode' for more information on Auto-Revert mode.

(fn &optional ARG)" t)
(autoload 'magit-auto-revert-buffers "magit-autorevert")
(register-definition-prefixes "magit-autorevert" '("auto-revert-buffer" "magit-"))


;;; Generated autoloads from magit-base.el

(autoload 'magit-emacs-Q-command "magit-base" "\
Show a shell command that runs an uncustomized Emacs with only Magit loaded.
See info node `(magit)Debugging Tools' for more information." t)
(define-advice Info-follow-nearest-node (:around (fn &optional fork) gitman) (let ((node (Info-get-token (point) "\\*note[ 
	]+" "\\*note[ 
	]+\\([^:]*\\):\\(:\\|[ 
	]*(\\)?"))) (if (and node (string-match "^(gitman)\\(.+\\)" node)) (pcase magit-view-git-manual-method ('info (funcall fn fork)) ('man (require 'man) (man (match-string-no-properties 1 node))) ('woman (require 'woman) (woman (match-string-no-properties 1 node))) (_ (user-error "Invalid value for `magit-view-git-manual-method'"))) (funcall fn fork))))
(define-advice org-man-export (:around (fn link description format) gitman) (if (and (eq format 'texinfo) (string-prefix-p "git" link)) (string-replace "%s" link "
@ifinfo
@ref{%s,,,gitman,}.
@end ifinfo
@ifhtml
@html
the <a href=\"http://git-scm.com/docs/%s\">%s(1)</a> manpage.
@end html
@end ifhtml
@iftex
the %s(1) manpage.
@end iftex
") (funcall fn link description format)))
(register-definition-prefixes "magit-base" '("magit-"))


;;; Generated autoloads from magit-bisect.el

(autoload 'magit-bisect "magit-bisect" nil t)
(autoload 'magit-bisect-start "magit-bisect" "\
Start a bisect session.

Bisecting a bug means to find the commit that introduced it.
This command starts such a bisect session by asking for a known
good and a known bad commit.  To move the session forward use the
other actions from the bisect transient command (\\<magit-status-mode-map>\\[magit-bisect]).

(fn BAD GOOD ARGS)" t)
(autoload 'magit-bisect-reset "magit-bisect" "\
After bisecting, cleanup bisection state and return to original `HEAD'." t)
(autoload 'magit-bisect-good "magit-bisect" "\
While bisecting, mark the current commit as good.
Use this after you have asserted that the commit does not contain
the bug in question." t)
(autoload 'magit-bisect-bad "magit-bisect" "\
While bisecting, mark the current commit as bad.
Use this after you have asserted that the commit does contain the
bug in question." t)
(autoload 'magit-bisect-mark "magit-bisect" "\
While bisecting, mark the current commit with a bisect term.
During a bisect using alternate terms, commits can still be
marked with `magit-bisect-good' and `magit-bisect-bad', as those
commands map to the correct term (\"good\" to --term-old's value
and \"bad\" to --term-new's).  However, in some cases, it can be
difficult to keep that mapping straight in your head; this
command provides an interface that exposes the underlying terms." t)
(autoload 'magit-bisect-skip "magit-bisect" "\
While bisecting, skip the current commit.
Use this if for some reason the current commit is not a good one
to test.  This command lets Git choose a different one." t)
(autoload 'magit-bisect-run "magit-bisect" "\
Bisect automatically by running commands after each step.

Unlike \"git bisect run\" this can be used before bisecting has begun.
In that case it behaves like \"git bisect start; git bisect run\".

(fn CMDLINE &optional BAD GOOD ARGS)" t)
(register-definition-prefixes "magit-bisect" '("magit-"))


;;; Generated autoloads from magit-blame.el

(autoload 'magit-blame-echo "magit-blame" nil t)
(autoload 'magit-blame-addition "magit-blame" nil t)
(autoload 'magit-blame-removal "magit-blame" nil t)
(autoload 'magit-blame-reverse "magit-blame" nil t)
(autoload 'magit-blame "magit-blame" nil t)
(register-definition-prefixes "magit-blame" '("magit-"))


;;; Generated autoloads from magit-branch.el

(autoload 'magit-branch "magit" nil t)
(autoload 'magit-checkout "magit-branch" "\
Checkout COMMIT, updating the index and the working tree.
If COMMIT is a local branch, then that becomes the current
branch.  If it is something else, then `HEAD' becomes detached.
Checkout fails if the working tree or the staging area contain
changes.

(git checkout COMMIT).

(fn COMMIT &optional ARGS)" t)
(function-put 'magit-checkout 'interactive-only 'magit--checkout)
(autoload 'magit-branch-create "magit-branch" "\
Create BRANCH at branch or revision START-POINT.

(fn BRANCH START-POINT)" t)
(function-put 'magit-branch-create 'interactive-only 'magit-call-git)
(autoload 'magit-branch-and-checkout "magit-branch" "\
Create and checkout BRANCH at branch or revision START-POINT.

(fn BRANCH START-POINT &optional ARGS)" t)
(function-put 'magit-branch-and-checkout 'interactive-only 'magit-call-git)
(autoload 'magit-branch-or-checkout "magit-branch" "\
Hybrid between `magit-checkout' and `magit-branch-and-checkout'.

Ask the user for an existing branch or revision.  If the user
input actually can be resolved as a branch or revision, then
check that out, just like `magit-checkout' would.

Otherwise create and checkout a new branch using the input as
its name.  Before doing so read the starting-point for the new
branch.  This is similar to what `magit-branch-and-checkout'
does.

(fn ARG &optional START-POINT)" t)
(function-put 'magit-branch-or-checkout 'interactive-only 'magit-call-git)
(autoload 'magit-branch-checkout "magit-branch" "\
Checkout an existing or new local branch.

Read a branch name from the user offering all local branches and
a subset of remote branches as candidates.  Omit remote branches
for which a local branch by the same name exists from the list
of candidates.  The user can also enter a completely new branch
name.

- If the user selects an existing local branch, then check that
  out.

- If the user selects a remote branch, then create and checkout
  a new local branch with the same name.  Configure the selected
  remote branch as push target.

- If the user enters a new branch name, then create and check
  that out, after also reading the starting-point from the user.

In the latter two cases the upstream is also set.  Whether it is
set to the chosen START-POINT or something else depends on the
value of `magit-branch-adjust-remote-upstream-alist', just like
when using `magit-branch-and-checkout'.

(fn BRANCH &optional START-POINT)" t)
(function-put 'magit-branch-checkout 'interactive-only 'magit-call-git)
(autoload 'magit-branch-orphan "magit-branch" "\
Create and checkout an orphan BRANCH with contents from revision START-POINT.

(fn BRANCH START-POINT)" t)
(autoload 'magit-checkout-remote-ref "magit-branch" "\
Checkout reference REF from REMOTE.

This command queries the REMOTE for a list of its references.  After
the user has selected on of them, it fetches just that, and finally
it checks out \"FETCH_HEAD\", which now refers to the same commit as
REF does on REMOTE.

This is only useful if you usually only fetch a subset of the refs
from REMOTE.  Otherwise it is better to use `magit-checkout', as
that avoids a round-trip.

(fn REMOTE REF)" t)
(function-put 'magit-checkout-remote-ref 'interactive-only 'magit-call-git)
(autoload 'magit-branch-spinout "magit-branch" "\
Create new branch from the unpushed commits.
Like `magit-branch-spinoff' but remain on the current branch.
If there are any uncommitted changes, then behave exactly like
`magit-branch-spinoff'.

(fn BRANCH &optional FROM)" t)
(autoload 'magit-branch-spinoff "magit-branch" "\
Create new branch from the unpushed commits.

Create and checkout a new branch starting at and tracking the
current branch.  That branch in turn is reset to the last commit
it shares with its upstream.  If the current branch has no
upstream or no unpushed commits, then the new branch is created
anyway and the previously current branch is not touched.

This is useful to create a feature branch after work has already
began on the old branch (likely but not necessarily \"master\").

If the current branch is a member of the value of option
`magit-branch-prefer-remote-upstream' (which see), then the
current branch will be used as the starting point as usual, but
the upstream of the starting-point may be used as the upstream
of the new branch, instead of the starting-point itself.

If optional FROM is non-nil, then the source branch is reset
to `FROM~', instead of to the last commit it shares with its
upstream.  Interactively, FROM is only ever non-nil, if the
region selects some commits, and among those commits, FROM is
the commit that is the fewest commits ahead of the source
branch.

The commit at the other end of the selection actually does not
matter, all commits between FROM and `HEAD' are moved to the new
branch.  If FROM is not reachable from `HEAD' or is reachable
from the source branch's upstream, then an error is raised.

(fn BRANCH &optional FROM)" t)
(autoload 'magit-branch-reset "magit-branch" "\
Reset a branch to the tip of another branch or any other commit.

When the branch being reset is the current branch, then do a
hard reset.  If there are any uncommitted changes, then the user
has to confirm the reset because those changes would be lost.

This is useful when you have started work on a feature branch but
realize it's all crap and want to start over.

When resetting to another branch and a prefix argument is used,
then also set the target branch as the upstream of the branch
that is being reset.

(fn BRANCH TO &optional SET-UPSTREAM)" t)
(autoload 'magit-branch-delete "magit-branch" "\
Delete one or multiple branches.

If the region marks multiple branches, then offer to delete
those, otherwise prompt for a single branch to be deleted,
defaulting to the branch at point.

Require confirmation when deleting branches is dangerous in some
way.  Option `magit-no-confirm' can be customized to not require
confirmation in certain cases.  See its docstring to learn why
confirmation is required by default in certain cases or if a
prompt is confusing.

(fn BRANCHES &optional FORCE)" t)
(autoload 'magit-branch-rename "magit-branch" "\
Rename the branch named OLD to NEW.

With a prefix argument FORCE, rename even if a branch named NEW
already exists.

If `branch.OLD.pushRemote' is set, then unset it.  Depending on
the value of `magit-branch-rename-push-target' (which see) maybe
set `branch.NEW.pushRemote' and maybe rename the push-target on
the remote.

(fn OLD NEW &optional FORCE)" t)
(autoload 'magit-branch-shelve "magit-branch" "\
Shelve a BRANCH.
Rename \"refs/heads/BRANCH\" to \"refs/shelved/YYYY-MM-DD-BRANCH\",
and also rename the respective reflog file.

(fn BRANCH)" t)
(autoload 'magit-branch-unshelve "magit-branch" "\
Unshelve a BRANCH.
Rename \"refs/shelved/BRANCH\" to \"refs/heads/BRANCH\".  If BRANCH
is prefixed with \"YYYY-MM-DD\", then drop that part of the name.
Also rename the respective reflog file.

(fn BRANCH)" t)
(autoload 'magit-branch-configure "magit-branch" nil t)
(register-definition-prefixes "magit-branch" '("magit-"))


;;; Generated autoloads from magit-bundle.el

(autoload 'magit-bundle "magit-bundle" nil t)
(autoload 'magit-bundle-import "magit-bundle" nil t)
(autoload 'magit-bundle-create-tracked "magit-bundle" "\
Create and track a new bundle.

(fn FILE TAG BRANCH REFS ARGS)" t)
(autoload 'magit-bundle-update-tracked "magit-bundle" "\
Update a bundle that is being tracked using TAG.

(fn TAG)" t)
(autoload 'magit-bundle-verify "magit-bundle" "\
Check whether FILE is valid and applies to the current repository.

(fn FILE)" t)
(autoload 'magit-bundle-list-heads "magit-bundle" "\
List the refs in FILE.

(fn FILE)" t)
(register-definition-prefixes "magit-bundle" '("magit-"))


;;; Generated autoloads from magit-clone.el

(autoload 'magit-clone "magit-clone" nil t)
(autoload 'magit-clone-regular "magit-clone" "\
Create a clone of REPOSITORY in DIRECTORY.
Then show the status buffer for the new repository.

(fn REPOSITORY DIRECTORY ARGS)" t)
(autoload 'magit-clone-shallow "magit-clone" "\
Create a shallow clone of REPOSITORY in DIRECTORY.
Then show the status buffer for the new repository.
With a prefix argument read the DEPTH of the clone;
otherwise use 1.

(fn REPOSITORY DIRECTORY ARGS DEPTH)" t)
(autoload 'magit-clone-shallow-since "magit-clone" "\
Create a shallow clone of REPOSITORY in DIRECTORY.
Then show the status buffer for the new repository.
Exclude commits before DATE, which is read from the
user.

(fn REPOSITORY DIRECTORY ARGS DATE)" t)
(autoload 'magit-clone-shallow-exclude "magit-clone" "\
Create a shallow clone of REPOSITORY in DIRECTORY.
Then show the status buffer for the new repository.
Exclude commits reachable from EXCLUDE, which is a
branch or tag read from the user.

(fn REPOSITORY DIRECTORY ARGS EXCLUDE)" t)
(autoload 'magit-clone-bare "magit-clone" "\
Create a bare clone of REPOSITORY in DIRECTORY.
Then show the status buffer for the new repository.

(fn REPOSITORY DIRECTORY ARGS)" t)
(autoload 'magit-clone-mirror "magit-clone" "\
Create a mirror of REPOSITORY in DIRECTORY.
Then show the status buffer for the new repository.

(fn REPOSITORY DIRECTORY ARGS)" t)
(autoload 'magit-clone-sparse "magit-clone" "\
Clone REPOSITORY into DIRECTORY and create a sparse checkout.

(fn REPOSITORY DIRECTORY ARGS)" t)
(register-definition-prefixes "magit-clone" '("magit-"))


;;; Generated autoloads from magit-commit.el

(autoload 'magit-commit "magit-commit" nil t)
(autoload 'magit-commit-create "magit-commit" "\
Create a new commit.

(fn &optional ARGS)" t)
(autoload 'magit-commit-extend "magit-commit" "\
Amend staged changes to the last commit, without editing its message.

With a prefix argument do not update the committer date; without an
argument update it.  The option `magit-commit-extend-override-date'
can be used to inverse the meaning of the prefix argument.  Called
non-interactively, the optional OVERRIDE-DATE argument controls this
behavior, and the option is of no relevance.

(fn &optional ARGS OVERRIDE-DATE)" t)
(autoload 'magit-commit-amend "magit-commit" "\
Amend staged changes (if any) to the last commit, and edit its message.

(fn &optional ARGS)" t)
(autoload 'magit-commit-reword "magit-commit" "\
Reword the message of the last commit, without amending its tree.

With a prefix argument do not update the committer date; without an
argument update it.  The option `magit-commit-reword-override-date'
can be used to inverse the meaning of the prefix argument.  Called
non-interactively, the optional OVERRIDE-DATE argument controls this
behavior, and the option is of no relevance.

(fn &optional ARGS OVERRIDE-DATE)" t)
(autoload 'magit-commit-fixup "magit-commit" "\
Create a fixup commit, leaving the original commit message untouched.

If there is a reachable commit at point, target that.  Otherwise prompt
for a commit.  If `magit-commit-squash-confirm' is non-nil, always make
the user explicitly select a commit, in a buffer dedicated to that task.

During a later rebase, when this commit gets squashed into its targeted
commit, the original message of the targeted commit is used as-is.

In other words, call \"git commit --fixup=COMMIT --no-edit\".

(fn &optional COMMIT ARGS)" t)
(autoload 'magit-commit-squash "magit-commit" "\
Create a squash commit, without the user authoring a commit message.

If there is a reachable commit at point, target that.  Otherwise prompt
for a commit.  If `magit-commit-squash-confirm' is non-nil, always make
the user explicitly select a commit, in a buffer dedicated to that task.

During a later rebase, when this commit gets squashed into its targeted
commit, the user is given a chance to edit the original message to take
the changes from the squash commit into account.

In other words, call \"git commit --squash=COMMIT --no-edit\".

(fn &optional COMMIT ARGS)" t)
(autoload 'magit-commit-alter "magit-commit" "\
Create a squash commit, authoring the final commit message now.

If there is a reachable commit at point, target that.  Otherwise prompt
for a commit.  If `magit-commit-squash-confirm' is non-nil, always make
the user explicitly select a commit, in a buffer dedicated to that task.

During a later rebase, when this commit gets squashed into its targeted
commit, the original message of the targeted commit is replaced with the
message of this commit, without the user automatically being given a
chance to edit again.

In other words, call \"git commit --fixup=amend:COMMIT --edit\".

(fn &optional COMMIT ARGS)" t)
(autoload 'magit-commit-augment "magit-commit" "\
Create a squash commit, authoring a new temporary commit message.

If there is a reachable commit at point, target that.  Otherwise prompt
for a commit.  If `magit-commit-squash-confirm' is non-nil, always make
the user explicitly select a commit, in a buffer dedicated to that task.

During a later rebase, when this commit gets squashed into its targeted
commit, the user is asked to write a final commit message, in a buffer
that starts out containing both the original commit message, as well as
the temporary commit message of the squash commit.

In other words, call \"git commit --squash=COMMIT --edit\".

(fn &optional COMMIT ARGS)" t)
(autoload 'magit-commit-revise "magit-commit" "\
Reword the message of an existing commit, without editing its tree.

If there is a reachable commit at point, target that.  Otherwise prompt
for a commit.  If `magit-commit-squash-confirm' is non-nil, always make
the user explicitly select a commit, in a buffer dedicated to that task.

During a later rebase, when this commit gets squashed into its targeted
commit, a combined commit is created which uses the message of the fixup
commit and the tree of the targeted commit.

In other words, call \"git commit --fixup=reword:COMMIT --edit\".

(fn &optional COMMIT ARGS)" t)
(autoload 'magit-commit-instant-fixup "magit-commit" "\
Create a fixup commit, and immediately combine it with its target.

If there is a reachable commit at point, target that.  Otherwise prompt
for a commit.  If `magit-commit-squash-confirm' is non-nil, always make
the user explicitly select a commit, in a buffer dedicated to that task.

Leave the original commit message of the targeted commit untouched.

Like `magit-commit-fixup' but also run a \"--autofixup\" rebase.

(fn &optional COMMIT ARGS)" t)
(autoload 'magit-commit-instant-squash "magit-commit" "\
Create a squash commit, and immediately combine it with its target.

If there is a reachable commit at point, target that.  Otherwise prompt
for a commit.  If `magit-commit-squash-confirm' is non-nil, always make
the user explicitly select a commit, in a buffer dedicated to that task.

Turing the rebase phase, when the two commits are being squashed, ask
the user to author the final commit message, based on the original
message of the targeted commit.

Like `magit-commit-squash' but also run a \"--autofixup\" rebase.

(fn &optional COMMIT ARGS)" t)
(autoload 'magit-commit-reshelve "magit-commit" "\
Change committer (and possibly author) date of the last commit.

The current time is used as the initial minibuffer input and the
original author or committer date is available as the previous
history element.

Both the author and the committer dates are changed, unless one
of the following is true, in which case only the committer date
is updated:
- You are not the author of the commit that is being reshelved.
- The command was invoked with a prefix argument.
- Non-interactively if UPDATE-AUTHOR is nil.

(fn DATE UPDATE-AUTHOR &optional ARGS)" t)
(autoload 'magit-commit-absorb-modules "magit-commit" "\
Spread modified modules across recent commits.

(fn PHASE COMMIT)" t)
(autoload 'magit-commit-absorb "magit-commit" nil t)
(autoload 'magit-commit-autofixup "magit-commit" nil t)
(autoload 'magit-run-post-commit-hook "magit-commit")
(register-definition-prefixes "magit-commit" '("magit-"))


;;; Generated autoloads from magit-diff.el

(autoload 'magit-diff "magit-diff" nil t)
(autoload 'magit-diff-refresh "magit-diff" nil t)
(autoload 'magit-diff-dwim "magit-diff" "\
Show changes for the thing at point.

For example, if point is on a commit, show the changes introduced by
that commit.  Likewise if point is on the section titled \"Unstaged
changes\", then show those changes in a separate buffer.  Generally
speaking, compare the thing at point with the most logical, trivial
and (in *any* situation) at least potentially useful other thing it
could be compared to.

When the region selects commits, then compare the two commits at
either end.  There are different ways two commits can be compared.
In the buffer showing the diff, you can control how the comparison,
is done, using \"D r\" and \"D f\".

This function does not always show the changes that you might want
to view in any given situation.  You can think of the changes being
shown as the smallest common denominator.  There is no AI involved.
If this command never does what you want, then ignore it, and instead
use the commands that allow you to explicitly specify what you need.

(fn &optional ARGS FILES)" t)
(autoload 'magit-diff-range "magit-diff" "\
Show differences between two commits.

REV-OR-RANGE should be a range or a single revision.  If it is a
revision, then show changes in the working tree relative to that
revision.  If it is a range, but one side is omitted, then show
changes relative to `HEAD'.

If the region is active, use the revisions on the first and last
line of the region as the two sides of the range.  With a prefix
argument, instead of diffing the revisions, choose a revision to
view changes along, starting at the common ancestor of both
revisions (i.e., use a \"...\" range).

(fn REV-OR-RANGE &optional ARGS FILES)" t)
(autoload 'magit-diff-working-tree "magit-diff" "\
Show changes between the current working tree and the `HEAD' commit.
With a prefix argument show changes between the working tree and
a commit read from the minibuffer.

(fn &optional REV ARGS FILES)" t)
(autoload 'magit-diff-staged "magit-diff" "\
Show changes between the index and the `HEAD' commit.
With a prefix argument show changes between the index and
a commit read from the minibuffer.

(fn &optional REV ARGS FILES)" t)
(autoload 'magit-diff-unstaged "magit-diff" "\
Show changes between the working tree and the index.

(fn &optional ARGS FILES)" t)
(autoload 'magit-diff-unmerged "magit-diff" "\
Show changes that are being merged.

(fn &optional ARGS FILES)" t)
(autoload 'magit-diff-while-committing "magit-diff" "\
While committing, show the changes that are about to be committed.
While amending, invoking the command again toggles between
showing just the new changes or all the changes that will
be committed." t)
(autoload 'magit-diff-buffer-file "magit-diff" "\
Show diff for the blob or file visited in the current buffer.

Limit the diff to the file or blob.

When the buffer visits a blob, then show the respective commit.
When the buffer visits a file, then show the differences between
`HEAD' and the working tree, or the index with a prefix argument.

(fn &optional UNSTAGED-ONLY)" t)
(autoload 'magit-diff-paths "magit-diff" "\
Show changes between any two files on disk.

(fn A B)" t)
(autoload 'magit-show-commit "magit-diff" "\
Visit the revision at point in another buffer.

If there is no revision at point, or with a prefix argument, prompt
for a revision.

By default the same per-repository revision buffer is reused for all
revision.  When you want to display multiple revisions at the same
time, you can lock a revision buffer to its value, which prevents it
from being reused to display another revision.

Alternatively, you can use a dedicated buffer for every revision.
To do so, enable `magit-revision-use-dedicated-buffers', but only
after readings its docstring, to make sure you are can live with
the trade-offs.

(fn REV &optional ARGS FILES MODULE)" t)
(autoload 'magit-show-commit-removing-file "magit-diff" "\
Show the commit that removed FILE.

(fn FILE &optional ARGS)" t)
(register-definition-prefixes "magit-diff" '("magit-"))


;;; Generated autoloads from magit-dired.el

(autoload 'magit-dired-jump "magit-dired" "\
Visit file at point using Dired.
With a prefix argument, visit in another window.  If there
is no file at point, then instead visit `default-directory'.

(fn &optional OTHER-WINDOW)" t)
(autoload 'magit-dired-stage "magit-dired" "\
In Dired, staged all marked files or the file at point." t)
(autoload 'magit-dired-unstage "magit-dired" "\
In Dired, unstaged all marked files or the file at point." t)
(autoload 'magit-dired-log "magit-dired" "\
In Dired, show log for all marked files or the directory if none are marked.

(fn &optional FOLLOW)" t)
(autoload 'magit-dired-am-apply-patches "magit-dired" "\
In Dired, apply the marked (or next ARG) files as patches.
If inside a repository, then apply in that.  Otherwise prompt
for a repository.

(fn REPO &optional ARG)" t)
(autoload 'magit-do-async-shell-command "magit-dired" "\
Open FILE with `dired-do-async-shell-command'.
Interactively, open the file at point.

(fn FILE)" t)


;;; Generated autoloads from magit-ediff.el

(autoload 'magit-ediff "magit-ediff" nil t)
(autoload 'magit-ediff-resolve-all "magit-ediff" nil t)
(autoload 'magit-ediff-resolve-rest "magit-ediff" nil t)
(autoload 'magit-ediff-stage "magit-ediff" nil t)
(autoload 'magit-ediff-compare "magit-ediff" nil t)
(autoload 'magit-ediff-dwim "magit-ediff" nil t)
(autoload 'magit-ediff-show-staged "magit-ediff" nil t)
(autoload 'magit-ediff-show-unstaged "magit-ediff" nil t)
(autoload 'magit-ediff-show-working-tree "magit-ediff" nil t)
(autoload 'magit-ediff-show-commit "magit-ediff" nil t)
(autoload 'magit-ediff-show-stash "magit-ediff" nil t)
(register-definition-prefixes "magit-ediff" '("magit-ediff-"))


;;; Generated autoloads from magit-extras.el

(autoload 'magit-git-mergetool "magit-extras" nil t)
(autoload 'magit-run-git-gui-blame "magit-extras" "\
Run \"git gui blame\" on the given FILENAME and COMMIT.
Interactively run it for the current file and the `HEAD', with a
prefix or when the current file cannot be determined let the user
choose.  When the current buffer is visiting FILENAME instruct
blame to center around the line point is on.

(fn COMMIT FILENAME &optional LINENUM)" t)
(autoload 'magit-run-git-gui "magit-extras" "\
Run \"git gui\" for the current git repository." t)
(autoload 'magit-run-gitk "magit-extras" "\
Run `gitk' in the current repository." t)
(autoload 'magit-run-gitk-branches "magit-extras" "\
Run `gitk --branches' in the current repository." t)
(autoload 'magit-run-gitk-all "magit-extras" "\
Run `gitk --all' in the current repository." t)
(autoload 'magit-project-status "magit-extras" "\
Run `magit-status' in the current project's root.

To teach `project-switch-project' about this command, you have to
add something like this to your configuration:

    (keymap-set project-prefix-map \"m\" #\\='magit-project-status)
    (add-to-list \\='project-switch-commands
                 \\='(magit-project-status \"Magit\") t)

Also see `magit-project-dispatch'." t)
(autoload 'magit-project-dispatch "magit-extras" "\
Run `magit-dispatch' in the current project's root.

Note that for `magit-dispatch' to operate in the selected project,
the current buffer's `default-directory' must be located in the
selected repository.  To achieve that, a Dired buffer is created.

To teach `project-switch-project' about this command, you have to
add something like this to your configuration:

    (keymap-set project-prefix-map \"M\" #\\='magit-project-dispatch)
    (add-to-list \\='project-switch-commands
                 \\='(magit-project-dispatch \"Magit Dispatch\") t)

Also see `magit-project-status'." t)
(autoload 'magit-previous-line "magit-extras" "\
Like `previous-line' but with Magit-specific shift-selection.

Magit's selection mechanism is based on the region but selects an
area that is larger than the region.  This causes `previous-line'
when invoked while holding the shift key to move up one line and
thereby select two lines.  When invoked inside a hunk body this
command does not move point on the first invocation and thereby
it only selects a single line.  Which inconsistency you prefer
is a matter of preference.

(fn &optional ARG TRY-VSCROLL)" t)
(function-put 'magit-previous-line 'interactive-only '"use `forward-line' with negative argument instead.")
(autoload 'magit-next-line "magit-extras" "\
Like `next-line' but with Magit-specific shift-selection.

Magit's selection mechanism is based on the region but selects
an area that is larger than the region.  This causes `next-line'
when invoked while holding the shift key to move down one line
and thereby select two lines.  When invoked inside a hunk body
this command does not move point on the first invocation and
thereby it only selects a single line.  Which inconsistency you
prefer is a matter of preference.

(fn &optional ARG TRY-VSCROLL)" t)
(function-put 'magit-next-line 'interactive-only 'forward-line)
(autoload 'magit-clean "magit-extras" "\
Remove untracked files from the working tree.
With a prefix argument also remove ignored files,
with two prefix arguments remove ignored files only.

(git clean -f -d [-x|-X])

(fn &optional ARG)" t)
(autoload 'magit-generate-changelog "magit-extras" "\
Insert ChangeLog entries into the current buffer.

The entries are generated from the diff being committed.
If prefix argument, AMENDING, is non-nil, include changes
in HEAD as well as staged changes in the diff to check.

(fn &optional AMENDING)" t)
(autoload 'magit-add-change-log-entry "magit-extras" "\
Find change log file and add date entry and item for current change.
This differs from `add-change-log-entry' (which see) in that
it acts on the current hunk in a Magit buffer instead of on
a position in a file-visiting buffer.

(fn &optional WHOAMI FILE-NAME OTHER-WINDOW)" t)
(autoload 'magit-add-change-log-entry-other-window "magit-extras" "\
Find change log file in other window and add entry and item.
This differs from `add-change-log-entry-other-window' (which see)
in that it acts on the current hunk in a Magit buffer instead of
on a position in a file-visiting buffer.

(fn &optional WHOAMI FILE-NAME)" t)
(autoload 'magit-edit-line-commit "magit-extras" "\
Edit the commit that added the current line.

With a prefix argument edit the commit that removes the line,
if any.  The commit is determined using \"git blame\" and made
editable using \"git rebase --interactive\" if it is reachable
from `HEAD', or by checking out the commit (or a branch that
points at it) otherwise.

(fn &optional TYPE)" t)
(autoload 'magit-diff-edit-hunk-commit "magit-extras" "\
From a hunk, edit the respective commit and visit the file.

First visit the file being modified by the hunk at the correct
location using `magit-diff-visit-file'.  This actually visits a
blob.  When point is on a diff header, not within an individual
hunk, then this visits the blob the first hunk is about.

Then invoke `magit-edit-line-commit', which uses an interactive
rebase to make the commit editable, or if that is not possible
because the commit is not reachable from `HEAD' by checking out
that commit directly.  This also causes the actual worktree file
to be visited.

Neither the blob nor the file buffer are killed when finishing
the rebase.  If that is undesirable, then it might be better to
use `magit-rebase-edit-commit' instead of this command." t)
(autoload 'magit-reshelve-since "magit-extras" "\
Change the author and committer dates of the commits since COMMIT.

Ask the user for the first reachable commit whose dates should
be changed.  Then read the new date for that commit.  The initial
minibuffer input and the previous history element offer good
values.  The next commit will be created one minute later and so
on.

This command is only intended for interactive use and should only
be used on highly rearranged and unpublished history.

If KEYID is non-nil, then use that to sign all reshelved commits.
Interactively use the value of the \"--gpg-sign\" option in the
list returned by `magit-rebase-arguments'.

(fn COMMIT KEYID)" t)
(autoload 'magit-pop-revision-stack "magit-extras" "\
Insert a representation of a revision into the current buffer.

Pop a revision from the `magit-revision-stack' and insert it into
the current buffer according to `magit-pop-revision-stack-format'.
Revisions can be put on the stack using `magit-copy-section-value'
and `magit-copy-buffer-revision'.

If the stack is empty or with a prefix argument, instead read a
revision in the minibuffer.  By using the minibuffer history this
allows selecting an item which was popped earlier or to insert an
arbitrary reference or revision without first pushing it onto the
stack.

When reading the revision from the minibuffer, then it might not
be possible to guess the correct repository.  When this command
is called inside a repository (e.g., while composing a commit
message), then that repository is used.  Otherwise (e.g., while
composing an email) then the repository recorded for the top
element of the stack is used (even though we insert another
revision).  If not called inside a repository and with an empty
stack, or with two prefix arguments, then read the repository in
the minibuffer too.

(fn REV TOPLEVEL)" t)
(autoload 'magit-copy-section-value "magit-extras" "\
Save the value of the current section for later use.

Save the section value to the `kill-ring', and, provided that
the current section is a commit, branch, or tag section, push
the (referenced) revision to the `magit-revision-stack' for use
with `magit-pop-revision-stack'.

When `magit-copy-revision-abbreviated' is non-nil, save the
abbreviated revision to the `kill-ring' and the
`magit-revision-stack'.

When the current section is a branch or a tag, and a prefix
argument is used, then save the revision at its tip to the
`kill-ring' instead of the reference name.

When the region is active, then save that to the `kill-ring',
like `kill-ring-save' would, instead of behaving as described
above.  If a prefix argument is used and the region is within
a hunk, then strip the diff marker column and keep only either
the added or removed lines, depending on the sign of the prefix
argument.

(fn ARG)" t)
(autoload 'magit-copy-buffer-revision "magit-extras" "\
Save the revision of the current buffer for later use.

Save the revision shown in the current buffer to the `kill-ring'
and push it to the `magit-revision-stack'.

This command is mainly intended for use in `magit-revision-mode'
buffers, the only buffers where it is always unambiguous exactly
which revision should be saved.

Most other Magit buffers usually show more than one revision, in
some way or another, so this command has to select one of them,
and that choice might not always be the one you think would have
been the best pick.

In such buffers it is often more useful to save the value of
the current section instead, using `magit-copy-section-value'.

When the region is active, then save that to the `kill-ring',
like `kill-ring-save' would, instead of behaving as described
above.

When `magit-copy-revision-abbreviated' is non-nil, save the
abbreviated revision to the `kill-ring' and the
`magit-revision-stack'." t)
(autoload 'magit-display-repository-buffer "magit-extras" "\
Display a Magit buffer belonging to the current Git repository.
The buffer is displayed using `magit-display-buffer', which see.

(fn BUFFER)" t)
(autoload 'magit-switch-to-repository-buffer "magit-extras" "\
Switch to a Magit buffer belonging to the current Git repository.

(fn BUFFER)" t)
(autoload 'magit-switch-to-repository-buffer-other-window "magit-extras" "\
Switch to a Magit buffer belonging to the current Git repository.

(fn BUFFER)" t)
(autoload 'magit-switch-to-repository-buffer-other-frame "magit-extras" "\
Switch to a Magit buffer belonging to the current Git repository.

(fn BUFFER)" t)
(autoload 'magit-abort-dwim "magit-extras" "\
Abort current operation.
Depending on the context, this will abort a merge, a rebase, a
patch application, a cherry-pick, a revert, or a bisect." t)
(autoload 'magit-back-to-indentation "magit-extras" "\
Move point to the first non-whitespace character on this line.
In Magit diffs, also skip over - and + at the beginning of the line." t)
(register-definition-prefixes "magit-extras" '("magit-"))


;;; Generated autoloads from magit-fetch.el

(autoload 'magit-fetch "magit-fetch" nil t)
(autoload 'magit-fetch-from-pushremote "magit-fetch" nil t)
(autoload 'magit-fetch-from-upstream "magit-fetch" nil t)
(autoload 'magit-fetch-other "magit-fetch" "\
Fetch from another repository.

(fn REMOTE ARGS)" t)
(autoload 'magit-fetch-branch "magit-fetch" "\
Fetch a BRANCH from a REMOTE.

(fn REMOTE BRANCH ARGS)" t)
(autoload 'magit-fetch-refspec "magit-fetch" "\
Fetch a REFSPEC from a REMOTE.

(fn REMOTE REFSPEC ARGS)" t)
(autoload 'magit-fetch-all "magit-fetch" "\
Fetch from all remotes.

(fn ARGS)" t)
(autoload 'magit-fetch-all-prune "magit-fetch" "\
Fetch from all remotes, and prune.
Prune remote tracking branches for branches that have been
removed on the respective remote." t)
(autoload 'magit-fetch-all-no-prune "magit-fetch" "\
Fetch from all remotes." t)
(autoload 'magit-fetch-modules "magit-fetch" nil t)
(register-definition-prefixes "magit-fetch" '("magit-"))


;;; Generated autoloads from magit-files.el

(autoload 'magit-find-file "magit-files" "\
View FILE from REV.
Switch to a buffer visiting blob REV:FILE, creating one if none
already exists.  If prior to calling this command the current
buffer and/or cursor position is about the same file, then go
to the line and column corresponding to that location.

(fn REV FILE)" t)
(autoload 'magit-find-file-other-window "magit-files" "\
View FILE from REV, in another window.
Switch to a buffer visiting blob REV:FILE, creating one if none
already exists.  If prior to calling this command the current
buffer and/or cursor position is about the same file, then go to
the line and column corresponding to that location.

(fn REV FILE)" t)
(autoload 'magit-find-file-other-frame "magit-files" "\
View FILE from REV, in another frame.
Switch to a buffer visiting blob REV:FILE, creating one if none
already exists.  If prior to calling this command the current
buffer and/or cursor position is about the same file, then go to
the line and column corresponding to that location.

(fn REV FILE)" t)
(autoload 'magit-file-dispatch "magit" nil t)
(autoload 'magit-blob-visit-file "magit-files" "\
View the file from the worktree corresponding to the current blob.
When visiting a blob or the version from the index, then go to
the same location in the respective file in the working tree." t)
(autoload 'magit-file-stage "magit-files" "\
Stage all changes to the file being visited in the current buffer." t)
(autoload 'magit-file-unstage "magit-files" "\
Unstage all changes to the file being visited in the current buffer." t)
(autoload 'magit-file-untrack "magit-files" "\
Untrack the selected FILES or one file read in the minibuffer.

With a prefix argument FORCE do so even when the files have
staged as well as unstaged changes.

(fn FILES &optional FORCE)" t)
(autoload 'magit-file-rename "magit-files" "\
Rename or move FILE to NEWNAME.
NEWNAME may be a file or directory name.  If FILE isn't tracked in
Git, fallback to using `rename-file'.

(fn FILE NEWNAME)" t)
(autoload 'magit-file-delete "magit-files" "\
Delete the selected FILES or one file read in the minibuffer.

With a prefix argument FORCE do so even when the files have
uncommitted changes.  When the files aren't being tracked in
Git, then fallback to using `delete-file'.

(fn FILES &optional FORCE)" t)
(autoload 'magit-file-checkout "magit-files" "\
Checkout FILE from REV.

(fn REV FILE)" t)
(register-definition-prefixes "magit-files" '("lsp" "magit-"))


;;; Generated autoloads from magit-git.el

(register-definition-prefixes "magit-git" '("magit-"))


;;; Generated autoloads from magit-gitignore.el

(autoload 'magit-gitignore "magit-gitignore" nil t)
(autoload 'magit-gitignore-in-topdir "magit-gitignore" nil t)
(autoload 'magit-gitignore-in-subdir "magit-gitignore" nil t)
(autoload 'magit-gitignore-in-gitdir "magit-gitignore" nil t)
(autoload 'magit-gitignore-on-system "magit-gitignore" nil t)
(autoload 'magit-skip-worktree "magit-gitignore" "\
Call \"git update-index --skip-worktree -- FILE\".

(fn FILE)" t)
(autoload 'magit-no-skip-worktree "magit-gitignore" "\
Call \"git update-index --no-skip-worktree -- FILE\".

(fn FILE)" t)
(autoload 'magit-assume-unchanged "magit-gitignore" "\
Call \"git update-index --assume-unchanged -- FILE\".

(fn FILE)" t)
(autoload 'magit-no-assume-unchanged "magit-gitignore" "\
Call \"git update-index --no-assume-unchanged -- FILE\".

(fn FILE)" t)
(register-definition-prefixes "magit-gitignore" '("magit-"))


;;; Generated autoloads from magit-log.el

(autoload 'magit-log "magit-log" nil t)
(autoload 'magit-log-refresh "magit-log" nil t)
(autoload 'magit-log-current "magit-log" nil t)
(autoload 'magit-log-head "magit-log" "\
Show log for `HEAD'.

(fn &optional ARGS FILES)" t)
(autoload 'magit-log-related "magit-log" "\
Show log for the current branch, its upstream and its push target.
When the upstream is a local branch, then also show its own
upstream.  When `HEAD' is detached, then show log for that, the
previously checked out branch and its upstream and push-target.

(fn REVS &optional ARGS FILES)" t)
(autoload 'magit-log-other "magit-log" "\
Show log for one or more revs read from the minibuffer.
The user can input any revision or revisions separated by a
space, or even ranges, but only branches and tags, and a
representation of the commit at point, are available as
completion candidates.

(fn REVS &optional ARGS FILES)" t)
(autoload 'magit-log-branches "magit-log" "\
Show log for all local branches and `HEAD'.

(fn &optional ARGS FILES)" t)
(autoload 'magit-log-matching-branches "magit-log" "\
Show log for all branches matching PATTERN and `HEAD'.

(fn PATTERN &optional ARGS FILES)" t)
(autoload 'magit-log-matching-tags "magit-log" "\
Show log for all tags matching PATTERN and `HEAD'.

(fn PATTERN &optional ARGS FILES)" t)
(autoload 'magit-log-all-branches "magit-log" "\
Show log for all local and remote branches and `HEAD'.

(fn &optional ARGS FILES)" t)
(autoload 'magit-log-all "magit-log" "\
Show log for all references and `HEAD'.

(fn &optional ARGS FILES)" t)
(autoload 'magit-log-reflog "magit-log" "\
Show log for all objects mentioned in all reflogs.

(fn &optional ARGS FILES)" t)
(autoload 'magit-log-buffer-file "magit-log" "\
Show log for the blob or file visited in the current buffer.
With a prefix argument or when \"--follow\" is an active log
argument, then follow renames.  When the region is active,
restrict the log to the lines that the region touches.

(fn &optional FOLLOW BEG END)" t)
(autoload 'magit-log-trace-definition "magit-log" "\
Show log for the definition at point.

(fn FILE FN COMMIT)" t)
(autoload 'magit-log-merged "magit-log" "\
Show log for the merge of COMMIT into BRANCH.

More precisely, find merge commit M that brought COMMIT into
BRANCH, and show the log of the range \"M^1..M\". If COMMIT is
directly on BRANCH, then show approximately
`magit-log-merged-commit-count' surrounding commits instead.

This command requires git-when-merged, which is available from
https://github.com/mhagger/git-when-merged.

(fn COMMIT BRANCH &optional ARGS FILES)" t)
(autoload 'magit-delete-shelved-branch "magit-log" "\
Delete the shelved BRANCH.
Delete a ref created by `magit-branch-shelve'.

(fn BRANCH)" t)
(autoload 'magit-log-move-to-parent "magit-log" "\
Move to the Nth parent of the current commit.

(fn &optional N)" t)
(autoload 'magit-shortlog "magit-log" nil t)
(autoload 'magit-shortlog-since "magit-log" "\
Show a history summary for commits since REV.

(fn COMMIT ARGS)" t)
(autoload 'magit-shortlog-range "magit-log" "\
Show a history summary for commit or range REV-OR-RANGE.

(fn REV-OR-RANGE ARGS)" t)
(autoload 'magit-cherry "magit-log" "\
Show commits in a branch that are not merged in the upstream branch.

(fn HEAD UPSTREAM)" t)
(register-definition-prefixes "magit-log" '("magit-"))


;;; Generated autoloads from magit-margin.el

(register-definition-prefixes "magit-margin" '("magit-"))


;;; Generated autoloads from magit-merge.el

(autoload 'magit-merge "magit" nil t)
(autoload 'magit-merge-plain "magit-merge" "\
Merge commit REV into the current branch; using default message.

Unless there are conflicts or a prefix argument is used create a
merge commit using a generic commit message and without letting
the user inspect the result.  With a prefix argument pretend the
merge failed to give the user the opportunity to inspect the
merge.

To create an octopus-merge, separate branches with commas.

(git merge --no-edit|--no-commit [ARGS] REV)

(fn REV &optional ARGS NOCOMMIT)" t)
(autoload 'magit-merge-editmsg "magit-merge" "\
Merge commit REV into the current branch; and edit message.

Perform the merge and prepare a commit message but let the user
edit it.

To create an octopus-merge, separate branches with commas.

(git merge --edit --no-ff [ARGS] REV)

(fn REV &optional ARGS)" t)
(autoload 'magit-merge-nocommit "magit-merge" "\
Merge commit REV into the current branch; pretending it failed.

Pretend the merge failed to give the user the opportunity to
inspect the merge and change the commit message.

To create an octopus-merge, separate branches with commas.

(git merge --no-commit --no-ff [ARGS] REV)

(fn REV &optional ARGS)" t)
(autoload 'magit-merge-dissolve "magit-merge" "\
Merge the current branch into BRANCH and remove the former.

Before merging, force push the source branch to its push-remote,
provided the respective remote branch already exists, ensuring
that the respective pull-request (if any) won't get stuck on some
obsolete version of the commits that are being merged.  Finally
if `forge-branch-pullreq' was used to create the merged branch,
then also remove the respective remote branch.

(fn BRANCH &optional ARGS)" t)
(autoload 'magit-merge-absorb "magit-merge" "\
Merge BRANCH into the current branch and remove the former.

Before merging, force push the source branch to its push-remote,
provided the respective remote branch already exists, ensuring
that the respective pull-request (if any) won't get stuck on some
obsolete version of the commits that are being merged.  Finally
if `forge-branch-pullreq' was used to create the merged branch,
then also remove the respective remote branch.

(fn BRANCH &optional ARGS)" t)
(autoload 'magit-merge-squash "magit-merge" "\
Squash commit REV into the current branch; don't create a commit.

(git merge --squash REV)

(fn REV)" t)
(autoload 'magit-merge-preview "magit-merge" "\
Preview result of merging REV into the current branch.

(fn REV)" t)
(autoload 'magit-merge-abort "magit-merge" "\
Abort the current merge operation.

(git merge --abort)" t)
(register-definition-prefixes "magit-merge" '("magit-"))


;;; Generated autoloads from magit-mode.el

(autoload 'magit-info "magit-mode" "\
Visit the Magit manual." t)
(register-definition-prefixes "magit-mode" '("magit-"))


;;; Generated autoloads from magit-notes.el

(autoload 'magit-notes "magit" nil t)
(register-definition-prefixes "magit-notes" '("magit-notes-"))


;;; Generated autoloads from magit-patch.el

(autoload 'magit-patch "magit-patch" nil t)
(autoload 'magit-patch-create "magit-patch" nil t)
(autoload 'magit-patch-apply "magit-patch" nil t)
(autoload 'magit-patch-save "magit-patch" "\
Write current diff into patch FILE.

What arguments are used to create the patch depends on the value
of `magit-patch-save-arguments' and whether a prefix argument is
used.

If the value is the symbol `buffer', then use the same arguments
as the buffer.  With a prefix argument use no arguments.

If the value is a list beginning with the symbol `exclude', then
use the same arguments as the buffer except for those matched by
entries in the cdr of the list.  The comparison is done using
`string-prefix-p'.  With a prefix argument use the same arguments
as the buffer.

If the value is a list of strings (including the empty list),
then use those arguments.  With a prefix argument use the same
arguments as the buffer.

Of course the arguments that are required to actually show the
same differences as those shown in the buffer are always used.

(fn FILE &optional ARG)" t)
(autoload 'magit-request-pull "magit-patch" "\
Request upstream to pull from your public repository.

URL is the url of your publicly accessible repository.
START is a commit that already is in the upstream repository.
END is the last commit, usually a branch name, which upstream
is asked to pull.  START has to be reachable from that commit.

(fn URL START END)" t)
(register-definition-prefixes "magit-patch" '("magit-"))


;;; Generated autoloads from magit-process.el

(register-definition-prefixes "magit-process" '("magit-"))


;;; Generated autoloads from magit-pull.el

(autoload 'magit-pull "magit-pull" nil t)
(autoload 'magit-pull-from-pushremote "magit-pull" nil t)
(autoload 'magit-pull-from-upstream "magit-pull" nil t)
(autoload 'magit-pull-into-upstream "magit-pull" nil t)
(autoload 'magit-pull-branch "magit-pull" "\
Pull from a branch read in the minibuffer.

(fn SOURCE ARGS)" t)
(register-definition-prefixes "magit-pull" '("magit-pull-"))


;;; Generated autoloads from magit-push.el

(autoload 'magit-push "magit-push" nil t)
(autoload 'magit-push-current-to-pushremote "magit-push" nil t)
(autoload 'magit-push-current-to-upstream "magit-push" nil t)
(autoload 'magit-push-current "magit-push" "\
Push the current branch to a branch read in the minibuffer.

(fn TARGET ARGS)" t)
(autoload 'magit-push-other "magit-push" "\
Push an arbitrary branch or commit somewhere.
Both the source and the target are read in the minibuffer.

(fn SOURCE TARGET ARGS)" t)
(autoload 'magit-push-refspecs "magit-push" "\
Push one or multiple REFSPECS to a REMOTE.
Both the REMOTE and the REFSPECS are read in the minibuffer.  To
use multiple REFSPECS, separate them with commas.  Completion is
only available for the part before the colon, or when no colon
is used.

(fn REMOTE REFSPECS ARGS)" t)
(autoload 'magit-push-matching "magit-push" "\
Push all matching branches to another repository.
If multiple remotes exist, then read one from the user.
If just one exists, use that without requiring confirmation.

(fn REMOTE &optional ARGS)" t)
(autoload 'magit-push-tags "magit-push" "\
Push all tags to another repository.
If only one remote exists, then push to that.  Otherwise prompt
for a remote, offering the remote configured for the current
branch as default.

(fn REMOTE &optional ARGS)" t)
(autoload 'magit-push-tag "magit-push" "\
Push a tag to another repository.

(fn TAG REMOTE &optional ARGS)" t)
(autoload 'magit-push-notes-ref "magit-push" "\
Push a notes ref to another repository.

(fn REF REMOTE &optional ARGS)" t)
(autoload 'magit-push-implicitly "magit-push" nil t)
(autoload 'magit-push-to-remote "magit-push" nil t)
(register-definition-prefixes "magit-push" '("magit-"))


;;; Generated autoloads from magit-reflog.el

(autoload 'magit-reflog-current "magit-reflog" "\
Display the reflog of the current branch.
If `HEAD' is detached, then show the reflog for that instead." t)
(autoload 'magit-reflog-other "magit-reflog" "\
Display the reflog of a branch or another ref.

(fn REF)" t)
(autoload 'magit-reflog-head "magit-reflog" "\
Display the `HEAD' reflog." t)
(register-definition-prefixes "magit-reflog" '("magit-reflog-"))


;;; Generated autoloads from magit-refs.el

(autoload 'magit-show-refs "magit-refs" nil t)
(autoload 'magit-show-refs-head "magit-refs" "\
List and compare references in a dedicated buffer.
Compared with `HEAD'.

(fn &optional ARGS)" t)
(autoload 'magit-show-refs-current "magit-refs" "\
List and compare references in a dedicated buffer.
Compare with the current branch or `HEAD' if it is detached.

(fn &optional ARGS)" t)
(autoload 'magit-show-refs-other "magit-refs" "\
List and compare references in a dedicated buffer.
Compared with a branch read from the user.

(fn &optional REF ARGS)" t)
(register-definition-prefixes "magit-refs" '("magit-"))


;;; Generated autoloads from magit-remote.el

(autoload 'magit-remote "magit-remote" nil t)
(autoload 'magit-remote-add "magit-remote" "\
Add a remote named REMOTE and fetch it.

(fn REMOTE URL &optional ARGS)" t)
(autoload 'magit-remote-rename "magit-remote" "\
Rename the remote named OLD to NEW.

(fn OLD NEW)" t)
(autoload 'magit-remote-remove "magit-remote" "\
Delete the remote named REMOTE.

(fn REMOTE)" t)
(autoload 'magit-remote-prune "magit-remote" "\
Remove stale remote-tracking branches for REMOTE.

(fn REMOTE)" t)
(autoload 'magit-remote-prune-refspecs "magit-remote" "\
Remove stale refspecs for REMOTE.

A refspec is stale if there no longer exists at least one branch
on the remote that would be fetched due to that refspec.  A stale
refspec is problematic because its existence causes Git to refuse
to fetch according to the remaining non-stale refspecs.

If only stale refspecs remain, then offer to either delete the
remote or to replace the stale refspecs with the default refspec.

Also remove the remote-tracking branches that were created due to
the now stale refspecs.  Other stale branches are not removed.

(fn REMOTE)" t)
(autoload 'magit-remote-set-head "magit-remote" "\
Set the local representation of REMOTE's default branch.
Query REMOTE and set the symbolic-ref refs/remotes/<remote>/HEAD
accordingly.  With a prefix argument query for the branch to be
used, which allows you to select an incorrect value if you fancy
doing that.

(fn REMOTE &optional BRANCH)" t)
(autoload 'magit-remote-unset-head "magit-remote" "\
Unset the local representation of REMOTE's default branch.
Delete the symbolic-ref \"refs/remotes/<remote>/HEAD\".

(fn REMOTE)" t)
(autoload 'magit-update-default-branch "magit-remote" nil t)
(autoload 'magit-remote-unshallow "magit-remote" "\
Convert a shallow remote into a full one.
If only a single refspec is set and it does not contain a
wildcard, then also offer to replace it with the standard
refspec.

(fn REMOTE)" t)
(autoload 'magit-remote-configure "magit-remote" nil t)
(register-definition-prefixes "magit-remote" '("magit-"))


;;; Generated autoloads from magit-repos.el

(autoload 'magit-list-repositories "magit-repos" "\
Display a list of repositories.

Use the option `magit-repository-directories' to control which
repositories are displayed." t)
(register-definition-prefixes "magit-repos" '("magit-"))


;;; Generated autoloads from magit-reset.el

(autoload 'magit-reset "magit" nil t)
(autoload 'magit-reset-mixed "magit-reset" "\
Reset the `HEAD' and index to COMMIT, but not the working tree.

(git reset --mixed COMMIT)

(fn COMMIT)" t)
(autoload 'magit-reset-soft "magit-reset" "\
Reset the `HEAD' to COMMIT, but not the index and working tree.

(git reset --soft COMMIT)

(fn COMMIT)" t)
(autoload 'magit-reset-hard "magit-reset" "\
Reset the `HEAD', index, and working tree to COMMIT.

(git reset --hard COMMIT)

(fn COMMIT)" t)
(autoload 'magit-reset-keep "magit-reset" "\
Reset the `HEAD' and index to COMMIT, while keeping uncommitted changes.

(git reset --keep COMMIT)

(fn COMMIT)" t)
(autoload 'magit-reset-index "magit-reset" "\
Reset the index to COMMIT.
Keep the `HEAD' and working tree as-is, so if COMMIT refers to the
head this effectively unstages all changes.

(git reset COMMIT .)

(fn COMMIT)" t)
(autoload 'magit-reset-worktree "magit-reset" "\
Reset the worktree to COMMIT.
Keep the `HEAD' and index as-is.

(fn COMMIT)" t)
(autoload 'magit-reset-quickly "magit-reset" "\
Reset the `HEAD' and index to COMMIT, and possibly the working tree.
With a prefix argument reset the working tree otherwise don't.

(git reset --mixed|--hard COMMIT)

(fn COMMIT &optional HARD)" t)
(register-definition-prefixes "magit-reset" '("magit-reset-"))


;;; Generated autoloads from magit-sequence.el

(autoload 'magit-sequencer-continue "magit-sequence" "\
Resume the current cherry-pick or revert sequence." t)
(autoload 'magit-sequencer-skip "magit-sequence" "\
Skip the stopped at commit during a cherry-pick or revert sequence." t)
(autoload 'magit-sequencer-abort "magit-sequence" "\
Abort the current cherry-pick or revert sequence.
This discards all changes made since the sequence started." t)
(autoload 'magit-cherry-pick "magit-sequence" nil t)
(autoload 'magit-cherry-copy "magit-sequence" "\
Copy COMMITS from another branch onto the current branch.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then pick all of them,
without prompting.

(fn COMMITS &optional ARGS)" t)
(autoload 'magit-cherry-apply "magit-sequence" "\
Apply the changes in COMMITS but do not commit them.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then apply all of them,
without prompting.

(fn COMMITS &optional ARGS)" t)
(autoload 'magit-cherry-harvest "magit-sequence" "\
Move COMMITS from another BRANCH onto the current branch.
Remove the COMMITS from BRANCH and stay on the current branch.
If a conflict occurs, then you have to fix that and finish the
process manually.

(fn COMMITS BRANCH &optional ARGS)" t)
(autoload 'magit-cherry-donate "magit-sequence" "\
Move COMMITS from the current branch onto another existing BRANCH.
Remove COMMITS from the current branch and stay on that branch.
If a conflict occurs, then you have to fix that and finish the
process manually.  `HEAD' is allowed to be detached initially.

(fn COMMITS BRANCH &optional ARGS)" t)
(autoload 'magit-cherry-spinout "magit-sequence" "\
Move COMMITS from the current branch onto a new BRANCH.
Remove COMMITS from the current branch and stay on that branch.
If a conflict occurs, then you have to fix that and finish the
process manually.

(fn COMMITS BRANCH START-POINT &optional ARGS)" t)
(autoload 'magit-cherry-spinoff "magit-sequence" "\
Move COMMITS from the current branch onto a new BRANCH.
Remove COMMITS from the current branch and checkout BRANCH.
If a conflict occurs, then you have to fix that and finish
the process manually.

(fn COMMITS BRANCH START-POINT &optional ARGS)" t)
(autoload 'magit-revert "magit-sequence" nil t)
(autoload 'magit-revert-and-commit "magit-sequence" "\
Revert COMMIT by creating a new commit.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then revert all of them,
without prompting.

(fn COMMIT &optional ARGS)" t)
(autoload 'magit-revert-no-commit "magit-sequence" "\
Revert COMMIT by applying it in reverse to the worktree.
Prompt for a commit, defaulting to the commit at point.  If
the region selects multiple commits, then revert all of them,
without prompting.

(fn COMMIT &optional ARGS)" t)
(autoload 'magit-am "magit-sequence" nil t)
(autoload 'magit-am-apply-patches "magit-sequence" "\
Apply the patches FILES.

(fn &optional FILES ARGS)" t)
(autoload 'magit-am-apply-maildir "magit-sequence" "\
Apply the patches from MAILDIR.

(fn &optional MAILDIR ARGS)" t)
(autoload 'magit-am-continue "magit-sequence" "\
Resume the current patch applying sequence." t)
(autoload 'magit-am-skip "magit-sequence" "\
Skip the stopped at patch during a patch applying sequence." t)
(autoload 'magit-am-abort "magit-sequence" "\
Abort the current patch applying sequence.
This discards all changes made since the sequence started." t)
(autoload 'magit-rebase "magit-sequence" nil t)
(autoload 'magit-rebase-onto-pushremote "magit-sequence" nil t)
(autoload 'magit-rebase-onto-upstream "magit-sequence" nil t)
(autoload 'magit-rebase-branch "magit-sequence" "\
Rebase the current branch onto a branch read in the minibuffer.
All commits that are reachable from `HEAD' but not from the
selected branch TARGET are being rebased.

(fn TARGET ARGS)" t)
(autoload 'magit-rebase-subset "magit-sequence" "\
Rebase a subset of the current branch's history onto a new base.
Rebase commits from START to `HEAD' onto NEWBASE.
START has to be selected from a list of recent commits.

(fn NEWBASE START ARGS)" t)
(autoload 'magit-rebase-interactive "magit-sequence" "\
Start an interactive rebase sequence.

(fn COMMIT ARGS)" t)
(autoload 'magit-rebase-autosquash "magit-sequence" "\
Combine squash and fixup commits with their intended targets.
By default only squash into commits that are not reachable from
the upstream branch.  If no upstream is configured or with a prefix
argument, prompt for the first commit to potentially squash into.

(fn SELECT ARGS)" t)
(autoload 'magit-rebase-edit-commit "magit-sequence" "\
Edit a single older commit using rebase.

(fn COMMIT ARGS)" t)
(autoload 'magit-rebase-reword-commit "magit-sequence" "\
Reword a single older commit using rebase.

(fn COMMIT ARGS)" t)
(autoload 'magit-rebase-remove-commit "magit-sequence" "\
Remove a single older commit using rebase.

(fn COMMIT ARGS)" t)
(autoload 'magit-rebase-continue "magit-sequence" "\
Restart the current rebasing operation.
In some cases this pops up a commit message buffer for you do
edit.  With a prefix argument the old message is reused as-is.

(fn &optional NOEDIT)" t)
(autoload 'magit-rebase-skip "magit-sequence" "\
Skip the current commit and restart the current rebase operation." t)
(autoload 'magit-rebase-edit "magit-sequence" "\
Edit the todo list of the current rebase operation." t)
(autoload 'magit-rebase-abort "magit-sequence" "\
Abort the current rebase operation, restoring the original branch." t)
(register-definition-prefixes "magit-sequence" '("magit-"))


;;; Generated autoloads from magit-sparse-checkout.el

(autoload 'magit-sparse-checkout "magit-sparse-checkout" nil t)
(autoload 'magit-sparse-checkout-enable "magit-sparse-checkout" "\
Convert the working tree to a sparse checkout.

(fn &optional ARGS)" t)
(autoload 'magit-sparse-checkout-set "magit-sparse-checkout" "\
Restrict working tree to DIRECTORIES.
To extend rather than override the currently configured
directories, call `magit-sparse-checkout-add' instead.

(fn DIRECTORIES)" t)
(autoload 'magit-sparse-checkout-add "magit-sparse-checkout" "\
Add DIRECTORIES to the working tree.
To override rather than extend the currently configured
directories, call `magit-sparse-checkout-set' instead.

(fn DIRECTORIES)" t)
(autoload 'magit-sparse-checkout-reapply "magit-sparse-checkout" "\
Reapply the sparse checkout rules to the working tree.
Some operations such as merging or rebasing may need to check out
files that aren't included in the sparse checkout.  Call this
command to reset to the sparse checkout state." t)
(autoload 'magit-sparse-checkout-disable "magit-sparse-checkout" "\
Convert sparse checkout to full checkout.
Note that disabling the sparse checkout does not clear the
configured directories.  Call `magit-sparse-checkout-enable' to
restore the previous sparse checkout." t)
(register-definition-prefixes "magit-sparse-checkout" '("magit-sparse-checkout-"))


;;; Generated autoloads from magit-stash.el

(autoload 'magit-stash "magit-stash" nil t)
(autoload 'magit-stash-both "magit-stash" "\
Create a stash of the index and working tree.
Untracked files are included according to infix arguments.
One prefix argument is equivalent to \"--include-untracked\"
while two prefix arguments are equivalent to \"--all\".

(fn MESSAGE &optional INCLUDE-UNTRACKED)" t)
(autoload 'magit-stash-index "magit-stash" "\
Create a stash of the index only.
Unstaged and untracked changes are not stashed.  The stashed
changes are applied in reverse to both the index and the
worktree.  This command can fail when the worktree is not clean.
Applying the resulting stash has the inverse effect.

(fn MESSAGE)" t)
(autoload 'magit-stash-worktree "magit-stash" "\
Create a stash of unstaged changes in the working tree.
Untracked files are included according to infix arguments.
One prefix argument is equivalent to \"--include-untracked\"
while two prefix arguments are equivalent to \"--all\".

(fn MESSAGE &optional INCLUDE-UNTRACKED)" t)
(autoload 'magit-stash-keep-index "magit-stash" "\
Create a stash of the index and working tree, keeping index intact.
Untracked files are included according to infix arguments.
One prefix argument is equivalent to \"--include-untracked\"
while two prefix arguments are equivalent to \"--all\".

(fn MESSAGE &optional INCLUDE-UNTRACKED)" t)
(autoload 'magit-snapshot-both "magit-stash" "\
Create a snapshot of the index and working tree.
Untracked files are included according to infix arguments.
One prefix argument is equivalent to \"--include-untracked\"
while two prefix arguments are equivalent to \"--all\".

(fn &optional INCLUDE-UNTRACKED)" t)
(autoload 'magit-snapshot-index "magit-stash" "\
Create a snapshot of the index only.
Unstaged and untracked changes are not stashed." t)
(autoload 'magit-snapshot-worktree "magit-stash" "\
Create a snapshot of unstaged changes in the working tree.
Untracked files are included according to infix arguments.
One prefix argument is equivalent to \"--include-untracked\"
while two prefix arguments are equivalent to \"--all\".

(fn &optional INCLUDE-UNTRACKED)" t)
(autoload 'magit-stash-push "magit-stash" nil t)
(autoload 'magit-stash-apply "magit-stash" "\
Apply a stash to the working tree.

When using a Git release before v2.38.0, simply run \"git stash
apply\" or with a prefix argument \"git stash apply --index\".

When using Git v2.38.0 or later, behave more intelligently:

First try \"git stash apply --index\", which tries to preserve the
index stored in the stash, if any.  This may fail because applying
the stash could result in conflicts and those have to be stored in
the index, making it impossible to also store the stash's index
there.

If \"git stash\" fails, then potentially fall back to using \"git
apply\".  If the stash does not touch any unstaged files, then pass
\"--3way\" to that command.  Otherwise ask the user whether to use
that argument or \"--reject\".  Customize `magit-no-confirm' if you
want to fall back to using \"--3way\", without being prompted.

(fn STASH)" t)
(autoload 'magit-stash-pop "magit-stash" "\
Apply a stash to the working tree, on success remove it from stash list.

When using a Git release before v2.38.0, simply run \"git stash
pop\" or with a prefix argument \"git stash pop --index\".

When using Git v2.38.0 or later, behave more intelligently:

First try \"git stash apply --index\", which tries to preserve the
index stored in the stash, if any.  This may fail because applying
the stash could result in conflicts and those have to be stored in
the index, making it impossible to also store the stash's index
there.

If \"git stash\" fails, then potentially fall back to using \"git
apply\".  If the stash does not touch any unstaged files, then pass
\"--3way\" to that command.  Otherwise ask the user whether to use
that argument or \"--reject\".  Customize `magit-no-confirm' if you
want to fall back to using \"--3way\", without being prompted.

(fn STASH)" t)
(autoload 'magit-stash-drop "magit-stash" "\
Remove a stash from the stash list.
When the region is active offer to drop all contained stashes.

(fn STASH)" t)
(autoload 'magit-stash-clear "magit-stash" "\
Remove all stashes saved in REF's reflog by deleting REF.

(fn REF)" t)
(autoload 'magit-stash-branch "magit-stash" "\
Create and checkout a new BRANCH from an existing STASH.
The new branch starts at the commit that was current when the
stash was created.  If the stash applies cleanly, then drop it.

(fn STASH BRANCH)" t)
(autoload 'magit-stash-branch-here "magit-stash" "\
Create and checkout a new BRANCH from an existing STASH.
Use the current branch or `HEAD' as the starting-point of BRANCH.
Then apply STASH, dropping it if it applies cleanly.

(fn STASH BRANCH)" t)
(autoload 'magit-stash-format-patch "magit-stash" "\
Create a patch from STASH.

(fn STASH)" t)
(autoload 'magit-stash-list "magit-stash" "\
List all stashes in a buffer." t)
(autoload 'magit-stash-show "magit-stash" "\
Show all diffs of a stash in a buffer.

(fn STASH &optional ARGS FILES)" t)
(register-definition-prefixes "magit-stash" '("magit-"))


;;; Generated autoloads from magit-status.el

(autoload 'magit-init "magit-status" "\
Initialize a Git repository, then show its status.

If the directory is below an existing repository, then the user
has to confirm that a new one should be created inside.  If the
directory is the root of the existing repository, then the user
has to confirm that it should be reinitialized.

Non-interactively DIRECTORY is (re-)initialized unconditionally.

(fn DIRECTORY)" t)
(autoload 'magit-status "magit-status" "\
Show the status of the current Git repository in a buffer.

If the current directory isn't located within a Git repository,
then prompt for an existing repository or an arbitrary directory,
depending on option `magit-repository-directories', and show the
status of the selected repository instead.

* If that option specifies any existing repositories, then offer
  those for completion and show the status buffer for the
  selected one.

* Otherwise read an arbitrary directory using regular file-name
  completion.  If the selected directory is the top-level of an
  existing working tree, then show the status buffer for that.

* Otherwise offer to initialize the selected directory as a new
  repository.  After creating the repository show its status
  buffer.

These fallback behaviors can also be forced using one or more
prefix arguments:

* With two prefix arguments (or more precisely a numeric prefix
  value of 16 or greater) read an arbitrary directory and act on
  it as described above.  The same could be accomplished using
  the command `magit-init'.

* With a single prefix argument read an existing repository, or
  if none can be found based on `magit-repository-directories',
  then fall back to the same behavior as with two prefix
  arguments.

(fn &optional DIRECTORY CACHE)" t)
(defalias 'magit #'magit-status "\
Begin using Magit.

This alias for `magit-status' exists for better discoverability.

Instead of invoking this alias for `magit-status' using
\"M-x magit RET\", you should bind a key to `magit-status'
and read the info node `(magit)Getting Started', which
also contains other useful hints.")
(autoload 'magit-status-here "magit-status" "\
Like `magit-status' but with non-nil `magit-status-goto-file-position'.
Before doing so, save all file-visiting buffers belonging to the current
repository without prompting." t)
(autoload 'magit-status-quick "magit-status" "\
Show the status of the current Git repository, maybe without refreshing.

If the status buffer of the current Git repository exists but
isn't being displayed in the selected frame, then display it
without refreshing it.

If the status buffer is being displayed in the selected frame,
then also refresh it.

Prefix arguments have the same meaning as for `magit-status',
and additionally cause the buffer to be refresh.

To use this function instead of `magit-status', add this to your
init file: (global-set-key (kbd \"C-x g\") \\='magit-status-quick).

Non-interactively another repository can be specified using the
optional DIRECTORY argument, which must then name the top-level
directory of an existing repository.

(fn &optional DIRECTORY)" t)
(autoload 'magit-status-setup-buffer "magit-status" "\


(fn &optional DIRECTORY)")
(register-definition-prefixes "magit-status" '("magit-"))


;;; Generated autoloads from magit-submodule.el

(autoload 'magit-submodule "magit-submodule" nil t)
(autoload 'magit-submodule-add "magit-submodule" nil t)
(autoload 'magit-submodule-read-name-for-path "magit-submodule" "\


(fn PATH &optional PREFER-SHORT)")
(autoload 'magit-submodule-register "magit-submodule" nil t)
(autoload 'magit-submodule-populate "magit-submodule" nil t)
(autoload 'magit-submodule-update "magit-submodule" nil t)
(autoload 'magit-submodule-synchronize "magit-submodule" nil t)
(autoload 'magit-submodule-unpopulate "magit-submodule" nil t)
(autoload 'magit-submodule-remove "magit-submodule" "\
Unregister MODULES and remove their working directories.

For safety reasons, do not remove the gitdirs and if a module has
uncommitted changes, then do not remove it at all.  If a module's
gitdir is located inside the working directory, then move it into
the gitdir of the superproject first.

With the \"--force\" argument offer to remove dirty working
directories and with a prefix argument offer to delete gitdirs.
Both actions are very dangerous and have to be confirmed.  There
are additional safety precautions in place, so you might be able
to recover from making a mistake here, but don't count on it.

(fn MODULES ARGS TRASH-GITDIRS)" t)
(autoload 'magit-insert-modules "magit-submodule" "\
Insert submodule sections.
Hook `magit-module-sections-hook' controls which module sections
are inserted, and option `magit-module-sections-nested' controls
whether they are wrapped in an additional section.")
(autoload 'magit-insert-modules-overview "magit-submodule" "\
Insert sections for all modules.
For each section insert the path and the output of \"git describe --tags\",
or, failing that, the abbreviated HEAD commit hash.")
(autoload 'magit-insert-modules-unpulled-from-upstream "magit-submodule" "\
Insert sections for modules that haven't been pulled from the upstream.
These sections can be expanded to show the respective commits.")
(autoload 'magit-insert-modules-unpulled-from-pushremote "magit-submodule" "\
Insert sections for modules that haven't been pulled from the push-remote.
These sections can be expanded to show the respective commits.")
(autoload 'magit-insert-modules-unpushed-to-upstream "magit-submodule" "\
Insert sections for modules that haven't been pushed to the upstream.
These sections can be expanded to show the respective commits.")
(autoload 'magit-insert-modules-unpushed-to-pushremote "magit-submodule" "\
Insert sections for modules that haven't been pushed to the push-remote.
These sections can be expanded to show the respective commits.")
(autoload 'magit-list-submodules "magit-submodule" "\
Display a list of the current repository's populated submodules." t)
(register-definition-prefixes "magit-submodule" '("magit-"))


;;; Generated autoloads from magit-subtree.el

(autoload 'magit-subtree "magit-subtree" nil t)
(autoload 'magit-subtree-import "magit-subtree" nil t)
(autoload 'magit-subtree-export "magit-subtree" nil t)
(autoload 'magit-subtree-add "magit-subtree" "\
Add REF from REPOSITORY as a new subtree at PREFIX.

(fn PREFIX REPOSITORY REF ARGS)" t)
(autoload 'magit-subtree-add-commit "magit-subtree" "\
Add COMMIT as a new subtree at PREFIX.

(fn PREFIX COMMIT ARGS)" t)
(autoload 'magit-subtree-merge "magit-subtree" "\
Merge COMMIT into the PREFIX subtree.

(fn PREFIX COMMIT ARGS)" t)
(autoload 'magit-subtree-pull "magit-subtree" "\
Pull REF from REPOSITORY into the PREFIX subtree.

(fn PREFIX REPOSITORY REF ARGS)" t)
(autoload 'magit-subtree-push "magit-subtree" "\
Extract the history of the subtree PREFIX and push it to REF on REPOSITORY.

(fn PREFIX REPOSITORY REF ARGS)" t)
(autoload 'magit-subtree-split "magit-subtree" "\
Extract the history of the subtree PREFIX.

(fn PREFIX COMMIT ARGS)" t)
(register-definition-prefixes "magit-subtree" '("magit-"))


;;; Generated autoloads from magit-tag.el

(autoload 'magit-tag "magit" nil t)
(autoload 'magit-tag-create "magit-tag" "\
Create a new tag with the given NAME at COMMIT.
With a prefix argument annotate the tag.

(git tag [--annotate] NAME REV)

(fn NAME COMMIT &optional ARGS)" t)
(autoload 'magit-tag-delete "magit-tag" "\
Delete one or more tags.
If the region marks multiple tags (and nothing else), then offer
to delete those, otherwise prompt for a single tag to be deleted,
defaulting to the tag at point.

(git tag -d TAGS)

(fn TAGS)" t)
(autoload 'magit-tag-prune "magit-tag" "\
Offer to delete tags missing locally from REMOTE, and vice versa.

(fn TAGS REMOTE-TAGS REMOTE)" t)
(autoload 'magit-tag-release "magit-tag" "\
Create a release tag for `HEAD'.

Assume that release tags match `magit-release-tag-regexp'.

If `HEAD's message matches `magit-release-commit-regexp', then
base the tag on the version string specified by that.  Otherwise
prompt for the name of the new tag using the highest existing
tag as initial input and leaving it to the user to increment the
desired part of the version string.

When creating an annotated tag, prepare a message based on the message
of the highest existing tag, provided that contains the corresponding
version string, and substituting the new version string for that.  If
that is not the case, propose a message using a reasonable format.

(fn TAG MSG &optional ARGS)" t)
(register-definition-prefixes "magit-tag" '("magit-"))


;;; Generated autoloads from magit-transient.el

(register-definition-prefixes "magit-transient" '("magit-"))


;;; Generated autoloads from magit-wip.el

(defvar magit-wip-mode nil "\
Non-nil if Magit-Wip mode is enabled.
See the `magit-wip-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `magit-wip-mode'.")
(custom-autoload 'magit-wip-mode "magit-wip" nil)
(autoload 'magit-wip-mode "magit-wip" "\
Automatically save uncommitted changes to work-in-progress refs.

This is a global minor mode.  If called interactively, toggle the
`Magit-Wip mode' mode.  If the prefix argument is positive, enable the
mode, and if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the mode
if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `(default-value \\='magit-wip-mode)'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

(fn &optional ARG)" t)
(register-definition-prefixes "magit-wip" '("magit-"))


;;; Generated autoloads from magit-worktree.el

(autoload 'magit-worktree "magit-worktree" nil t)
(autoload 'magit-worktree-checkout "magit-worktree" "\
Checkout COMMIT in a new worktree in DIRECTORY.
COMMIT may, but does not have to be, a local branch.
Interactively, use `magit-read-worktree-directory-function'.

(fn DIRECTORY COMMIT)" t)
(autoload 'magit-worktree-branch "magit-worktree" "\
Create a new BRANCH and check it out in a new worktree at DIRECTORY.
Interactively, use `magit-read-worktree-directory-function'.

(fn DIRECTORY BRANCH START-POINT)" t)
(autoload 'magit-worktree-move "magit-worktree" "\
Move existing WORKTREE directory to DIRECTORY.

(fn WORKTREE DIRECTORY)" t)
(register-definition-prefixes "magit-worktree" '("magit-"))

;;; End of scraped data

(provide 'magit-autoloads)

;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; no-native-compile: t
;; coding: utf-8-emacs-unix
;; End:

;;; magit-autoloads.el ends here
