Package: magit

Defined variables (351)

magit-reflog-mode-mapKeymap for `magit-reflog-mode'.
magit-reflog-mode-abbrev-tableAbbrev table for `magit-reflog-mode'.
magit-reflog-mode-syntax-tableSyntax table for `magit-reflog-mode'.
magit-reflog-marginFormat of the margin in `magit-reflog-mode' buffers.
magit-reflog-mode-hookHook run after entering `magit-reflog-mode'.
magit-reflog-limitMaximal number of entries initially shown in reflog buffers.
magit--age-specTime units used when formatting relative commit ages.
magit-margin-default-time-formatSee https://github.com/magit/magit/pull/4605.
magit-pull-or-fetchWhether `magit-pull' also offers some fetch suffixes.
magit-release-commit-regexpRegexp used by `magit-tag-release' to parse release commit messages.
magit-tag-version-regexp-alistOverrides `version-regexp-alist' for `magit-tag-release'.
magit-release-tag-regexpRegexp used by `magit-tag-release' to parse release tags.
magit-refs-show-remote-prefixWhether to show the remote prefix in lists of remote branches.
magit-refs-sections-hookHook run to insert sections into a references buffer.
magit-refs-show-commit-countWhether to show commit counts in Magit-Refs mode buffers.
magit-branch-section-mapKeymap for `branch' sections.
magit-refs-mode-hookHook run after entering Magit-Refs mode.
magit-shelved-branch-section-mapKeymap for `shelved-branch' sections.
magit-refs-mode-abbrev-tableAbbrev table for `magit-refs-mode'.
magit-refs-mode-syntax-tableSyntax table for `magit-refs-mode'.
magit-refs-mode-mapKeymap for `magit-refs-mode'.
magit-refs-pad-commit-countsWhether to pad all counts on all sides in `magit-refs-mode' buffers.
magit-refs-marginFormat of the margin in `magit-refs-mode' buffers.
magit-refs-show-push-remoteWhether to show the push-remotes of local branches.
magit-refs-show-branch-descriptionsWhether to show the description, if any, of local branches.
magit-refs-margin-for-tagsWhether to show information about tags in the margin.
magit-visit-ref-behaviorControl how `magit-visit-ref' behaves in `magit-refs-mode' buffers.
magit-refs-primary-column-widthWidth of the focus column in `magit-refs-mode' buffers.
magit-refs-focus-column-widthWidth of the focus column in `magit-refs-mode' buffers.
magit-remote-section-mapKeymap for `remote' sections.
magit-tag-section-mapKeymap for `tag' sections.
magit-refs-filter-alistAlist controlling which refs are omitted from `magit-refs-mode' buffers.
magit-auto-revert-modeNon-nil if Magit-Auto-Revert mode is enabled.
auto-revert-buffer-list-filterFilter that determines which buffers `auto-revert-buffers' reverts.
magit-auto-revert-immediatelyWhether Magit reverts buffers immediately.
magit-auto-revert-counterIncremented each time `auto-revert-buffers' is called.
magit-auto-revert-mode-hookHook run after entering or leaving `magit-auto-revert-mode'.
magit-auto-revert-tracked-onlyWhether `magit-auto-revert-mode' only reverts tracked files.
magit-wip-mode-lighterLighter for Magit-Wip mode.
magit-wip-mode-hookHook run after entering or leaving `magit-wip-mode'.
magit-wip-modeNon-nil if Magit-Wip mode is enabled.
magit-wip-namespaceNamespace used for work-in-progress refs.
magit-wip-merge-branchWhether to merge the current branch into its wip ref.
magit-wip-debugWhether to record commands used to update wip refs.
magit-prefer-push-defaultWhether to prefer `remote.pushDefault' over per-branch variables.
magit-remote-add-set-remote.pushDefaultWhether to set the value of `remote.pushDefault' after adding a remote.
magit-remote-direct-configureWhether the command `magit-remote' shows Git variables.
magit-read-worktree-directory-functionFunction used to read the directory to be used as a new worktree.
magit-worktree-read-directory-name-functionLike `magit-read-worktree-directory-function' but takes only one argument.
magit-worktree-section-mapKeymap for `worktree' sections.
magit-read-worktree-offsite-directoryBase directory used by `magit-read-worktree-directory-offsite'.
magit-show-process-buffer-hintWhether to append hint about process buffer to Git error messages.
magit-process-finish-apply-ansi-colorsWhether and when to apply color escapes in the process buffer.
magit-tramp-pipe-stty-settingsOverride `tramp-pipe-stty-settings' in `magit-start-process'.
magit-process-prompt-functionsList of functions used to forward arbitrary questions to the user.
magit-process-timestamp-formatFormat of timestamp for each process in the process buffer.
magit-mode-line-process-mapKeymap for `mode-line-process'.
magit-need-cygwin-noglobWhether to use a workaround for Cygwin's globbing behavior.
magit-process-mode-abbrev-tableAbbrev table for `magit-process-mode'.
magit-process-log-maxMaximum number of sections to keep in a process log buffer.
magit-process-username-prompt-regexpsList of regexps matching username prompts of Git and its subprocesses.
magit-process-yes-or-no-prompt-regexpRegexp matching Yes-or-No prompts of Git and its subprocesses.
magit-credential-hookHook run before Git needs credentials.
magit-process-error-tooltip-max-linesThe number of lines for `magit-process-error-lines' to return.
magit-process-apply-ansi-colorsWhether and when to apply color escapes in the process buffer.
magit-process-find-password-functionsList of functions to try in sequence to get a password.
magit-process-mode-hookHook run after entering `magit-process-mode'.
magit-credential-cache-daemon-socketIf non-nil, start a credential cache daemon using this socket.
magit-process-popup-timePopup the process buffer if a command takes longer than this many seconds.
magit-process-connection-typeConnection type used for the Git process.
magit-process-mode-syntax-tableSyntax table for `magit-process-mode'.
magit-process-password-prompt-regexpsList of regexps matching password prompts of Git and its subprocesses.
magit-process-display-mode-line-errorWhether Magit should retain and highlight process errors in the mode line.
magit-process-ensure-unix-line-endingWhether Magit should ensure a unix coding system when talking to Git.
magit-process-mode-mapKeymap for `magit-process-mode'.
magit-versionThe version of Magit that you're using.
magit-define-global-key-bindingsWhich set of key bindings to add to the global keymap, if any.
magit-openpgp-default-signing-keyFingerprint of your default Openpgp key used for signing.
magit-shell-command-verbose-promptWhether to show the working directory when reading a command.
magit-branch-delete-never-verifyWhether `magit-branch-delete' always pushes with "--no-verify".
magit-published-branchesList of branches that are considered to be published.
magit-branch-rename-push-targetWhether the push-remote setup is preserved when renaming a branch.
magit-branch-name-suggestionsList of names and/or prefixes suggested when naming a new branch.
magit-branch-read-upstream-firstWhether to read upstream before name of new branch when creating a branch.
magit-branch-prefer-remote-upstreamWhether to favor remote upstreams when creating new branches.
magit-branch-adjust-remote-upstream-alistAlist of upstreams to be used when branching from remote branches.
magit-branch-direct-configureWhether the command `magit-branch' shows Git variables.
git-commit-cd-to-toplevelWhether to set `default-directory' to the worktree in message buffer.
git-commit-major-modeMajor mode used to edit Git commit messages.
git-commit-setup-hookHook run at the end of `git-commit-setup'.
git-commit-known-pseudo-headersA list of Git trailers to be highlighted.
git-commit-elisp-text-mode-mapKeymap for `git-commit-elisp-text-mode'.
git-commit-finish-query-functionsList of functions called to query before performing commit.
git-commit-elisp-text-mode-syntax-tableSyntax table for `git-commit-elisp-text-mode'.
git-commit-use-local-message-ringWhether to use a local message ring instead of the global one.
git-commit-comment-headingsAlso fontified outside of comments in `git-commit-font-lock-keywords-2'.
git-commit-mode-hookThis variable is an alias for `git-commit-setup-hook' (which see).
git-commit-redundant-bindingsBindings made redundant by `git-commit-insert-trailer'.
git-commit-font-lock-keywordsFont-Lock keywords for Git-Commit mode.
git-commit-mode-menuGit Commit Mode Menu.
git-commit-mode-mapKeymap used by `git-commit-mode'.
git-commit-elisp-text-mode-hookHook run after entering `git-commit-elisp-text-mode'.
git-commit-post-finish-hook-timeoutTime in seconds to wait for git to create a commit.
git-commit-header-line-formatIf non-nil, header line format used by `git-commit-mode'.
git-commit-summary-max-lengthColumn beyond which characters in the summary lines are highlighted.
global-git-commit-mode-hookHook run after entering or leaving `global-git-commit-mode'.
global-git-commit-modeNon-nil if Global Git-Commit mode is enabled.
git-commit-elisp-text-mode-abbrev-tableAbbrev table for `git-commit-elisp-text-mode'.
git-commit-trailersA list of Git trailers to be highlighted.
git-commit-post-finish-hookHook run after the user finished writing a commit message.
git-commit-need-summary-lineWhether the text should have a heading that is separated from the body.
git-commit-usage-messageMessage displayed when editing a commit message.
git-commit-style-convention-checksList of checks performed by `git-commit-check-style-conventions'.
git-commit-modeNon-nil if Git-Commit mode is enabled.
magit-clone-default-directoryDefault directory to use when `magit-clone' reads destination.
magit-clone-always-transientWhether `magit-clone' always acts as a transient prefix command.
magit-clone-url-formatFormat(s) used when turning repository names into urls.
magit-clone-name-alistAlist mapping repository names to repository urls.
magit-post-clone-hookHook run after the repository has been successfully cloned.
magit-clone-set-remote.pushDefaultWhether to set the value of `remote.pushDefault' after cloning.
magit-clone-set-remote-headWhether cloning creates the symbolic-ref `<remote>/HEAD'.
magit-common-git-post-commit-functionsHook run by Git hooks `post-commit', `post-merge' and `post-rewrite'.
magit-commit-reword-override-dateWhether using `magit-commit-reword' changes the committer date.
magit-commit-show-diffWhether the relevant diff is automatically shown when committing.
magit-commit-extend-override-dateWhether using `magit-commit-extend' changes the committer date.
magit-post-commit-hookHook run after creating a commit without the user editing a message.
magit-commit-ask-to-stageWhether to ask to stage everything when committing and nothing is staged.
magit-commit-add-log-insert-functionUsed by `magit-commit-add-log' to insert a single entry.
magit-commit-squash-confirmWhether the commit targeted by squash and fixup has to be confirmed.
magit-commit-diff-inhibit-same-windowWhether to inhibit use of same window when showing diff while committing.
magit-module-sections-hookHook run by `magit-insert-modules'.
magit-submodule-list-mode-mapLocal keymap for Magit-Submodule-List mode buffers.
magit-submodule-list-mode-hookHook run after entering Magit-Submodule-List mode.
magit-submodule-list-sort-keyInitial sort key for buffer created by `magit-list-submodules'.
magit-submodule-remove-trash-gitdirsWhether `magit-submodule-remove' offers to trash module gitdirs.
magit-submodule-list-mode-abbrev-tableAbbrev table for `magit-submodule-list-mode'.
magit-submodule-list-columnsList of columns displayed by `magit-list-submodules'.
magit-module-section-mapKeymap for `module' sections.
magit-submodule-list-mode-syntax-tableSyntax table for `magit-submodule-list-mode'.
magit-modules-section-mapKeymap for `modules' sections.
magit-submodule-list-predicatePredicate used to determine whether to include a module in the list.
magit-module-sections-nestedWhether `magit-insert-modules' wraps inserted sections.
magit-push-optionsChoices offered when setting "--push-options" in the push menu.
magit-status-mode-syntax-tableSyntax table for `magit-status-mode'.
magit-status-initial-sectionThe section point is placed on when a status buffer is created.
magit-status-show-hashes-in-headersWhether headers in the status buffer show hashes.
magit-error-section-mapKeymap for `error' sections.
magit-status-use-buffer-argumentsWhether `magit-status' reuses arguments when the buffer already exists.
magit-status-mode-mapKeymap for `magit-status-mode'.
magit-status-sections-hookHook run to insert sections into a status buffer.
magit-status-mode-abbrev-tableAbbrev table for `magit-status-mode'.
magit-status-marginFormat of the margin in `magit-status-mode' buffers.
magit-status-goto-file-positionWhether to go to position corresponding to file position.
magit-untracked-section-mapKeymap for the `untracked' section.
magit-status-show-untracked-filesWhether to list untracked files in the status buffer.
magit-status-headers-hookHook run to insert headers into the status buffer.
magit-status-mode-hookHook run after entering Magit-Status mode.
magit-status-file-list-limitHow many files to list in file list sections in the status buffer.
magit-cherry-mode-mapKeymap for `magit-cherry-mode'.
magit-module-commit-section-mapKeymap for `module-commit' sections.
magit-cherry-mode-syntax-tableSyntax table for `magit-cherry-mode'.
magit-log-buffer-file-lockedWhether `magit-log-buffer-file-quick' uses a dedicated buffer.
magit-log-trailer-labelsWhether and how to insert labels, derived from commit message trailers.
magit-log-marginFormat of the margin in `magit-log-mode' buffers.
magit-cherry-sections-hookHook run to insert sections into the cherry buffer.
magit-log-mode-abbrev-tableAbbrev table for `magit-log-mode'.
magit-cherry-marginFormat of the margin in `magit-cherry-mode' buffers.
magit-cherry-mode-abbrev-tableAbbrev table for `magit-cherry-mode'.
magit-log-disable-graph-hack-argsArguments which disable the graph speedup hack.
magit-log-merged-commit-countHow many surrounding commits to show for `magit-log-merged'.
magit-log-show-refname-after-summaryWhether to show refnames after commit summaries.
magit-log-select-mode-mapKeymap for `magit-log-select-mode'.
magit-log-select-mode-hookHook run after entering `magit-log-select-mode'.
magit-log-section-mapKeymap for log sections.
magit-log-header-line-functionFunction used to generate text shown in header line of log buffers.
magit-log-mode-syntax-tableSyntax table for `magit-log-mode'.
magit-log-select-show-usageWhether to show usage information when selecting a commit from a log.
magit-log-show-signatures-limitNumber of commits over which signatures are not verified.
magit-log-select-marginFormat of the margin in `magit-log-select-mode' buffers.
magit-log-select-mode-abbrev-tableAbbrev table for `magit-log-select-mode'.
magit-log-remove-graph-argsThe log arguments that cause the "--graph" argument to be dropped.
magit-log-color-graph-limitNumber of commits over which log graphs are not colored.
magit-log-mode-hookHook run after entering Magit-Log mode.
magit-log-revision-headers-formatAdditional format string used with the `++header' argument.
magit-log-trace-definition-functionFunction used to determine the function at point.
magit-commit-section-mapKeymap for `commit' sections.
magit-log-section-commit-countHow many recent commits to show in certain log sections.
magit-log-select-mode-syntax-tableSyntax table for `magit-log-select-mode'.
magit-log-wash-summary-hookFunctions used to highlight parts of each individual commit summary.
magit-cherry-mode-hookHook run after entering `magit-cherry-mode'.
magit-log-margin-show-committer-dateWhether to show the committer date in the margin.
magit-log-mode-mapKeymap for `magit-log-mode'.
magit-log-auto-moreInsert more log entries automatically when moving past the last entry.
magit-blame-read-only-mode-mapKeymap for `magit-blame-read-only-mode'.
magit-blame-mode-mapKeymap for `magit-blame-mode'.
magit-blame-read-only-mode-hookHook run after entering or leaving `magit-blame-read-only-mode'.
magit-blame-read-onlyWhether to initially make the blamed buffer read-only.
magit-blame-stylesList of styles used to visualize blame information.
magit-blame-echo-styleThe blame visualization style used by `magit-blame-echo'.
magit-blame-goto-chunk-hookHook run after point entered another chunk.
magit-blame-read-only-modeNon-nil if Magit-Blame-Read-Only mode is enabled.
magit-blame-mode-hookHook run after entering or leaving `magit-blame-mode'.
magit-blame-modeNon-nil if Magit-Blame mode is enabled.
magit-blame-mode-lighterThe mode-line lighter of the Magit-Blame mode.
magit-blame-time-formatFormat for time strings in blame headings.
magit-blame-disable-modesList of modes not compatible with Magit-Blame mode.
magit-delete-by-moving-to-trashWhether Magit uses the system's trash can.
magit-reverse-atomicallyWhether to reverse changes atomically.
magit-post-unstage-hookHook run after unstaging changes.
magit-post-stage-hookHook run after staging changes.
magit-unstage-committedWhether unstaging a committed change reverts it instead.
magit-no-confirmA list of symbols for actions Magit should not confirm, or t.
magit-completing-read-functionFunction to be called when requesting input from the user.
magit-completing-read-default-prompt-predicateFunction used to determine whether to add default to prompt.
magit-dwim-selectionWhen not to offer alternatives and ask for confirmation.
magit-ellipsisCharacters or strings used to abbreviate text in some buffers.
magit-update-other-window-delayDelay before automatically updating the other window.
magit-verbose-messagesWhether to make certain prompts and messages more verbose.
magit-slow-confirmWhether to ask user "y or n" or "yes or no" questions.
magit-view-git-manual-methodHow links to Git documentation are followed from Magit's Info manuals.
magit-no-messageA list of messages Magit should not display.
magit--default-directoryValue of `default-directory' when buffer is generated.
magit-create-buffer-hookNormal hook run while creating a new `magit-mode' buffer.
magit-display-buffer-noselectIf non-nil, then `magit-display-buffer' doesn't call `select-window'.
magit-post-display-buffer-hookHook run by `magit-display-buffer' after displaying the buffer.
magit-mode-abbrev-tableAbbrev table for `magit-mode'.
magit-mode-menuMagit menu.
magit-display-buffer-functionThe function used to display a Magit buffer.
magit-buffer-name-formatThe format string used to name Magit buffers.
magit-refresh-buffer-hookNormal hook for `magit-refresh-buffer' to run after refreshing.
magit-mode-syntax-tableSyntax table for `magit-mode'.
magit-region-highlight-hookFunctions used to highlight the region.
magit-repository-local-cacheAlist mapping `magit-toplevel' paths to alists of key/value pairs.
magit-mode-hookHook run when entering a mode derived from Magit mode.
magit-post-create-buffer-hookNormal hook run after creating a new `magit-mode' buffer.
magit-save-repository-buffers-predicatePredicate for `magit-save-repository-buffers'.
magit-prefix-use-buffer-argumentsWhether certain prefix commands reuse arguments active in relevant buffer.
magit-mode-mapParent keymap for all keymaps of modes derived from `magit-mode'.
magit-bury-buffer-functionThe function used to bury or kill the current Magit buffer.
magit-refresh-verboseWhether to revert Magit buffers verbosely.
magit-pre-refresh-hookHook run before refreshing in `magit-refresh'.
magit-setup-buffer-hookHook run by `magit-setup-buffer'.
magit-generate-buffer-name-functionThe function used to generate the name for a Magit buffer.
magit-direct-use-buffer-argumentsWhether certain commands reuse arguments active in relevant buffer.
magit-uniquify-buffer-namesWhether to uniquify the names of Magit buffers.
magit-pre-display-buffer-hookHook run by `magit-display-buffer' before displaying the buffer.
magit-save-repository-buffersWhether to save file-visiting buffers when appropriate.
magit-xref-modesList of modes for which to insert navigation buttons.
magit-refresh-status-bufferWhether the status buffer is refreshed after running git.
magit-post-refresh-hookHook run after refreshing in `magit-refresh'.
magit-revision-mode-hookHook run after entering Magit-Revision mode.
magit-merge-preview-mode-syntax-tableSyntax table for `magit-merge-preview-mode'.
magit-diff-section-base-mapKeymap for diff sections.
magit-diff-mode-syntax-tableSyntax table for `magit-diff-mode'.
magit-revision-wash-message-hookFunctions used to highlight parts of a commit message.
magit-hunk-section-smerge-mapKeymap bound to `smerge-command-prefix' in `magit-hunk-section-map'.
magit-revision-fill-summary-lineWhether to fill excessively long summary lines.
magit-commit-message-section-mapKeymap for `commit-message' sections.
magit-diff-highlight-hunk-bodyWhether to highlight bodies of selected hunk sections.
magit-merge-preview-mode-hookHook run after entering `magit-merge-preview-mode'.
magit-unstaged-section-mapKeymap for the `unstaged' section.
magit-revision-insert-related-refsWhether to show related branches in revision buffers.
magit-wash-message-hookFunctions used to highlight parts of a commit message.
magit-merge-preview-mode-mapKeymap for `magit-merge-preview-mode'.
magit-diff-visit-prefer-worktreeWhether `magit-diff-visit-file' prefers visiting the worktree file.
magit-revision-filter-files-on-followWhether to honor file filter if log arguments include "--follow".
magit-diff-buffer-file-lockedWhether `magit-diff-buffer-file' uses a dedicated buffer.
magit-staged-section-mapKeymap for the `staged' section.
magit-diff-highlight-indentationHighlight the "wrong" indentation style.
magit-diff-extra-stat-argumentsAdditional arguments to be used alongside "--stat".
magit-merge-preview-mode-abbrev-tableAbbrev table for `magit-merge-preview-mode'.
magit-diff-paint-whitespaceSpecify where to highlight whitespace errors.
magit-diff-mode-mapKeymap for `magit-diff-mode'.
magit-diff-paint-whitespace-linesSpecify in what kind of lines to highlight whitespace errors.
magit-diff-unmarked-lines-keep-foregroundWhether `magit-diff-highlight-hunk-region-dim-outside' preserves foreground.
magit-file-section-mapKeymap for `file' sections.
magit-diff-hide-trailing-cr-charactersWhether to hide ^M characters at the end of a line in diffs.
magit-diff-specify-hunk-foregroundWhether to specify foreground colors for hunk faces.
magit-hunk-section-mapKeymap for `hunk' sections.
magit-diff-refine-ignore-whitespaceWhether to ignore whitespace changes in word-granularity differences.
magit-diff-highlight-trailingWhether to highlight whitespace at the end of a line in diffs.
magit-diff-highlight-hunk-region-functionsThe functions used to highlight the hunk-internal region.
magit-diff-refine-hunkWhether to refine hunks to show word-granularity differences.
magit-diff-expansion-thresholdAfter how many seconds not to expand anymore diffs.
magit-diff-adjust-tab-widthWhether to adjust the width of tabs in diffs.
magit-revision-headers-formatFormat string used to insert headers in revision buffers.
magit-diff-sections-hookHook run to insert sections into a `magit-diff-mode' buffer.
magit-revision-mode-mapKeymap for `magit-revision-mode'.
magit-diff-use-indicator-facesWhether to use separate faces for diff side indicators.
magit-revision-use-dedicated-buffersWhether `magit-show-commit' uses a dedicated buffer for each revision.
magit-diff-section-mapKeymap for diff sections.
magit-revision-use-hash-sectionsWhether to turn hashes inside the commit message into sections.
magit-diff-mode-abbrev-tableAbbrev table for `magit-diff-mode'.
magit-revision-show-gravatarsWhether to show gravatar images in revision buffers.
magit-diff-fontify-hunkWhether to apply syntax highlighting to diff hunks.
magit-diff-visit-previous-blobWhether `magit-diff-visit-file' may visit the previous blob.
magit-revision-mode-abbrev-tableAbbrev table for `magit-revision-mode'.
magit-revision-sections-hookHook run to insert sections into a `magit-revision-mode' buffer.
magit-format-file-functionFunction used to format lines representing a file.
magit-revision-insert-related-refs-display-alistHow `magit-insert-revision-headers' displays related branch types.
magit-diff-mode-hookHook run after entering Magit-Diff mode.
magit-revision-mode-syntax-tableSyntax table for `magit-revision-mode'.
magit-stash-mode-syntax-tableSyntax table for `magit-stash-mode'.
magit-stash-sections-hookHook run to insert sections into stash diff buffers.
magit-stashes-section-mapKeymap for `stashes' section.
magit-stash-section-mapKeymap for `stash' sections.
magit-stashes-marginFormat of the margin in `magit-stashes-mode' buffers.
magit-stash-mode-hookHook run after entering `magit-stash-mode'.
magit-stash-mode-mapKeymap for `magit-stash-mode'.
magit-stashes-mode-hookHook run after entering `magit-stashes-mode'.
magit-stash-read-message-functionFunction used to read the message when creating a stash.
magit-stash-mode-abbrev-tableAbbrev table for `magit-stash-mode'.
magit-stashes-mode-mapKeymap for `magit-stashes-mode'.
magit-stashes-mode-abbrev-tableAbbrev table for `magit-stashes-mode'.
magit-stashes-mode-syntax-tableSyntax table for `magit-stashes-mode'.
magit-bisect-show-graphWhether to use "--graph" in the log showing commits yet to be bisected.
magit--blob-cache-limitLimit number of volatile blob buffers to be kept alive.
magit-blob-mode-hookHook run after entering or leaving `magit-blob-mode'.
magit-blob-modeNon-nil if Magit-Blob mode is enabled.
magit--blob-cache-intervalSeconds between volatile blob buffer pruning runs.
magit--blob-cache-timeoutLimit age, since last access, of volatile blob buffers to be kept alive.
magit-blob-mode-mapKeymap for `magit-blob-mode'.
magit-git-environmentPrepended to `process-environment' while running git.
magit-git-executableThe Git executable used by Magit on the local host.
magit-git-global-argumentsGlobal Git arguments.
magit-githook-directoryDirectory containing files Magit needs to map Git to Lisp hooks.
magit--git-w32-path-hackAlist of (EXE . (PATHENTRY)).
magit-remote-git-executableThe Git executable used by Magit on remote machines.
magit-long-lived-branchesBranch names intended to be used for long lived branches.
magit-list-refs-sortbyHow to sort the ref collection in the prompt.
magit-get-previous-branch-timeoutMaximum time to spend in `magit-get-previous-branch'.
magit-prefer-remote-upstreamWhether to favor remote branches when reading the upstream branch.
magit-git-output-coding-systemCoding system for receiving output from Git.
magit-main-branch-namesBranch names intended to be used for the primary branch.
magit-git-debugWhether and how to enable additional debugging of git errors.
magit-run-hooks-from-githooksWhether Git hooks may run Lisp hooks.
magit-with-editor-envvarThe environment variable exported by `magit-with-editor'.
magit-cygwin-mount-pointsAlist of (CYGWIN . WIN32) directory names.
magit--refresh-cacheCache used during refreshes and other expensive operations.
magit-ref-namespacesHow refs are formatted for display.
magit-list-refs-namespacesList of ref namespaces considered when reading a ref.
magit-user-githook-fileFile containing user Git hook to Lisp hook mappings.
magit-repolist-sort-keyInitial sort key for buffer created by `magit-list-repositories'.
magit-repolist-mode-syntax-tableSyntax table for `magit-repolist-mode'.
magit-repolist-column-flag-alistAssociation list of predicates and flags for `magit-repolist-column-flag'.
magit-repolist-mode-mapLocal keymap for Magit-Repolist mode buffers.
magit-repolist-mode-abbrev-tableAbbrev table for `magit-repolist-mode'.
magit-repository-directoriesList of directories that are or contain Git repositories.
magit-repolist-mode-hookHook run after entering Magit-Repolist mode.
magit-repolist-columnsList of columns displayed by `magit-list-repositories'.
magit-perl-executableThe Perl executable.

Defined functions (1484)

magit-reflog-format-subject(SUBJECT)
magit-reflog-current()
magit-reflog-setup-buffer(REF)
magit-reflog-head()
magit-reflog-mode()
magit-margin-settings()
magit-toggle-margin()
magit-set-window-margins(&optional WINDOW)
magit-margin-set-variable(MODE SYMBOL VALUE)
magit-toggle-margin-details()
magit-set-buffer-margins(&optional RESET-RIGHT REFRESH-RIGHT)
magit-cycle-margin-style()
magit--age(DATE &optional ABBREVIATE)
magit-make-margin-overlay(&optional STRING (PREVIOUS-LINE nil SLINE))
magit-reset-keep(COMMIT)
magit-reset-quickly(COMMIT &optional HARD)
magit-reset-mixed(COMMIT)
magit-reset-worktree(COMMIT)
magit-reset-soft(COMMIT)
magit-reset-internal(ARG COMMIT &optional PATH)
magit-reset-read-branch-or-commit(PROMPT)
magit-reset-index(COMMIT)
magit-reset()
magit-reset-hard(COMMIT)
magit-pull:--rebase()
magit-pull()
magit-pull-from-pushremote(ARG1)
transient:magit-pull:--ff-only()
magit-pull-branch(SOURCE ARGS)
transient:magit-pull:--force()
magit-pull-into-upstream()
transient:magit-pull:--autostash()
magit-pull-from-upstream(ARG1)
magit--list-releases()
magit-tag-create(NAME COMMIT &optional ARGS)
magit-tag:--local-user()
transient:magit-tag:--force()
magit-tag-prune(TAGS REMOTE-TAGS REMOTE)
transient:magit-tag:--edit()
transient:magit-tag:--annotate()
transient:magit-tag:--sign()
magit-tag-release(TAG MSG &optional ARGS)
magit-tag-delete(TAGS)
magit-refs--insert-refname-p(REFNAME)
magit-insert-local-branches()
magit-refs-set-show-commit-count()
magit-insert-remote-branches()
magit-insert-shelved-branches()
transient:magit-show-refs:--no-merged()
transient:magit-show-refs:--no-merged=()
magit-refs-setup-buffer(REF ARGS)
magit-show-refs-other(&optional REF ARGS)
magit-refs--insert-cherry-commits(REF)
magit-insert-tags()
magit-refs--format-local-branch(LINE)
magit-read-ref-sort(PROMPT INITIAL-INPUT HISTORY)
magit-show-refs-arguments(&optional USE-BUFFER-ARGS)
magit-show-refs-current(&optional ARGS)
magit-refs--maybe-format-margin(REV)
magit-insert-branch-description()
magit-show-refs-head(&optional ARGS)
magit-refs--propertize-branch(BRANCH REF &optional HEAD-FACE)
magit-show-refs(&optional ARG1)
magit--painted-branch-as-menu-section(SECTION)
magit-for-each-ref:--contains()
magit-for-each-ref:--sort()
magit-visit-ref()
transient:magit-show-refs:--merged=()
transient:magit-show-refs:--merged()
magit-refs-mode()
magit-refs--format-focus-column(REF &optional TYPE)
magit-auto-revert-mode(&optional ARG)
magit-auto-revert-mode--disable()
magit-auto-revert-repository-buffer-p(BUFFER &optional FALLBACK)
magit-auto-revert-mode--initialize(SYMBOL VALUE)
magit-turn-on-auto-revert-mode-if-desired(&optional FILE)
magit-auto-revert-buffer-p(BUFFER)
auto-revert-buffers@buffer-list-filter(FN)
magit-wip-commit-index(REF FILES MSG)
magit-run-before-change-functions(FILES TASK)
magit-wip-mode(&optional ARG)
magit-wip-commit-buffer-file(&optional MSG)
magit-wip-commit-worktree(REF FILES MSG)
magit-wip-log-worktree(ARGS FILES)
magit--wip-wtree-ref(&optional REF)
magit-run-after-apply-functions(FILES TASK)
magit--wip-ref(NAMESPACE &optional REF)
magit-wip-get-parent(REF WIPREF)
magit-wip-update-wipref(REF WIPREF TREE PARENT FILES MSG START-MSG)
magit-wip-purge()
magit--wip-index-ref(&optional REF)
magit-wip--git(&rest ARGS)
magit-wip-log(BRANCH ARGS FILES COUNT)
magit-wip-commit(&optional FILES MSG)
magit-wip-log-index(ARGS FILES)
magit-wip-post-commit(&rest _)
magit-wip--update-ref(REF MESSAGE REV)
magit-wip-log-get-tips(WIPREF COUNT)
magit-wip-log-current(BRANCH ARGS FILES COUNT)
magit-remote-remove(REMOTE)
magit-remote-add(REMOTE URL &optional ARGS)
transient:magit-remote:-f()
magit-remote-prune-refspecs(REMOTE)
magit-remote..pushurl()
magit-remote..push()
magit--read-remote-scope(&optional OBJ)
magit-remote(ARG1)
magit-update-default-branch()
magit-remote-rename(OLD NEW)
magit--push-remote-variable(&optional BRANCH SHORT)
magit-remote-configure(ARG1)
magit-remote-unset-head(REMOTE)
magit--select-push-remote(PROMPT-SUFFIX)
magit-remote..followremotehead()
magit-remote..tagopt()
magit-remote..url()
magit-remote-prune(REMOTE)
magit-remote-set-head(REMOTE &optional BRANCH)
magit-remote--cleanup-push-variables(REMOTE &optional NEW-NAME)
magit-remote-unshallow(REMOTE)
magit-remote..fetch()
magit-read-url(PROMPT &optional INITIAL-INPUT)
magit--git-variable--eieio-childp(OBJ)
magit--git-variable-list-choices(OBJ)
magit--git-variable:urls(&rest SLOTS)
magit--git-variable:boolean(&rest SLOTS)
magit--git-variable:choices--eieio-childp(OBJ)
magit--git-variable:boolean--eieio-childp(OBJ)
magit--git-variable(&rest SLOTS)
magit--git-variable-get(OBJ ARG)
magit--git-variable-p(OBJ)
magit--git-variable:choices-p(OBJ)
magit--git-variable:urls--eieio-childp(OBJ)
magit--git-variable:choices(&rest SLOTS)
magit-transient-read-person(PROMPT INITIAL-INPUT HISTORY)
magit-transient-read-persons(PROMPT INITIAL-INPUT HISTORY)
magit--git-variable:boolean-child-p(OBJ)
magit--git-variable:choices-child-p(OBJ)
magit--git-variable:boolean-p(OBJ)
magit-transient-read-revision(PROMPT INITIAL-INPUT HISTORY)
magit--git-variable-child-p(OBJ)
magit--git-variable:urls-child-p(OBJ)
magit--git-variable:urls-p(OBJ)
magit-merge-editmsg(REV &optional ARGS)
magit-merge-preview(REV)
transient:magit-merge:-Xignore-space-change()
magit-merge-nocommit(REV &optional ARGS)
magit-merge:--strategy-option()
magit-checkout-stage(FILE ARG)
magit-merge-squash(REV)
magit--merge-absorb-1(BRANCH ARGS)
magit-checkout-read-stage(FILE)
magit--merge-absorb(BRANCH ARGS &optional MESSAGE)
magit-merge-dissolve(BRANCH &optional ARGS)
magit--merge-range(&optional HEAD)
transient:magit-merge:--no-ff()
magit-merge-absorb(BRANCH &optional ARGS)
magit-insert-merge-log()
transient:magit-merge:--ff-only()
magit-merge:--strategy()
transient:magit-merge:-Xignore-all-space()
magit-merge-abort()
magit-merge-plain(REV &optional ARGS NOCOMMIT)
magit-merge()
magit-worktree-branch(DIRECTORY BRANCH START-POINT)
magit-read-worktree-directory-nested(PROMPT COMMIT)
magit-worktree-status(WORKTREE)
magit--read-worktree-directory(REV)
magit-worktree-delete(WORKTREE)
magit-read-worktree-directory(PROMPT COMMIT)
magit-insert-worktrees()
magit-read-worktree-directory-sibling(PROMPT COMMIT)
magit-worktree-checkout(DIRECTORY COMMIT)
magit-read-worktree-directory-offsite(PROMPT COMMIT)
magit--expand-worktree(DIRECTORY)
magit--insert-worktree(CONFIG HEAD)
magit-worktree-move(WORKTREE DIRECTORY)
magit-worktree()
magit-process-set-mode-line(PROGRAM ARGS)
magit-process-finish-section(SECTION EXIT-CODE)
magit-start-git(INPUT &rest ARGS)
magit-process-yes-or-no-prompt(PROCESS STRING)
magit-process-mode()
magit-run-git(&rest ARGS)
magit-process-git-credential-manager-core(PROCESS STRING)
magit-process-sentinel(PROCESS EVENT)
magit-parse-git-async(&rest ARGS)
magit-sequencer-process-sentinel(PROCESS EVENT)
magit-run-git-sequencer(&rest ARGS)
magit-process-match-prompt(PROMPTS STRING)
magit-process-set-mode-line-error-status(&optional ERROR STR)
magit-maybe-start-credential-cache-daemon()
magit-process-setup(PROGRAM ARGS)
magit-process-remove-bogus-errors(STR)
magit-process-insert-section(PWD PROGRAM ARGS &optional ERRCODE ERRLOG FACE)
magit-process-file(PROCESS &optional INFILE BUFFER DISPLAY &rest ARGS)
magit-process--format-arguments(PROGRAM ARGS)
magit-process-password-prompt(PROCESS STRING)
magit-start-process(PROGRAM &optional INPUT &rest ARGS)
magit--log-action(SUMMARY LINE LIST)
magit-run-git-async(&rest ARGS)
magit-process-finish(ARG &optional PROCESS-BUF COMMAND-BUF DEFAULT-DIR SECTION)
magit-process-buffer(&optional NODISPLAY)
magit-process-git(DESTINATION &rest ARGS)
magit-process-filter(PROC STRING)
magit-process-unset-mode-line-error-status()
magit-process-unset-mode-line(&optional DIRECTORY)
magit-process-kill()
magit-process-error-tooltip(PROCESS-BUF SECTION)
magit-call-process(PROGRAM &rest ARGS)
magit-process-section(&rest SLOTS)
magit-process-kill-on-abort(PROCESS &rest BODY)
magit-run-git-with-editor(&rest ARGS)
magit-toggle-subprocess-record()
magit-call-git(&rest ARGS)
magit-process-section-p(OBJ)
magit-process-error-summary(PROCESS-BUF SECTION)
magit-process-make-keymap(PROCESS PARENT)
magit-process-username-prompt(PROCESS STRING)
magit-run-git-with-input(&rest ARGS)
magit-process-section-child-p(OBJ)
magit-git(&rest ARGS)
magit-process-display-buffer(PROCESS)
magit-process-section--eieio-childp(OBJ)
magit-process-password-auth-source(KEY)
magit-version(&optional PRINT-DEST)
magit-maybe-define-global-key-bindings(&optional FORCE)
magit-read-shell-command(&optional TOPLEVEL INITIAL-INPUT)
magit-read-gpg-secret-key(PROMPT &optional INITIAL-INPUT HISTORY PREDICATE DEFAULT)
magit-read-gpg-signing-key(PROMPT &optional INITIAL-INPUT HISTORY)
magit:--gpg-sign()
magit-shell-command(COMMAND)
magit-git-command-topdir(COMMAND)
magit:--signoff()
magit--shell-command(COMMAND &optional DIRECTORY)
magit-dispatch()
magit-shell-command-topdir(COMMAND)
magit-git-command(COMMAND)
magit-run()
magit-pull.rebase()
magit-branch..description(ARG1)
magit--branch-spinoff(BRANCH FROM CHECKOUT)
magit--read-branch-scope(&optional OBJ)
magit-branch..pushRemote()
magit-branch-create(BRANCH START-POINT)
magit-checkout-remote-ref(REMOTE REF)
magit-branch-spinout(BRANCH &optional FROM)
magit--git-branch:upstream(&rest SLOTS)
magit-remote.pushDefault()
magit-branch-configure(ARG1)
magit--checkout(REV &optional ARGS)
magit-branch-delete(BRANCHES &optional FORCE)
magit-branch-reset(BRANCH TO &optional SET-UPSTREAM)
magit-branch..rebase()
magit--git-branch:upstream--eieio-childp(OBJ)
magit-branch(ARG1)
magit-branch-and-checkout(BRANCH START-POINT &optional ARGS)
magit--rename-reflog-file(OLD NEW)
magit-branch-shelve(BRANCH)
magit-branch--read-name(PROMPT &optional START-POINT)
magit-branch-maybe-delete-pr-remote(BRANCH)
magit-delete-remote-branch-sentinel(REMOTE REFS PROCESS EVENT)
magit-branch-or-checkout(ARG &optional START-POINT)
magit-branch.autoSetupMerge()
magit--git-branch:upstream-child-p(OBJ)
magit-branch.autoSetupRebase()
magit-branch-maybe-adjust-upstream(BRANCH START-POINT)
magit-branch-unset-pushRemote(BRANCH)
magit-branch-unshelve(BRANCH)
magit-branch-rename(OLD NEW &optional FORCE)
magit-branch-orphan(BRANCH START-POINT)
magit-branch..merge/remote()
magit--git-branch:upstream-p(OBJ)
magit-branch-spinoff(BRANCH &optional FROM)
magit-checkout(COMMIT &optional ARGS)
transient:magit-branch:--recurse-submodules()
magit-branch-checkout(BRANCH &optional START-POINT)
transient:magit-branch:--merge()
magit-branch-read-args(PROMPT &optional DEFAULT-START)
git-commit-collapse-diff()
git-commit-search-message-forward(STRING)
git-commit-setup-flyspell()
git-commit-extend-region-summary-line()
git-commit-insert-changelog-gnu()
git-commit-test(NAME MAIL)
git-commit-ensure-comment-gap()
git-commit-finish-query-functions(FORCE)
git-commit-setup-orglink()
git-commit-setup-bug-reference()
git-commit-co-developed(NAME MAIL)
git-commit-ack(NAME MAIL)
git-commit-suggested(NAME MAIL)
git-commit--goto-insert-position(BOUND)
git-commit-save-message()
git-commit-turn-on-orglink()
git-commit-insert-trailer()
git-commit-prev-message(ARG)
git-commit-turn-on-flyspell()
git-commit-self-ident(&optional PROMPT)
git-commit-signoff(NAME MAIL)
git-commit-search-message-backward(STRING)
git-commit-get-ident(&optional PROMPT)
git-commit--insert-trailer(TRAILER VALUE)
git-commit-turn-on-auto-fill()
git-commit-mode-menu(ARG1)
git-commit-cc(NAME MAIL)
git-commit-read-ident(PROMPT)
git-commit-check-style-conventions(FORCE)
git-commit-run-post-finish-hook(PREVIOUS)
git-commit-insert-changelog-plain()
git-commit-setup-capf()
git-commit--insert-trailer-1(STRING &optional BEFORE-TRAILERS)
git-commit--insert-ident-trailer(TRAILER NAME EMAIL)
git-commit-elisp-text-mode()
global-git-commit-mode(&optional ARG)
git-commit--auto-fill-except-summary()
git-commit-modified(NAME MAIL)
git-commit-next-message(ARG)
git-commit-setup-changelog-support()
git-commit-insert-header(TRAILER NAME EMAIL)
git-commit-review(NAME MAIL)
git-commit-mode(&optional ARG)
git-commit--flyspell-verify()
git-commit-setup-auto-fill()
git-commit-reported(NAME MAIL)
git-commit-co-authored(NAME MAIL)
magit-fetch-modules(&optional ARG1 ARG2)
transient:magit-fetch:--unshallow()
transient:magit-fetch-modules:--jobs=()
magit-fetch()
transient:magit-fetch:--prune()
transient:magit-fetch:--force()
magit-fetch-other(REMOTE ARGS)
magit-fetch-all-no-prune()
magit-fetch-refspec(REMOTE REFSPEC ARGS)
transient:magit-fetch:--tags()
magit-fetch-branch(REMOTE BRANCH ARGS)
magit-fetch-all(ARGS)
magit-fetch-from-upstream(ARG1 ARG2)
transient:magit-fetch-modules:--verbose()
magit-git-fetch(REMOTE ARGS)
magit-fetch-from-pushremote(ARG1)
magit-fetch-all-prune()
magit-clone-sparse(REPOSITORY DIRECTORY ARGS)
magit-clone-internal(REPOSITORY DIRECTORY ARGS &optional SPARSE)
transient:magit-clone:--origin=()
transient:magit-clone:--no-hardlinks()
magit-clone:--filter()
transient:magit-clone:--single-branch()
magit-clone-regular(REPOSITORY DIRECTORY ARGS)
magit-clone--name-to-url(NAME)
magit-clone-read-filter(PROMPT INITIAL-INPUT HISTORY)
transient:magit-clone:--template=()
transient:magit-clone:--shared()
magit-clone-shallow-since(REPOSITORY DIRECTORY ARGS DATE)
transient:magit-clone:--recurse-submodules()
magit-clone-shallow-exclude(REPOSITORY DIRECTORY ARGS EXCLUDE)
transient:magit-clone:--branch=()
magit-clone-shallow(REPOSITORY DIRECTORY ARGS DEPTH)
magit-clone--format-url(HOST USER REPO)
transient:magit-clone:--no-tags()
magit-clone--url-to-name(URL)
transient:magit-clone:--separate-git-dir=()
magit-clone-bare(REPOSITORY DIRECTORY ARGS)
magit-clone-mirror(REPOSITORY DIRECTORY ARGS)
magit-clone(&optional ARG1)
transient:magit-clone:--no-local()
transient:magit-commit:--no-verify()
transient:magit-commit:--reset-author()
magit-commit-alter(&optional COMMIT ARGS)
magit-commit:--reedit-message()
magit-autofixup:--strict()
magit-commit-assert(ARGS &optional NOPATCH STRICT)
transient:magit-commit-absorb:--verbose()
magit-commit-reshelve(DATE UPDATE-AUTHOR &optional ARGS)
magit-commit:--reuse-message()
magit-commit-extend(&optional ARGS OVERRIDE-DATE)
magit-commit()
magit-commit-squash-internal(OPTION COMMIT &optional ARGS NOPATCH EDIT REBASE CONFIRMED)
magit-commit-augment(&optional COMMIT ARGS)
magit-commit:--date()
magit-commit-add-log()
magit-commit-instant-fixup(&optional COMMIT ARGS)
magit-commit-fixup(&optional COMMIT ARGS)
magit-commit-amend(&optional ARGS)
magit-commit-add-log-insert(BUFFER FILE DEFUN)
magit-read-reuse-message(PROMPT &optional DEFAULT HISTORY)
magit-commit-reword(&optional ARGS OVERRIDE-DATE)
magit-commit-autofixup(ARG1 ARG2 ARG3)
magit-autofixup:--context()
magit-commit-revise(&optional COMMIT ARGS)
magit-commit-create(&optional ARGS)
transient:magit-commit:--allow-empty()
magit-commit-squash(&optional COMMIT ARGS)
magit-commit-absorb(ARG1 ARG2 ARG3)
magit-commit-amend-assert(&optional COMMIT)
magit-commit-instant-squash(&optional COMMIT ARGS)
transient:magit-commit:--verbose()
magit-commit-absorb-modules(PHASE COMMIT)
transient:magit-commit-autofixup:-vv()
transient:magit-commit:--all()
transient:magit-commit-absorb:--force()
magit-submodule-synchronize(ARG1 ARG2)
magit-submodule-register(ARG1)
magit-submodule--maybe-reuse-gitdir(NAME PATH)
magit-submodule-remove(MODULES ARGS TRASH-GITDIRS)
magit--git-submodule-suffix-child-p(OBJ)
magit--git-submodule-suffix--eieio-childp(OBJ)
transient:magit-submodule:--recursive()
magit-submodule-list-module-populated-p(MODULE)
magit--insert-modules-logs(HEADING TYPE RANGE)
transient:magit-submodule:--checkout()
magit-submodule--format-module(MODULE)
magit--git-submodule-suffix(&rest SLOTS)
magit-insert-modules-overview()
magit-submodule-arguments(&rest FILTERS)
magit-submodule-add(ARG1 &optional ARG2 ARG3 ARG4)
transient:magit-submodule:--merge()
magit-submodule-list-setup(COLUMNS &optional PREDICATE)
magit-list-submodules()
magit-insert-modules-unpushed-to-pushremote()
magit-insert-modules-unpulled-from-upstream()
magit-modulelist-column-path(SPEC)
magit--insert-modules-overview(&optional SECTION REPOS)
magit-submodule--restore-worktree(WORKTREE GITDIR)
magit-insert-modules-unpushed-to-upstream()
transient:magit-submodule:--no-fetch()
magit--git-submodule-suffix-p(OBJ)
magit-submodule-unpopulate(ARG1 ARG2)
magit--insert-modules(&optional SECTION)
magit-submodule-update(ARG1 ARG2)
magit-submodule-read-path(PROMPT URL)
magit-insert-modules()
magit-submodule-add-1(URL &optional PATH NAME ARGS)
transient:magit-submodule:--remote()
magit-insert-modules-unpulled-from-pushremote()
transient:magit-submodule:--force()
transient:magit-submodule:--rebase()
magit-submodule()
magit-submodule-visit(MODULE &optional OTHER-WINDOW)
magit-submodule-list-mode()
magit-submodule-read-name-for-path(PATH &optional PREFER-SHORT)
magit-submodule-populate(ARG1 ARG2)
magit-push-tags(REMOTE &optional ARGS)
transient:magit-push:--no-verify()
magit-push-implicitly(ARG1)
transient:magit-push:--follow-tags()
magit-push-other(SOURCE TARGET ARGS)
transient:magit-push:--dry-run()
magit-push-notes-ref(REF REMOTE &optional ARGS)
transient:magit-push:--force-with-lease()
magit-push-current-to-pushremote(ARG1)
magit-push-current-to-upstream(ARG1)
magit-push-refspecs(REMOTE REFSPECS ARGS)
magit-push-tag(TAG REMOTE &optional ARGS)
magit-git-push(BRANCH TARGET ARGS)
magit-push()
magit-push-matching(REMOTE &optional ARGS)
magit-push-current(TARGET ARGS)
transient:magit-push:--tags()
magit-push:--push-option()
magit-push-to-remote(ARG1 ARG2)
transient:magit-push:--force()
transient:magit-push:--set-upstream()
magit-insert-status-headers()
magit-status-mode()
magit-jump-to-ignored(&optional ARG1)
magit-insert-untracked-files()
magit-insert-assume-unchanged-files()
magit-insert-diff-filter-header()
magit(&optional ARG1 ARG2)
magit-init(DIRECTORY)
magit-jump-to-skip-worktree(&optional ARG1)
magit-insert-tags-header()
magit-jump-to-assume-unchanged(&optional ARG1)
magit-insert-repo-header()
magit-status(&optional DIRECTORY CACHE)
magit-status-quick(&optional DIRECTORY)
magit-status--goto-file-position(FILE LINE COLUMN)
magit-insert-files(TYPE FN)
magit-status-jump()
magit-insert-head-branch-header(&optional BRANCH)
magit-insert-tracked-files()
magit-jump-to-untracked(&optional ARG1)
magit-status-setup-buffer(&optional DIRECTORY)
magit-insert-skip-worktree-files()
magit-parent-status()
magit-insert-ignored-files()
magit-status-goto-initial-section()
magit-jump-to-tracked(&optional ARG1)
magit-status-here()
magit-insert-push-branch-header()
magit-insert-upstream-branch-header(&optional BRANCH UPSTREAM KEYWORD)
magit-status-maybe-update-stash-buffer(&optional _)
magit-insert-remote-header()
magit-status-maybe-update-revision-buffer(&optional _)
magit-status-maybe-update-blob-buffer(&optional _)
magit-insert-user-header()
magit-insert-error-header()
magit-log-prefix--eieio-childp(OBJ)
magit-log:--graph-lane-limit()
magit-insert-log(REVS &optional ARGS FILES)
magit-log-refresh-prefix-child-p(OBJ)
magit-log:-G()
magit-log-header-line-arguments(REVS ARGS FILES)
magit-log-format-shortstat-margin(REV)
magit-log--get-value(MODE &optional USE-BUFFER-ARGS)
magit-insert-recent-commits(&optional TYPE VALUE)
transient:magit-log-infix-arguments:--follow()
transient:magit-log-refresh:--graph()
magit-shortlog-since(COMMIT ARGS)
transient:magit-log-infix-arguments:--graph()
transient:magit-log-infix-arguments:--patch()
transient:magit-shortlog:--group=()
magit-log-toggle-commit-limit()
magit-log-header-line-sentence(REVS ARGS FILES)
magit-previous-reference()
magit-insert-unpushed-to-upstream-or-recent()
magit-log-refresh-prefix--eieio-childp(OBJ)
magit:--author()
magit-log-wash-rev(STYLE ABBREV)
magit-read-file-trace(&rest IGNORED)
magit-cherry(HEAD UPSTREAM)
magit-shortlog()
magit-log--set-value(OBJ &optional SAVE)
transient:magit-shortlog:--email()
magit-log--wash-summary(SUMMARY)
magit-log-all-branches(&optional ARGS FILES)
transient:magit-log-infix-arguments:--reverse()
magit-diff-trace-definition()
magit-log-mode()
magit-log-maybe-update-revision-buffer(&optional _)
transient:magit-shortlog:--numbered()
magit-log-goto-commit-section(REV)
magit-log:--since()
magit-next-reference(&optional PREVIOUS)
magit-log-double-commit-limit()
magit-log()
transient:magit-log-infix-arguments:--invert-grep()
magit-log-format-author-margin(AUTHOR DATE)
transient:magit-log-infix-arguments:--stat()
magit-cherry-setup-buffer(HEAD UPSTREAM)
magit-log-prefix(&rest SLOTS)
magit-log-set-commit-limit(FN)
magit-log-related(REVS &optional ARGS FILES)
magit-log-bury-buffer(&optional ARG)
magit-jump-to-unpulled-from-upstream(&optional ARG1)
magit-log-refresh-prefix-p(OBJ)
magit-log-buffer-file(&optional FOLLOW BEG END)
transient:magit-log-infix-arguments:--show-signature()
magit-log-maybe-show-more-commits(SECTION)
magit-log-select(PICK &optional MSG QUIT BRANCH ARGS INITIAL)
transient:magit-log-infix-arguments:--first-parent()
magit-log:-S()
transient:magit-log-infix-arguments:--merges()
transient:magit-log-infix-arguments:--decorate()
magit-insert-cherry-headers()
magit-log-head(&optional ARGS FILES)
magit-log-arguments(&optional MODE)
transient:magit-log-infix-arguments:--simplify-merges()
magit-log-select-setup-buffer(REVS ARGS)
magit-insert-unpulled-cherries()
magit-log-wash-log(STYLE ARGS)
transient:magit-log-infix-arguments:--no-merges()
magit-toggle-log-margin-style()
magit-git-shortlog(REV ARGS)
magit-log:--*-order()
magit-log-current(&optional ARG1 ARG2)
magit-jump-to-unpushed-to-pushremote(&optional ARG1)
magit-jump-to-unpulled-from-pushremote(&optional ARG1)
magit-log-select-quit()
transient:magit-log-infix-arguments:--simplify-by-decoration()
magit-delete-shelved-branch(BRANCH)
magit-log:--grep()
magit-log-merged(COMMIT BRANCH &optional ARGS FILES)
magit-log:-n()
magit-shortlog-range(REV-OR-RANGE ARGS)
magit-log-prefix-child-p(OBJ)
magit-log-get-commit-limit(&optional ARGS)
magit-log-other(REVS &optional ARGS FILES)
magit-log-read-pattern(OPTION)
magit-insert-unpushed-to-upstream()
magit-log--maybe-drop-color-graph(ARGS LIMIT)
magit-insert-unpushed-cherries()
magit-cherry-mode()
transient:magit-log-infix-arguments:--ancestry-path()
magit-log-half-commit-limit()
magit-log-select-pick()
transient:magit-log-infix-arguments:--regexp-ignore-case()
magit--insert-log(KEEP-ERROR REVS &optional ARGS FILES)
magit-log-refresh-prefix(&rest SLOTS)
transient:magit-log-refresh:--decorate()
magit-log-setup-buffer(REVS ARGS FILES &optional LOCKED FOCUS)
magit-log-format-margin(REV AUTHOR DATE)
magit-log-margin-width(STYLE DETAILS DETAILS-WIDTH)
magit-jump-to-unpushed-to-upstream(&optional ARG1)
magit-log-select-mode()
magit-log-maybe-update-blob-buffer(&optional _)
magit-insert-cherry-commits()
magit-log-matching-branches(PATTERN &optional ARGS FILES)
magit-log-all(&optional ARGS FILES)
transient:magit-log-infix-arguments:--color()
magit-insert-unpulled-from-pushremote()
magit-log:-L()
magit-log-prefix-p(OBJ)
magit-log-refresh()
magit-log-trace-definition(FILE FN COMMIT)
magit-log-branches(&optional ARGS FILES)
magit-log-read-revs(&optional USE-CURRENT)
magit-log:--until()
transient:magit-log-refresh:--color()
magit-log-matching-tags(PATTERN &optional ARGS FILES)
magit-log-move-to-revision(COMMIT)
magit-insert-unpulled-from-upstream()
transient:magit-log-infix-arguments:--dense()
transient:magit-log-infix-arguments:--full-history()
transient:magit-shortlog:--summary()
transient:magit-log-infix-arguments:--sparse()
transient:magit-log-infix-arguments:++header()
transient:magit-shortlog:--format=()
transient:magit-shortlog:-w()
magit-log-move-to-parent(&optional N)
magit-log-reflog(&optional ARGS FILES)
magit-insert-unpushed-to-pushremote()
transient:magit-blame:-w()
magit-blame-next-chunk()
magit-blame--pre-blame-setup(TYPE)
transient:magit-blame:--first-parent()
magit-blame-visit-file()
magit-blame-previous-chunk()
magit-blame--pre-blame-assert(TYPE)
magit-blame--line-beginning-position(LINE)
magit-blame-chunk(&rest SLOTS)
magit-blame--format-string(OV FORMAT FACE)
magit-blame-chunk--eieio-childp(OBJ)
magit-blame-run-process(REV FILE ARGS &optional LINES)
magit-blame-chunk-at(POS)
magit-blame-reverse(ARG1)
magit-blame--run(ARGS)
magit-blame-quit()
magit-blame-echo(ARG1)
magit-blame-addition(ARG1)
magit-blame--style-get(KEY)
magit-blame-process-sentinel(PROCESS EVENT &optional QUIET)
magit-blame-previous-chunk-same-commit()
magit-blame--update-heading-overlay(OV)
transient:magit-blame:--root()
magit-blame--make-overlays(BUF CHUNK REVINFO)
magit-blame--commit-alist(REV)
magit-blame--make-highlight-overlay(CHUNK BEG)
magit-blame-cycle-style()
magit-blame--abbrev-hash(REV)
magit-blame--make-margin-overlays(CHUNK REVINFO BEG END)
magit-blame--make-heading-overlay(CHUNK REVINFO BEG END)
magit-blame()
magit-blame-process-quickstart-sentinel(PROCESS EVENT)
magit-blame-copy-hash()
magit-blame:-C()
magit-blame--update-margin(&optional ACTION)
magit-blame--update-margin-overlay(OV)
magit-blame-read-only-mode(&optional ARG)
magit-blame--remove-overlays(&optional BEG END)
magit-current-blame-chunk(&optional TYPE NOERROR)
magit-blame-removal(ARG1)
magit-blame--make-margin-overlay(CHUNK REVINFO LINE)
magit-blame-mode(&optional ARG)
magit-blame-chunk-child-p(OBJ)
magit-blame-put-keymap-before-view-mode()
magit-blame--update-highlight-overlay(OV)
magit-blame--overlay-at(&optional POS KEY)
magit-blame-next-chunk-same-commit()
magit-blame-process-filter(PROCESS STRING)
magit-blame-chunk-p(OBJ)
magit-blame--format-string-1(REV REVINFO FORMAT FACE)
magit-blame-assert-buffer(PROCESS)
magit-blame:-M()
magit-blame-visit-other-file()
magit-blame--parse-chunk(TYPE)
magit-blame--format-time-string(TIME TZ)
magit-apply-diffs(SECTIONS &rest ARGS)
magit-apply--ignore-whitespace-p(SELECTION TYPE SCOPE)
magit-stage-untracked(&optional INTENT)
magit-discard-file(SECTION)
magit-unstage()
magit-stage(&optional INTENT)
magit-discard-files--delete(FILES STATUS)
magit-apply(&rest ARGS)
magit-unstage-intent(FILES)
magit-smerge-keep-lower()
magit-reverse(&rest ARGS)
magit-discard-files--rename(FILES STATUS)
magit-stage-files(FILES &optional FORCE)
magit-discard-apply(SECTION:S APPLY)
magit-discard-files(SECTIONS)
magit-apply--adjust-hunk-new-start(HUNK)
magit-stage-1(ARG &optional FILES)
magit-apply-hunk(HUNK &rest ARGS)
magit-apply--adjust-hunk-new-starts(HUNKS)
magit-reverse-file(SECTION ARGS)
magit-reverse-apply(SECTION:S APPLY ARGS)
magit-discard-region(SECTION)
magit-unstage-all()
magit-smerge-keep-current()
magit-discard()
magit-apply-diff(SECTION &rest ARGS)
magit-reverse-in-index(&rest ARGS)
magit-call-smerge(FN)
magit-apply-hunks(HUNKS &rest ARGS)
magit-discard-files--resurrect(FILES)
magit-discard-files--resolve(FILES)
magit-unstage-files(FILES)
magit-discard-hunk(SECTION)
magit-apply-region(HUNK &rest ARGS)
magit-reverse-region(SECTION ARGS)
magit-apply--section-content(SECTION)
magit-smerge-keep-all()
magit-smerge-keep-base()
magit-copy-diff-as-kill()
magit-unstage-1(FILES)
magit-apply--get-diffs(SECTIONS)
magit-reverse-hunks(SECTIONS ARGS)
magit-reverse-hunk(SECTION ARGS)
magit-apply-patch(SECTION:S ARGS PATCH)
magit-apply--get-selection(&optional NOERROR)
magit-stage-modified(&optional ALL)
magit-smerge-keep-upper()
magit-discard-hunks(SECTIONS)
magit-reverse-files(SECTIONS ARGS)
magit-discard-files--discard(SECTIONS NEW-FILES)
magit-set-header-line-format(STRING)
magit-hunk-section(&rest SLOTS)
magit--format-prompt(PROMPT DEFAULT)
magit-whitespace-disallowed()
magit--completion-table(COLLECTION)
magit-completing-read-multiple(PROMPT TABLE &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD NO-SPLIT)
magit-module-section-p(OBJ)
magit--separate(PRED LIST)
magit-delete-line()
magit-commit-section--eieio-childp(OBJ)
magit-commit-section-p(OBJ)
magit-custom-initialize-reset(SYMBOL EXP)
magit-diff-section-p(OBJ)
magit-hunk-section-p(OBJ)
magit-log-section-p(OBJ)
magit-unpushed-section-child-p(OBJ)
magit-hunk-section-child-p(OBJ)
magit-unpulled-section-child-p(OBJ)
magit-unpushed-section--eieio-childp(OBJ)
magit--format-spec(FORMAT SPECIFICATION)
magit-unpushed-section(&rest SLOTS)
magit-commit-section-child-p(OBJ)
magit-file-section-child-p(OBJ)
magit-completing-read-multiple*(PROMPT TABLE &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD NO-SPLIT)
magit-module-section(&rest SLOTS)
magit-file-section--eieio-childp(OBJ)
Info-follow-nearest-node@gitman(FN &optional FORK)
magit-builtin-completing-read(PROMPT CHOICES &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF)
magit--remove-text-properties(STRING &optional PROPS)
magit-bind-match-strings(VARLIST STRING &rest BODY)
magit-log-section--eieio-childp(OBJ)
magit--meta-hunk-p(SECTION)
magit-diff-section--eieio-childp(OBJ)
magit-module-section--eieio-childp(OBJ)
magit-unmerged-section(&rest SLOTS)
magit-confirm-make-prompt(ACTION)
magit-confirm(ACTION &optional PROMPT PROMPT-N NOABORT (ITEMS nil SITEMS) PROMPT-SUFFIX)
magit-unmerged-section-p(OBJ)
magit--version>(V1 V2)
magit--ext-regexp-quote(STRING)
magit-unpulled-section-p(OBJ)
magit-read-char-case(PROMPT VERBOSE &rest CLAUSES)
magit-y-or-n-p(PROMPT &optional ACTION)
magit--version>=(V1 V2)
magit-confirm-files(ACTION FILES &optional PROMPT PROMPT-SUFFIX NOABORT)
magit-file-section(&rest SLOTS)
magit-file-lines(FILE &optional KEEP-EMPTY-LINES)
magit-unpulled-section--eieio-childp(OBJ)
magit-unpushed-section-p(OBJ)
magit-commit-section(&rest SLOTS)
magit-diff-section-child-p(OBJ)
magit--ellipsis(&optional WHERE)
magit-diff-section(&rest _)
magit--with-temp-position(BUF POS &rest BODY)
org-man-export@gitman(FN LINK DESCRIPTION FORMAT)
magit-message(FORMAT-STRING &rest ARGS)
magit-read-string(PROMPT &optional INITIAL-INPUT HISTORY DEFAULT-VALUE INHERIT-INPUT-METHOD NO-WHITESPACE)
magit-unmerged-section--eieio-childp(OBJ)
magit-unpulled-section(&rest SLOTS)
magit-read-string-ns(PROMPT &optional INITIAL-INPUT HISTORY DEFAULT-VALUE INHERIT-INPUT-METHOD)
magit--find-buffer(&rest PLIST)
magit-which-function()
magit-module-section-child-p(OBJ)
magit-log-section(&rest _)
magit-unmerged-section-child-p(OBJ)
magit-hook-custom-get(SYMBOL)
magit-file-section-p(OBJ)
magit-file-line(FILE)
magit--chase-links(FILENAME)
magit-completing-read(PROMPT COLLECTION &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF FALLBACK)
magit-read-number-string(PROMPT &optional DEFAULT HISTORY)
magit-msg(FORMAT-STRING &rest ARGS)
magit-hunk-section--eieio-childp(OBJ)
magit--delete-text-properties(STRING &optional PROPS)
magit-delete-match(&optional NUM)
magit-emacs-Q-command()
magit-log-section-child-p(OBJ)
magit-copy-thing()
magit-repository-local-delete(KEY &optional REPOSITORY)
magit-delete-thing()
magit-get-mode-buffer(MODE &optional VALUE FRAME)
magit-setup-buffer-internal
magit-maybe-set-dedicated()
magit-hack-dir-local-variables()
magit-mode-menu(ARG1)
magit-generate-new-buffer(MODE &optional VALUE DIRECTORY)
magit-maybe-save-repository-buffers()
magit--maybe-uniquify-buffer-names(BUFFER NAME MODE)
magit-setup-buffer
magit-repository-local-exists-p(KEY &optional REPOSITORY)
magit-refresh-buffer
magit-repository-local-repository()
magit-display-buffer-same-window-except-diff-v1(BUFFER)
magit-toggle-verbose-refresh()
magit-toggle-buffer-lock()
magit-profile-refresh-buffer()
magit-run-hook-with-benchmark(HOOK)
magit--display-buffer-fullframe(BUFFER ALIST)
magit-insert-xref-buttons()
magit-refresh()
magit-generate-buffer-name-default-function(MODE &optional VALUE)
magit-display-buffer-traditional(BUFFER)
magit--display-buffer-fullcolumn(BUFFER ALIST)
magit-go-forward()
magit-mode-bury-buffer(&optional KILL-BUFFER)
magit-visit-thing()
magit-info()
magit-zap-caches(&optional ALL)
magit-browse-thing()
magit-toggle-profiling()
magit-xref-restore(FN DIR ARGS)
magit--with-repository-local-cache(KEY &rest BODY)
magit-save-window-configuration()
magit-buffer-revision()
magit-buffer-value()
magit-display-buffer-fullcolumn-most-v1(BUFFER)
magit-after-save-refresh-status()
magit--refresh-buffer-set-positions(POSITIONS)
magit-display-buffer(BUFFER &optional DISPLAY-FUNCTION)
magit-go-backward()
magit-xref-insert-button(LABEL TYPE)
magit-repository-local-get(KEY &optional DEFAULT REPOSITORY)
magit-file-region-line-numbers()
magit-mode-quit-window(KILL-BUFFER)
magit-buffer-file-name()
magit-revert-buffer(IGNORE-AUTO NOCONFIRM)
magit-display-buffer-fullframe-status-topleft-v1(BUFFER)
magit-edit-thing()
magit-repository-local-set(KEY VALUE &optional REPOSITORY)
magit-save-repository-buffers(&optional ARG)
magit--display-buffer-topleft(BUFFER ALIST)
magit-restore-section-visibility-cache(MODE)
magit-refresh-all()
magit-restore-window-configuration(&optional KILL-BUFFER)
magit-mode()
magit-display-buffer-fullframe-status-v1(BUFFER)
magit-xref-setup(FN ARGS)
magit-diff--maybe-add-stat-arguments(ARGS)
magit-diff-toggle-file-filter()
magit-diff-paths(A B)
magit-diff-show-or-scroll-down()
magit-diff-visit-worktree-file-other-window()
magit--insert-related-refs(REV ARG TITLE REMOTE)
magit-diff-setup-buffer(RANGE TYPEARG ARGS FILES &optional TYPE LOCKED)
magit-diff-hunk-region-patch(SECTION &optional ARGS)
magit-jump-to-revision-headers(&optional ARG1)
transient:magit-diff-infix-arguments:--ignore-all-space()
magit-diff-highlight-hunk-region-using-face(SECTION)
magit-diff:--diff-algorithm()
magit-insert-revision-message()
magit-diff-toggle-refine-hunk(&optional STYLE)
magit-diff-visit--offset(LINE FILE &rest ARGS)
magit-insert-diff()
magit-diff-wash-diff(ARGS)
magit-insert-revision-notes()
magit-diff--region-range(&optional INTERACTIVE MBASE)
magit-diff-refresh-prefix-child-p(OBJ)
magit-diff-unstaged(&optional ARGS FILES)
magit-diff-refresh-prefix-p(OBJ)
magit-diff-set-context(FN)
magit-diff-visit-file--internal(FORCE-WORKTREE DISPLAY)
magit-diff:--show-signature()
magit-jump-to-revision-diffstat(&optional EXPAND)
magit-diff-flip-revs()
magit-diff-type(&optional SECTION)
magit-diff-dwim(&optional ARGS FILES)
magit-diff-refresh()
magit-diff-visit-file--setup(BUF POS)
magit-diff:-U()
magit-jump-to-revision-notes(&optional ARG1)
magit-insert-revision-gravatar(BEG REV EMAIL REGEXP)
magit-diff-visit-file-other-frame()
magit-highlight-bracket-keywords()
magit-diff-switch-range-type()
magit-diff-highlight-hunk-region-dim-outside(SECTION)
magit-diff-visit--position(BUFFER REV FILE GOTO-FROM GOTO-FILE)
magit-diff-select-color-moved-mode(&rest IGNORE)
transient:magit-diff-infix-arguments:--ignore-space-change()
magit-diff-mode()
magit-jump-to-revision-diff(&optional EXPAND)
magit-diff:-C()
magit-diff-on-removed-line-p()
magit-diff-read-range-or-commit(PROMPT &optional SECONDARY-DEFAULT MBASE)
magit-diff--dwim()
magit-diff-range(REV-OR-RANGE &optional ARGS FILES)
magit-diff-prefix(&rest SLOTS)
magit-format-file-nerd-icons(KIND FILE FACE &optional STATUS ORIG)
magit-diff-paint-whitespace(MERGING LINE-TYPE DIFF-TYPE)
magit-diff:--stat()
magit-diff-staged(&optional REV ARGS FILES)
magit-diff-toggle-fontify-hunk(&optional STYLE)
magit-diff--get-hunk-text(HUNK FROM)
magit-diff--get-hunk-syntax(HUNK SIDE REV FILE)
magit-diff-unmerged(&optional ARGS FILES)
magit-diff-arguments(&optional MODE)
magit-diff-file-header(SECTION &optional NO-RENAME)
magit-diff-highlight-hunk-region-using-underline(SECTION)
magit-revision-setup-buffer(REV ARGS FILES)
transient:magit-diff-infix-arguments:--function-context()
magit-diff:--color-moved()
magit-diff--modified-lines(BOUND)
magit-diff:--no-ext-diff()
magit-diff-show-or-scroll-up()
magit-read-similarity-index(PROMPT INITIAL-INPUT HISTORY)
magit-diff-select-algorithm(&rest IGNORE)
magit-diff-prefix-p(OBJ)
magit-diff-visit-file--noselect(&optional GOTO-FILE)
magit-insert-staged-changes()
magit-merge-preview-setup-buffer(REV)
magit-diff--hunk-after-string(FACE)
magit-read-files(PROMPT INITIAL-INPUT HISTORY &optional LIST-FN)
magit-hunk-set-window-start(SECTION)
magit-diff-wash-signature(OBJECT)
magit-diff-refresh-prefix(&rest SLOTS)
magit-diff--goto-file-position(FILE LINE COLUMN &optional PARENT)
magit-diff-visit-file-other-window()
magit-jump-to-revision-message(&optional ARG1)
magit-diff()
magit-insert-revision-tag()
magit-highlight-squash-markers()
magit-diff-paint-tab(MERGING WIDTH)
magit-diff-prefix-child-p(OBJ)
magit-diff-less-context(&optional COUNT)
magit-diff-use-window-width-as-stat-width()
magit-diff-visit-worktree-file-other-frame()
magit-diff--modified-defuns-1(REV FILE LINES)
magit-diff-more-context(&optional COUNT)
magit--diff-pair(BUFFER A B &optional FILE)
magit-section-cycle-diffs()
magit-diff-update-hunk-refinement(&optional SECTION ALLOW-REMOVE)
magit-diff-while-committing()
transient:magit-diff-infix-arguments:--find-copies-harder()
magit-diff--set-value(OBJ &optional SAVE)
magit-diff:--ignore-submodules()
magit-diff-working-tree(&optional REV ARGS FILES)
magit:--()
magit--get-file-icon(KIND FILE FACE STATUS ORIG ICON-FOR-FILE ICON-FOR-DIR DIR-IS-SUBMODULE)
magit-diff-expansion-threshold(SECTION)
magit-insert-revision-headers()
magit-jump-to-diffstat-or-diff(&optional EXPAND)
magit-diff-scope(&optional (SECTION nil SSECTION) STRICT)
magit-diff-visit-worktree-file(&optional OTHER-WINDOW)
magit-diff-inside-hunk-body-p()
magit-jump-to-staged(&optional ARG1)
magit-diff-insert-file-section(FILE ORIG STATUS MODES RENAME HEADER BINARY LONG-STATUS)
magit-jump-to-unstaged(&optional ARG1)
magit-diff-update-hunk-region(SECTION)
magit-diff-tab-width(FILE)
magit--insert-diff(KEEP-ERROR &rest ARGS)
magit-revision-mode()
magit-insert-revision-gravatar-cb(IMAGE SIZE REV MARKER ALIGN-TO COLUMN)
magit-format-file-all-the-icons(KIND FILE FACE &optional STATUS ORIG)
magit-format-file(KIND FILE FACE &optional STATUS ORIG)
magit-diff-hunk-column(SECTION GOTO-FROM)
magit-diff-prefix--eieio-childp(OBJ)
magit-diff-refresh-buffer()
magit-diff-select-merges(&rest IGNORE)
magit-revision-insert-related-refs-display-p(SYM)
magit-diff:--diff-merges()
magit-diff-hunk-region-header(SECTION)
magit-diff-visit-file(&optional OTHER-WINDOW)
magit-diff-show-or-scroll(FN)
magit-insert-revision-gravatars(REV BEG)
magit-diff--update-hunk-syntax(&optional HUNK)
magit-diff-highlight-hunk-region-using-overlays(SECTION)
magit-diff-select-color-moved-ws-mode(&rest IGNORE)
magit-diff-visit-directory(DIRECTORY &optional OTHER-WINDOW)
magit-diff--range-to-endpoints(RANGE)
magit-diff--combined-p(SECTION)
magit-diff:--color-moved-ws()
transient:magit-diff-infix-arguments:--irreversible-delete()
magit-insert-unstaged-changes()
magit-show-commit-removing-file(FILE &optional ARGS)
magit-diff-refresh-prefix--eieio-childp(OBJ)
magit-format-file-default(KIND FILE FACE &optional STATUS ORIG)
magit-diff--get-value(MODE &optional USE-BUFFER-ARGS)
magit-diff--make-hunk-overlay(START END &rest ARGS)
magit-diff-select-ignore-submodules(&rest IGNORED)
magit-diff--locate-file-position(FILE LINE COLUMN &optional PARENT)
magit-merge-preview-mode()
magit-diff:-M()
magit-insert-revision-diff()
magit-diff-wash-diffs(ARGS &optional LIMIT)
magit-show-commit(REV &optional ARGS FILES MODULE)
magit-diff-default-context()
magit-diff-hunk-line(SECTION GOTO-FROM)
magit-revision-jump(&optional ARG1)
magit-diff:-R()
magit-diff-buffer-file(&optional UNSTAGED-ONLY)
magit-notes-merge(REF)
magit-core.notesRef()
transient:magit-notes:--dry-run()
magit-notes:--strategy()
magit-notes-read-refs(PROMPT &optional INITIAL-INPUT HISTORY)
magit-notes-remove(COMMIT &optional REF)
magit-notes-prune(&optional DRY-RUN)
magit-global-core.notesRef()
magit-notes-edit(COMMIT &optional REF)
magit-global-notes.displayRef()
magit-notes:--ref()
magit-notes.displayRef()
magit-notes-merge-commit()
magit-notes()
magit-notes-read-ref(PROMPT &optional INITIAL-INPUT HISTORY)
magit-notes-read-args(PROMPT)
magit-notes-merge-abort()
magit-stash-index(MESSAGE)
magit-stash-list()
magit-stash-clear(REF)
magit-stash-branch-here(STASH BRANCH)
magit-stash-apply(STASH)
magit-stash()
magit-stash-setup-buffer(STASH ARGS FILES)
magit-stash-keep-index(MESSAGE &optional INCLUDE-UNTRACKED)
magit-stash--apply-1(ACTION STASH)
magit-stash-create(MESSAGE INDEX WORKTREE UNTRACKED)
magit-stash-save(MESSAGE INDEX WORKTREE UNTRACKED &optional REFRESH KEEP NOERROR REF)
magit-jump-to-stashes(&optional ARG1)
magit-stash--apply(ACTION STASH)
magit-stash-insert-section(REV RANGE MESSAGE &optional FILES)
magit-stash-mode()
magit-stashes-maybe-update-stash-buffer(&optional _)
transient:magit-stash-push:--include-untracked()
magit-stash-read-message-traditional()
magit-stashes-mode()
magit-stash-read-message()
magit-snapshot-both(&optional INCLUDE-UNTRACKED)
magit-stash-worktree(MESSAGE &optional INCLUDE-UNTRACKED)
transient:magit-stash-push:--all()
transient:magit-stash:--include-untracked()
magit-stash-pop(STASH)
magit--run-git-stash(&rest ARGS)
magit-insert-stash-worktree()
magit-stash-store(MESSAGE REF REV)
magit-stash-push(&optional ARG1 ARG2)
transient:magit-stash:--all()
transient:magit-stash-push:--keep-index()
magit-insert-stash-index()
magit-insert-stash-notes()
magit-stash-branch(STASH BRANCH)
transient:magit-stash-push:--no-keep-index()
magit-stash-both(MESSAGE &optional INCLUDE-UNTRACKED)
magit-stash-format-patch(STASH)
magit-snapshot-worktree(&optional INCLUDE-UNTRACKED)
magit-insert-stash-untracked()
magit-snapshot-save(INDEX WORKTREE UNTRACKED &optional REFRESH)
magit-stash-drop(STASH)
magit-insert-stashes(&optional (REF "refs/stash") (HEADING "Stashes:"))
magit-snapshot-index()
magit-stash-show(STASH &optional ARGS FILES)
magit-bisect-run(CMDLINE &optional BAD GOOD ARGS)
magit-bisect()
magit-git-bisect(SUBCOMMAND &optional ARGS NO-ASSERT)
magit-bisect-start(BAD GOOD ARGS)
magit-bisect:--term-old()
magit-insert-bisect-rest()
magit-bisect-start--assert(BAD GOOD ARGS)
magit-bisect-mark()
magit-insert-bisect-output()
transient:magit-bisect:--no-checkout()
magit-bisect:--term-new()
transient:magit-bisect:--first-parent()
magit-bisect-reset()
magit-insert-bisect-log()
magit-wash-bisect-log(ARGS)
magit-unstage-buffer-file()
magit-stage-buffer-file()
magit-file-delete(FILES &optional FORCE)
magit-file-untrack(FILES &optional FORCE)
magit-file-unstage()
magit-read-unmerged-file(&optional PROMPT)
magit-find-file-noselect-1(REV FILE &optional NO-RESTORE-POSITION VOLATILE)
magit--get-blob-buffer(OBJ FILE &optional VOLATILE)
magit-find-git-config-file(FILENAME &optional WILDCARDS)
magit-file-stage()
magit--blob-cache-remove(BUFFER)
magit-bury-buffer(&optional KILL-BUFFER)
magit-find-file(REV FILE)
magit-blob-visit-file()
magit-kill-this-buffer()
magit-find-file-noselect(REV FILE &optional NO-RESTORE-POSITION VOLATILE)
magit-find-file-other-window(REV FILE)
magit-file-rename(FILE NEWNAME)
magit--inhibit-in-blob-buffers(FN &rest ARGS)
magit-find-file-index-noselect(FILE)
magit-blob-ancestor(REV FILE)
magit-find-git-config-file-other-window(FILENAME &optional WILDCARDS)
magit-read-tracked-file(PROMPT &optional INCLUDE-DIRS)
magit-read-changed-file(REV-OR-RANGE PROMPT &optional DEFAULT)
magit-blob-next()
magit-blob-mode(&optional ARG)
magit-find-file--internal(REV FILE DISPLAY)
magit--blob-buffer-name(OBJ FILE &optional VOLATILE RELATIVE)
magit--revert-blob-buffer(IGNORE-AUTO NOCONFIRM)
magit-find-file-read-args(PROMPT)
magit-read-file(PROMPT &optional TRACKED-ONLY INCLUDE-DIRS)
magit--refresh-blob-buffer(&optional FORCE)
magit-read-file-from-rev(REV PROMPT &optional DEFAULT INCLUDE-DIRS)
magit-bury-or-kill-buffer(&optional BURY-BUFFER)
magit-find-file--restore-position(BEFORE BLOB LINE COL)
magit-file-checkout(REV FILE)
magit-blob-previous()
magit-update-index()
magit--handle-blob-bookmark(BOOKMARK)
magit-read-file-choice(PROMPT FILES &optional ERROR DEFAULT)
magit-file-dispatch()
magit-find-git-config-file-other-frame(FILENAME &optional WILDCARDS)
magit-find-file-other-frame(REV FILE)
magit-blob-successor(REV FILE)
magit-blob-visit(REV FILE)
magit--blob-cache-put(BUFFER)
magit-split-range(RANGE &optional ABBREV)
magit-decode-git-path(PATH)
magit--insert-blob-contents(OBJ FILE)
magit-get-current-remote(&optional ALLOW-UNNAMED)
magit--early-process-lines(PROGRAM &rest ARGS)
magit-binary-files(&rest ARGS)
magit--git-insert(RETURN-ERROR &rest ARGS)
magit-get-unnamed-upstream(&optional BRANCH)
magit-ref-p(STRING)
magit--with-refresh-cache(KEY &rest BODY)
magit-git-executable()
magit-read-local-branch(PROMPT &optional SECONDARY-DEFAULT)
magit-get-current-branch()
magit-rev-name(REV &optional PATTERN NOT-ANCHORED)
magit-set-all(VALUES &rest KEYS)
magit-set-upstream-branch(BRANCH UPSTREAM)
magit--safe-default-directory(&optional FILE)
magit-set(VALUE &rest KEYS)
magit-anything-staged-p(&optional IGNORE-SUBMODULES &rest FILES)
magit-git-string-p(&rest ARGS)
magit-update-files(FILES)
magit--with-temp-process-buffer(&rest BODY)
magit-split-branch-name(BRANCH)
magit-revision-directories(REV)
magit-anything-unmerged-p(&rest FILES)
magit-run-git-hook(HOOK &rest ARGS)
magit-git-version<(N)
magit-list-worktrees()
magit-remote-list-branches(REMOTE)
magit-module-worktree-p(MODULE)
magit-git-failure(&rest ARGS)
magit-get-submodule-name(PATH)
magit-git-lines(&rest ARGS)
magit-ref-equal(A B)
magit--rev-dereference(REV)
magit-file-status(&rest ARGS)
magit--client-message(FORMAT-STRING &rest ARGS)
magit-list-remote-branches(&optional REMOTE)
magit-get-remote(&optional BRANCH)
magit-remote-list-tags(REMOTE)
magit--untracked-directories(&optional INCLUDE-IGNORED DIRECTORY)
magit-list-refs(&optional NAMESPACES FORMAT SORTBY)
magit-ref-exists-p(REF)
magit-untracked-files(&optional INCLUDE-IGNORED DIRECTORY)
magit-format-ref-labels(STRING)
magit-toggle-git-debug()
magit-with-temp-index(TREE ARG &rest BODY)
magit-skip-worktree-files(&rest ARGS)
magit-with-editor(&rest BODY)
magit-get-push-branch(&optional BRANCH VERIFY)
magit-rev-head-p(REV)
magit-format-refs(FORMAT &rest ARGS)
magit-commit-children(REV &optional ARGS)
magit-convert-filename-for-git(FILENAME)
magit-rev-fixup-target(REV)
magit-merge-base(A B &rest ARGS)
magit-git-executable-find(COMMAND)
magit-patch-id(REV)
magit-process-git-arguments--split(PROGRAM ARGS)
magit-rev-parse-true(&rest ARGS)
magit-inside-gitdir-p(&optional NOERROR)
magit-name-remote-branch(REV &optional LAX)
magit-module-at-point(&optional PREDICATE)
magit-file-relative-name(&optional FILE TRACKED)
magit-git-success(&rest ARGS)
magit--painted-branch-at-point(&optional TYPE)
magit-git-config-p(VARIABLE &optional DEFAULT)
magit-commit-p(REV)
magit-read-upstream-branch(&optional BRANCH PROMPT)
magit-lightweight-tag-p(STRING)
magit-module-confirm(VERB &optional PREDICATE)
magit-symbolic-ref-p(STRING)
magit-read-other-branch-or-commit(PROMPT &optional EXCLUDE SECONDARY-DEFAULT)
magit-git-repo-p(DIRECTORY &optional NON-BARE)
magit-git-insert(&rest ARGS)
magit-renamed-files(REVA REVB)
magit-read-remote-branch(PROMPT &optional REMOTE DEFAULT LOCAL-BRANCH REQUIRE-MATCH)
magit-process-git-arguments(ARGS &optional ASYNC)
magit-get-upstream-branch(&optional BRANCH)
magit-rev-branch(REV)
magit-expand-git-file-name(FILENAME)
magit-get-push-remote(&optional BRANCH)
magit-revision-files(REV)
magit-rev-author-p(REV)
magit-with-toplevel(&rest BODY)
magit-annotated-tag-p(STRING)
magit-git-wash(WASHER &rest ARGS)
magit-name-branch(REV &optional LAX)
magit-rev-hash(ARG1)
magit-modified-files(&optional NOMODULES FILES)
magit-toplevel(&optional DIRECTORY)
magit-module-no-worktree-p(MODULE)
magit-list-branches-pointing-at(REV)
magit-rev-insert-format(FORMAT &optional REV ARGS)
magit-read-other-local-branch(PROMPT &optional EXCLUDE SECONDARY-DEFAULT)
magit-read-refspec(PROMPT REMOTE)
magit-list-unmerged-to-upstream-branches()
magit-ref-maybe-qualify(REFNAME &optional PREFIX)
magit--file-index-stages(FILE)
magit-get-some-remote(&optional BRANCH)
magit-get-boolean(&rest KEYS)
magit-list-refnames(&optional NAMESPACES INCLUDE-SPECIAL)
magit-ignore-submodules-p(&optional RETURN-ARGUMENT)
magit-get-upstream-remote(&optional BRANCH ALLOW-UNNAMED)
magit-changed-files(REV-OR-RANGE &optional OTHER-REV)
magit--abbrev-if-oid(OBJ)
magit-merge-commit-p(COMMIT)
magit-read-module-path(PROMPT &optional PREDICATE)
magit--split-range-raw(RANGE)
magit-git-str(&rest ARGS)
magit-hash-range(RANGE)
magit-read-starting-point(PROMPT &optional BRANCH DEFAULT)
magit-config-get-from-cached-list(KEY)
magit-list-stashes(&optional FORMAT)
magit--get-default-branch(&optional UPDATE)
magit-commit-worktree(MESSAGE &optional ARG &rest OTHER-PARENTS)
magit-get-upstream-ref(&optional BRANCH)
magit-rev-verify-commit(REV)
magit-git-exit-code(&rest ARGS)
magit-abbrev-arg(&optional ARG)
magit-read-branch(PROMPT &optional SECONDARY-DEFAULT)
magit-ref-abbrev(REFNAME)
magit-gitdir(&optional DIRECTORY COMMON)
magit--assert-default-directory(&optional NOERROR)
magit-ref-ambiguous-p(REFNAME)
magit-bare-repo-p(&optional NOERROR)
magit-assume-unchanged-files(&rest ARGS)
magit-file-ignored-p(FILE)
magit--valid-upstream-p(REMOTE MERGE)
magit-branch-merged-p(BRANCH &optional TARGET)
magit-read-branch-or-commit(PROMPT &optional SECONDARY-DEFAULT EXCLUDE)
magit-staged-files(&optional NOMODULES FILES)
magit-commit-tree(MESSAGE &optional TREE &rest PARENTS)
magit-no-commit-p()
magit-list-files(&rest ARGS)
magit-read-local-branch-or-ref(PROMPT &optional SECONDARY-DEFAULT)
magit-local-branch-p(STRING)
magit-read-other-branch(PROMPT &optional EXCLUDE SECONDARY-DEFAULT)
magit-rev-ancestor-p(A B)
magit-git-dir(&optional PATH)
magit-list-active-notes-refs()
magit-list-unmerged-branches(&optional REV &rest ARGS)
magit-get(&rest KEYS)
magit--unnamed-upstream-p(REMOTE MERGE)
magit-remote-list-refs(REMOTE)
magit-get-shortname(REV)
magit-read-range(PROMPT &optional DEFAULT)
magit-rev-equal(A B)
magit-get-local-upstream-branch(&optional BRANCH)
magit-git-string(&rest ARGS)
magit-rev-parse(&rest ARGS)
magit-blob-oid(REV FILE)
magit-remote-branch-p(STRING)
magit-update-ref(REF MESSAGE REV)
magit-format-rev-summary(REV)
magit-inside-worktree-p(&optional NOERROR)
magit-list-branches()
magit-list-local-branches()
magit--safe-git-version()
magit-rev-format(FORMAT &optional REV ARGS)
magit-list-merged-branches(&optional REV &rest ARGS)
magit-read-remote(PROMPT &optional DEFAULT USE-ONLY)
magit-list-related-branches(RELATION &optional REV &rest ARGS)
magit--rev-file-name(FILE REV OTHER-REV)
magit-read-shelved-branch(PROMPT)
magit-read-range-or-commit(PROMPT &optional SECONDARY-DEFAULT)
magit-rev-diff-count(A B &optional FIRST-PARENT)
magit-rev-verify(REV)
magit-get-current-tag(&optional REV WITH-DISTANCE)
magit-get-indirect-upstream-branch(BRANCH &optional FORCE)
magit-file-at-point(&optional EXPAND ASSERT)
magit-rev-parse-safe(&rest ARGS)
magit-anything-modified-p(&optional IGNORE-SUBMODULES &rest FILES)
magit-git-version()
magit-read-local-branch-or-commit(PROMPT)
magit-rev-eq(A B)
magit-blob-p(OBJ)
magit-main-branch(&optional REMOTE)
magit-commit-oid(REV &optional NOERROR)
magit-read-branch-prefer-other(PROMPT)
magit-get-all(&rest KEYS)
magit-remote-head(REMOTE)
magit-with-blob(REV FILE &rest BODY)
magit-stashed-files(STASH)
magit-read-stash(PROMPT)
magit-primary-remote()
magit-thingatpt--git-revision(&optional DISALLOW)
magit-git-items(&rest ARGS)
magit-unstaged-files(&optional NOMODULES FILES)
magit-headish()
magit-get-tracked(REFNAME)
magit-ignored-files(&rest ARGS)
magit-rev-abbrev(REV)
magit-git-output(&rest ARGS)
magit-ref-fullname(REFNAME)
magit-tracked-files(&rest ARGS)
magit-read-other-branches-or-commits(PROMPT &optional EXCLUDE SECONDARY-DEFAULT)
magit-git-false(&rest ARGS)
magit-anything-unstaged-p(&optional IGNORE-SUBMODULES &rest FILES)
magit--with-safe-default-directory(FILE &rest BODY)
magit-git-version-assert(&optional MINIMAL WHO)
magit-ref-eq(A B)
magit-list-untracked-files(&optional FILES)
magit-get-previous-branch()
magit-commit-parents(REV)
magit-list-remote-branch-names(&optional REMOTE RELATIVE)
magit-branch-set-face(BRANCH)
magit--git-wash(WASHER KEEP-ERROR &rest ARGS)
magit-read-tag(PROMPT)
magit--set-default-branch(NEWNAME OLDNAME)
magit-read-remote-or-url(PROMPT &optional DEFAULT)
magit-list-containing-branches(&optional REV &rest ARGS)
magit-get-@{push}-branch(&optional BRANCH)
magit-get-next-tag(&optional REV WITH-DISTANCE)
magit-remote-p(STRING)
magit-object-type(OBJECT)
magit-name-tag(REV &optional LAX)
magit--abbrev-if-hash(OBJ)
magit-tag-p(STRING)
magit-git-string-ng(&rest ARGS)
magit-branch-p(STRING)
magit-name-local-branch(REV &optional LAX)
magit-git-version>=(N)
magit-rev-parse-false(&rest ARGS)
magit-git-true(&rest ARGS)
magit-file-tracked-p(FILE)
magit-debug-git-executable()
magit-list-publishing-branches(&optional REV)
magit-rev-parse-p(&rest ARGS)
magit-repolist-column-stashes(SPEC)
magit-read-repository(&optional READ-DIRECTORY-NAME)
magit-repolist-setup(COLUMNS)
magit-repolist-version<(A B)
magit-repolist--mapc(FN REPOS &optional MSG)
magit-repolist-make-sorter(SORT-PREDICATE CONVERT-CELL COLUMN-IDX)
magit-repolist-fetch(REPOS)
magit-repolist-status(&optional BUTTON)
magit-repolist-column-upstream(_)
magit-repolist-unmark()
magit-repolist-column-unpushed-to-upstream(SPEC)
magit-repolist-column-path(_)
magit-list-repositories()
magit-repolist--format-entry(ENTRY)
magit-repolist-column-unpulled-from-pushremote(SPEC)
magit-repolist-column-flag(_)
magit-list-repos-uniquify(ALIST)
magit-repolist-find-file-other-frame(REPOS FILE)
magit-repolist-column-unpushed-to-pushremote(SPEC)
magit-repolist-mode()
magit-repolist-insert-count(N SPEC)
magit-repolist-column-unpulled-from-upstream(SPEC)
magit-repolist-column-branches(SPEC)
magit-repolist--marked-repos(&optional CHAR)
magit-repolist--ensure-padding()
magit-list-repos-1(DIRECTORY DEPTH)
magit-repolist--get-repos(&optional CHAR)
magit-repolist-column-version(_)
magit-repolist-column-branch(_)
magit-repolist-column-flags(_)
magit-repolist-mark()
magit-repolist-column-ident(SPEC)
magit-git-rebase(TARGET ARGS)
magit-rebase-subset(NEWBASE START ARGS)
transient:magit-rebase:--keep-empty()
magit-rebase-edit-commit(COMMIT ARGS)
magit-rebase-interactive-1(COMMIT ARGS MESSAGE &optional EDITOR DELAY-EDIT-CONFIRM NOASSERT CONFIRM EXACT)
transient:magit-rebase:--no-verify()
magit--cherry-move(COMMITS SRC DST ARGS &optional START-POINT CHECKOUT-DST)
magit-sequence-insert-am-patch(TYPE PATCH FACE)
magit-rebase-onto-upstream(ARG1)
magit-rebase-continue(&optional NOEDIT)
magit-rebase-autosquash(SELECT ARGS)
transient:magit-am:--scissors()
magit-cherry-harvest(COMMITS BRANCH &optional ARGS)
magit-revert-read-args(PROMPT)
magit-insert-rebase-sequence()
magit-cherry-apply(COMMITS &optional ARGS)
transient:magit-am:--ignore-date()
magit-rebase--get-state-lines(FILE)
magit-rebase-skip()
transient:magit-rebase:--ignore-date()
magit-rebase:--exec()
magit-rebase-in-progress-p()
magit-am-apply-maildir(&optional MAILDIR ARGS)
magit-revert-and-commit(COMMIT &optional ARGS)
magit-sequence-insert-step(TYPE TARGET)
transient:magit-revert:--edit()
magit-rebase()
transient:magit-rebase:--autosquash()
magit-rebase-interactive-assert(SINCE &optional DELAY-EDIT-CONFIRM REBASE-MERGES)
transient:magit-am:--reject()
magit-cherry-copy(COMMITS &optional ARGS)
magit-cherry-pick:--mainline()
transient:magit-am:--keep()
magit-sequencer-continue()
magit-rebase--perl-editor(ACTION SINCE)
magit-am-apply-patches(&optional FILES ARGS)
transient:magit-rebase:--force-rebase()
transient:magit-revert:--no-edit()
magit-cherry-spinoff(COMMITS BRANCH START-POINT &optional ARGS)
magit-rebase-interactive(COMMIT ARGS)
magit-rebase--todo()
magit--cherry-spinoff-read-args(VERB)
magit-revert()
magit-rebase-remove-commit(COMMIT ARGS)
transient:magit-rebase:--rebase-merges=()
magit-rebase-insert-merge-sequence(ONTO)
magit-sequencer-skip()
magit-sequence-insert-sequence(STOP ONTO &optional ORIG)
magit-rebase-onto-pushremote(ARG1)
transient:magit-rebase:--committer-date-is-author-date()
magit--cherry-move-read-args(VERB AWAY FN &optional ALLOW-DETACHED)
magit-rebase-edit()
magit-apply:-p()
magit-cherry-donate(COMMITS BRANCH &optional ARGS)
transient:magit-am:--3way()
magit-rebase--target-commit(SINCE)
magit-rebase-insert-apply-sequence(ONTO)
transient:magit-cherry-pick:--ff()
transient:magit-rebase:--update-refs()
magit-am()
transient:magit-rebase:--interactive()
transient:magit-am:--keep-non-patch()
transient:magit-cherry-pick:--edit()
magit-rebase-branch(TARGET ARGS)
magit-cherry-pick()
magit-am-skip()
magit-revert-no-commit(COMMIT &optional ARGS)
transient:magit-rebase:--autostash()
magit-sequencer-abort()
transient:magit-cherry-pick:-x()
magit-cherry-pick-read-args(PROMPT)
magit-am-abort()
magit-rebase-abort()
magit-rebase-reword-commit(COMMIT ARGS)
magit-am-continue()
magit-insert-am-sequence()
magit-cherry-spinout(COMMITS BRANCH START-POINT &optional ARGS)
transient:magit-rebase:--preserve-merges()
magit--cherry-pick(COMMITS ARGS &optional REVERT)
magit-insert-sequencer-sequence()
transient:magit-am:--committer-date-is-author-date()
magit-sequence-insert-commit(TYPE HASH FACE &optional ABBREV MSG)
magit-rebase-merges-select-mode(&rest IGNORE)

Defined faces (113)

magit-reflog-remoteFace for pull and clone commands in reflogs.
magit-reflog-commitFace for commit commands in reflogs.
magit-reflog-resetFace for reset commands in reflogs.
magit-reflog-mergeFace for merge, checkout and branch commands in reflogs.
magit-reflog-otherFace for other commands in reflogs.
magit-reflog-rebaseFace for rebase commands in reflogs.
magit-reflog-amendFace for amend commands in reflogs.
magit-reflog-checkoutFace for checkout commands in reflogs.
magit-reflog-cherry-pickFace for cherry-pick commands in reflogs.
magit-process-ngFace for non-zero exit-status.
magit-mode-line-process-errorFace for `mode-line-process' error status. Used when `magit-process-display-mode-line-error' is non-nil.
magit-mode-line-processFace for `mode-line-process' status when Git is running for side-effects.
magit-process-okFace for zero exit-status.
magit-dimmedFace for text that shouldn't stand out.
magit-cherry-unmatchedFace for unmatched cherry commits.
magit-keyword-squashFace for squash! and similar keywords in commit messages.
magit-header-line-keyFace for keys in the `header-line'.
magit-branch-remote-headFace for current branch.
magit-header-lineFace for the `header-line' in some Magit modes. Note that some modes, such as `magit-log-select-mode', have their own faces for the `header-line', or for parts of the `header-line'.
magit-signature-goodFace for good signatures.
magit-keywordFace for parts of commit messages inside brackets.
magit-branch-remoteFace for remote branch head labels shown in log buffer.
magit-signature-untrustedFace for good untrusted signatures.
magit-filenameFace for filenames.
magit-signature-expired-keyFace for signatures made by an expired key.
magit-hashFace for the commit object name in the log output.
magit-signature-errorFace for signatures that cannot be checked (e.g., missing key).
magit-headFace for the symbolic ref `HEAD'.
magit-refname-stashFace for stash refnames.
magit-branch-localFace for local branches.
magit-refname-wipFace for wip refnames.
magit-refname-pullreqFace for pullreq refnames.
magit-branch-upstreamFace for upstream branch. This face is only used in logs and it gets combined with `magit-branch-local', `magit-branch-remote' and/or `magit-branch-remote-head'.
magit-cherry-equivalentFace for equivalent cherry commits.
magit-signature-revokedFace for signatures made by a revoked key.
magit-signature-expiredFace for signatures that have expired.
magit-refnameFace for refnames without a dedicated face.
magit-branch-warningFace for warning about (missing) branch.
magit-branch-currentFace for current branch.
magit-tagFace for tag labels shown in log buffer.
magit-signature-badFace for bad signatures.
git-commit-comment-headingFace used for headings in commit message comments.
git-commit-comment-fileFace used for file names in commit message comments.
git-commit-summaryFace used for the summary in commit messages.
git-commit-comment-branch-remoteFace used for names of remote branches in commit message comments.
git-commit-trailer-valueFace used for Git trailer values in commit messages.
git-commit-comment-branch-localFace used for names of local branches in commit message comments.
git-commit-overlong-summaryFace used for the tail of overlong commit message summaries.
git-commit-comment-actionFace used for actions in commit message comments.
git-commit-trailer-tokenFace used for Git trailer tokens in commit messages.
git-commit-comment-detachedFace used for detached `HEAD' in commit message comments.
git-commit-comment-buttonFace used for buttons in commit message comments.
git-commit-nonempty-second-lineFace used for non-whitespace on the second line of commit messages.
git-commit-keywordFace used for keywords in commit messages. In this context a "keyword" is text surrounded by brackets.
magit-header-line-log-selectFace for the `header-line' in `magit-log-select-mode'.
magit-log-graphFace for the graph part of the log output.
magit-log-dateFace for the date part of the log output.
magit-log-authorFace for the author part of the log output.
magit-blame-highlightFace used for highlighting when blaming. Also see option `magit-blame-styles'.
magit-blame-marginFace used for the blame margin by default when blaming. Also see option `magit-blame-styles'.
magit-blame-hashFace used for commit hashes when blaming.
magit-blame-dateFace used for dates when blaming.
magit-blame-headingFace used for blame headings by default when blaming. Also see option `magit-blame-styles'.
magit-blame-dimmedFace used for the blame margin in some cases when blaming. Also see option `magit-blame-styles'.
magit-blame-nameFace used for author and committer names when blaming.
magit-blame-summaryFace used for commit summaries when blaming.
magit-diffstat-removedFace for removal indicator in diffstat.
magit-diff-file-heading-selectionFace for selected diff file headings.
magit-diff-their-headingFace for headings of their side in merge conflicts.
magit-diff-lines-headingFace for diff hunk heading when lines are marked.
magit-diffstat-addedFace for addition indicator in diffstat.
magit-diff-our-indicatorFace for indicators on lines in a diff for our side in a conflict. Only used if `magit-diff-use-indicator-faces' is non-nil.
magit-diff-our-highlightFace for lines in a diff for our side in a conflict.
magit-diff-baseFace for lines in a diff for the base side in a conflict.
magit-diff-file-heading-highlightFace for current diff file headings.
magit-diff-base-indicatorFace for indicators on lines in a diff for base side in a conflict. Only used if `magit-diff-use-indicator-faces' is non-nil.
magit-diff-base-headingFace for headings of common base in merge conflicts.
magit-diff-whitespace-warningFace for highlighting whitespace errors added lines.
magit-diff-added-indicatorFace for indicators on lines in a diff that have been added. Only used if `magit-diff-use-indicator-faces' is non-nil.
magit-diff-ourFace for lines in a diff for our side in a conflict.
magit-diff-file-headingFace for diff file headings.
magit-diff-theirFace for lines in a diff for their side in a conflict.
magit-diff-revision-summaryFace for commit message summaries.
magit-diff-conflict-heading-highlightFace for conflict markers.
magit-diff-addedFace for lines in a diff that have been added.
magit-diff-removedFace for lines in a diff that have been removed.
magit-diff-our-headingFace for headings of our side in merge conflicts.
magit-diff-hunk-regionFace used by `magit-diff-highlight-hunk-region-using-face'. This face is overlaid over text that uses other hunk faces, and those normally set the foreground and background colors. The `:foreground' and especially the `:background' properties should be avoided here. Setting the latter would cause the loss of information. Good properties to set here are `:weight' and `:slant'.
magit-diff-removed-indicatorFace for indicators on lines in a diff that have been removed. Only used if `magit-diff-use-indicator-faces' is non-nil.
magit-diff-context-highlightFace for lines in the current context in a diff.
magit-diff-base-highlightFace for lines in a diff for the base side in a conflict.
magit-diff-conflict-headingFace for conflict markers.
magit-diff-their-highlightFace for lines in a diff for their side in a conflict.
magit-diff-contextFace for lines in a diff that are unchanged.
magit-diff-hunk-heading-highlightFace for current diff hunk headings.
magit-diff-hunk-heading-selectionFace for selected diff hunk headings.
magit-diff-hunk-headingFace for diff hunk headings.
magit-diff-their-indicatorFace for indicators on lines in a diff for their side in a conflict. Only used if `magit-diff-use-indicator-faces' is non-nil.
magit-diff-lines-boundaryFace for boundary of marked lines in diff hunk.
magit-diff-revision-summary-highlightFace for highlighted commit message summaries.
magit-diff-removed-highlightFace for lines in a diff that have been removed.
magit-diff-added-highlightFace for lines in a diff that have been added.
magit-bisect-goodFace for good bisect revisions.
magit-bisect-skipFace for skipped bisect revisions.
magit-bisect-badFace for bad bisect revisions.
magit-sequence-dropFace used in sequence sections.
magit-sequence-ontoFace used in sequence sections.
magit-sequence-headFace used in sequence sections.
magit-sequence-doneFace used in sequence sections.
magit-sequence-pickFace used in sequence sections.
magit-sequence-stopFace used in sequence sections.
magit-sequence-execFace used in sequence sections.
magit-sequence-partFace used in sequence sections.