#compdef jj

autoload -U is-at-least

_jj() {
    typeset -A opt_args
    typeset -a _arguments_options
    local ret=1

    if is-at-least 5.2; then
        _arguments_options=(-s -S -C)
    else
        _arguments_options=(-s -C)
    fi

    local context curcontext="$curcontext" state line
    _arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'-V[Print version information]' \
'--version[Print version information]' \
":: :_jj_commands" \
"*::: :->jj" \
&& ret=0
    case $state in
    (jj)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-command-$line[1]:"
        case $line[1] in
            (version)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(init)
_arguments "${_arguments_options[@]}" \
'--git-repo=[Path to a git repo the jj repo will be backed by]:GIT_REPO:_files -/' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--git[Use the Git backend, creating a jj repo backed by a Git repo]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::destination -- The destination directory:_files -/' \
&& ret=0
;;
(checkout)
_arguments "${_arguments_options[@]}" \
'-m+[The change description to use]:MESSAGE: ' \
'--message=[The change description to use]:MESSAGE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':revision -- The revision to update to:' \
&& ret=0
;;
(untrack)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Paths to untrack:_files' \
&& ret=0
;;
(files)
_arguments "${_arguments_options[@]}" \
'-r+[The revision to list files in]:REVISION: ' \
'--revision=[The revision to list files in]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Only list files matching these prefixes (instead of all files):_files' \
&& ret=0
;;
(print)
_arguments "${_arguments_options[@]}" \
'-r+[The revision to get the file contents from]:REVISION: ' \
'--revision=[The revision to get the file contents from]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':path -- The file to print:_files' \
&& ret=0
;;
(diff)
_arguments "${_arguments_options[@]}" \
'-r+[Show changes in this revision, compared to its parent(s)]:REVISION: ' \
'--revision=[Show changes in this revision, compared to its parent(s)]:REVISION: ' \
'(-r --revision)--from=[Show changes from this revision]:FROM: ' \
'(-r --revision)--to=[Show changes to this revision]:TO: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-s[For each path, show only whether it was modified, added, or removed]' \
'--summary[For each path, show only whether it was modified, added, or removed]' \
'--git[Show a Git-format diff]' \
'--color-words[Show a word-level diff with changes indicated only by color]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Restrict the diff to these paths:_files' \
&& ret=0
;;
(show)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'-s[For each path, show only whether it was modified, added, or removed]' \
'--summary[For each path, show only whether it was modified, added, or removed]' \
'--git[Show a Git-format diff]' \
'--color-words[Show a word-level diff with changes indicated only by color]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::revision -- Show changes in this revision, compared to its parent(s):' \
&& ret=0
;;
(status)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(log)
_arguments "${_arguments_options[@]}" \
'-r+[Which revisions to show. Defaults to the `ui.default-revset` setting, or "remote_branches().. | (remote_branches()..)-" if it is not set]:REVISIONS: ' \
'--revisions=[Which revisions to show. Defaults to the `ui.default-revset` setting, or "remote_branches().. | (remote_branches()..)-" if it is not set]:REVISIONS: ' \
'-T+[Render each revision using the given template (the syntax is not yet documented and is likely to change)]:TEMPLATE: ' \
'--template=[Render each revision using the given template (the syntax is not yet documented and is likely to change)]:TEMPLATE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--reversed[Show revisions in the opposite order (older revisions first)]' \
'--no-graph[Don'\''t show the graph, show a flat list of revisions]' \
'-p[Show patch]' \
'--patch[Show patch]' \
'-s[For each path, show only whether it was modified, added, or removed]' \
'--summary[For each path, show only whether it was modified, added, or removed]' \
'--git[Show a Git-format diff]' \
'--color-words[Show a word-level diff with changes indicated only by color]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Show commits modifying the given paths:_files' \
&& ret=0
;;
(obslog)
_arguments "${_arguments_options[@]}" \
'-r+[]:REVISION: ' \
'--revision=[]:REVISION: ' \
'-T+[Render each revision using the given template (the syntax is not yet documented and is likely to change)]:TEMPLATE: ' \
'--template=[Render each revision using the given template (the syntax is not yet documented and is likely to change)]:TEMPLATE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-graph[Don'\''t show the graph, show a flat list of revisions]' \
'-p[Show patch compared to the previous version of this change]' \
'--patch[Show patch compared to the previous version of this change]' \
'-s[For each path, show only whether it was modified, added, or removed]' \
'--summary[For each path, show only whether it was modified, added, or removed]' \
'--git[Show a Git-format diff]' \
'--color-words[Show a word-level diff with changes indicated only by color]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(interdiff)
_arguments "${_arguments_options[@]}" \
'--from=[Show changes from this revision]:FROM: ' \
'--to=[Show changes to this revision]:TO: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-s[For each path, show only whether it was modified, added, or removed]' \
'--summary[For each path, show only whether it was modified, added, or removed]' \
'--git[Show a Git-format diff]' \
'--color-words[Show a word-level diff with changes indicated only by color]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Restrict the diff to these paths:_files' \
&& ret=0
;;
(describe)
_arguments "${_arguments_options[@]}" \
'-m+[The change description to use (don'\''t open editor)]:MESSAGE: ' \
'--message=[The change description to use (don'\''t open editor)]:MESSAGE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--stdin[Read the change description from stdin]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::revision -- The revision whose description to edit:' \
&& ret=0
;;
(close)
_arguments "${_arguments_options[@]}" \
'-m+[The change description to use (don'\''t open editor)]:MESSAGE: ' \
'--message=[The change description to use (don'\''t open editor)]:MESSAGE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'-e[Also edit the description]' \
'--edit[Also edit the description]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::revision -- The revision to close:' \
&& ret=0
;;
(open)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':revision -- The revision to open:' \
&& ret=0
;;
(duplicate)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::revision -- The revision to duplicate:' \
&& ret=0
;;
(abandon)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::revisions -- The revision(s) to abandon:' \
&& ret=0
;;
(edit)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':revision -- The commit to edit:' \
&& ret=0
;;
(new)
_arguments "${_arguments_options[@]}" \
'-m+[The change description to use]:MESSAGE: ' \
'--message=[The change description to use]:MESSAGE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::revisions -- Parent(s) of the new change:' \
&& ret=0
;;
(move)
_arguments "${_arguments_options[@]}" \
'--from=[Move part of this change into the destination]:FROM: ' \
'--to=[Move part of the source into this change]:TO: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-i[Interactively choose which parts to move]' \
'--interactive[Interactively choose which parts to move]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Move only changes to these paths (instead of all paths):_files' \
&& ret=0
;;
(squash)
_arguments "${_arguments_options[@]}" \
'-r+[]:REVISION: ' \
'--revision=[]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-i[Interactively choose which parts to squash]' \
'--interactive[Interactively choose which parts to squash]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Move only changes to these paths (instead of all paths):_files' \
&& ret=0
;;
(unsquash)
_arguments "${_arguments_options[@]}" \
'-r+[]:REVISION: ' \
'--revision=[]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-i[Interactively choose which parts to unsquash]' \
'--interactive[Interactively choose which parts to unsquash]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(restore)
_arguments "${_arguments_options[@]}" \
'--from=[Revision to restore from (source)]:FROM: ' \
'--to=[Revision to restore into (destination)]:TO: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-i[Interactively choose which parts to restore]' \
'--interactive[Interactively choose which parts to restore]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Restore only these paths (instead of all paths):_files' \
&& ret=0
;;
(touchup)
_arguments "${_arguments_options[@]}" \
'-r+[The revision to touch up]:REVISION: ' \
'--revision=[The revision to touch up]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(split)
_arguments "${_arguments_options[@]}" \
'-r+[The revision to split]:REVISION: ' \
'--revision=[The revision to split]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::paths -- Put these paths in the first commit and don'\''t run the diff editor:_files' \
&& ret=0
;;
(merge)
_arguments "${_arguments_options[@]}" \
'-m+[The change description to use]:MESSAGE: ' \
'--message=[The change description to use]:MESSAGE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-r[Ignored (but lets you pass `-r` for consistency with other commands)]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::revisions -- Parent(s) of the new change:' \
&& ret=0
;;
(rebase)
_arguments "${_arguments_options[@]}" \
'-b+[Rebase the whole branch (relative to destination'\''s ancestors)]:BRANCH: ' \
'--branch=[Rebase the whole branch (relative to destination'\''s ancestors)]:BRANCH: ' \
'-s+[Rebase this revision and its descendants]:SOURCE: ' \
'--source=[Rebase this revision and its descendants]:SOURCE: ' \
'-r+[Rebase only this revision, rebasing descendants onto this revision'\''s parent(s)]:REVISION: ' \
'--revision=[Rebase only this revision, rebasing descendants onto this revision'\''s parent(s)]:REVISION: ' \
'*-d+[The revision(s) to rebase onto]:DESTINATION: ' \
'*--destination=[The revision(s) to rebase onto]:DESTINATION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(backout)
_arguments "${_arguments_options[@]}" \
'-r+[The revision to apply the reverse of]:REVISION: ' \
'--revision=[The revision to apply the reverse of]:REVISION: ' \
'*-d+[The revision to apply the reverse changes on top of]:DESTINATION: ' \
'*--destination=[The revision to apply the reverse changes on top of]:DESTINATION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(branch)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
":: :_jj__branch_commands" \
"*::: :->branch" \
&& ret=0

    case $state in
    (branch)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-branch-command-$line[1]:"
        case $line[1] in
            (create)
_arguments "${_arguments_options[@]}" \
'-r+[The branch'\''s target revision]:REVISION: ' \
'--revision=[The branch'\''s target revision]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::names -- The branches to create:' \
&& ret=0
;;
(delete)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::names -- The branches to delete:' \
&& ret=0
;;
(forget)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::names -- The branches to delete:' \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(set)
_arguments "${_arguments_options[@]}" \
'-r+[The branch'\''s target revision]:REVISION: ' \
'--revision=[The branch'\''s target revision]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'-B[Allow moving the branch backwards or sideways]' \
'--allow-backwards[Allow moving the branch backwards or sideways]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'*::names -- The branches to update:' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
":: :_jj__branch__help_commands" \
"*::: :->help" \
&& ret=0

    case $state in
    (help)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-branch-help-command-$line[1]:"
        case $line[1] in
            (create)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(delete)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(forget)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(set)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
        esac
    ;;
esac
;;
(undo)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::operation -- The operation to undo:' \
&& ret=0
;;
(operation)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
":: :_jj__operation_commands" \
"*::: :->operation" \
&& ret=0

    case $state in
    (operation)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-operation-command-$line[1]:"
        case $line[1] in
            (log)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(undo)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::operation -- The operation to undo:' \
&& ret=0
;;
(restore)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':operation -- The operation to restore to:' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
":: :_jj__operation__help_commands" \
"*::: :->help" \
&& ret=0

    case $state in
    (help)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-operation-help-command-$line[1]:"
        case $line[1] in
            (log)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(undo)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(restore)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
        esac
    ;;
esac
;;
(workspace)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
":: :_jj__workspace_commands" \
"*::: :->workspace" \
&& ret=0

    case $state in
    (workspace)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-workspace-command-$line[1]:"
        case $line[1] in
            (add)
_arguments "${_arguments_options[@]}" \
'--name=[A name for the workspace]:NAME: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':destination -- Where to create the new workspace:' \
&& ret=0
;;
(forget)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::workspace -- Name of the workspace to forget (the current workspace by default):' \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
":: :_jj__workspace__help_commands" \
"*::: :->help" \
&& ret=0

    case $state in
    (help)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-workspace-help-command-$line[1]:"
        case $line[1] in
            (add)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(forget)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
        esac
    ;;
esac
;;
(sparse)
_arguments "${_arguments_options[@]}" \
'*--add=[Patterns to add to the working copy]:ADD:_files' \
'(--clear)*--remove=[Patterns to remove from the working copy]:REMOVE:_files' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--clear[Include no files in the working copy (combine with --add)]' \
'(--add --remove --clear)--reset[Include all files in the working copy]' \
'(--add --remove --clear --reset)--list[List patterns]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(git)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
":: :_jj__git_commands" \
"*::: :->git" \
&& ret=0

    case $state in
    (git)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-git-command-$line[1]:"
        case $line[1] in
            (remote)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
":: :_jj__git__remote_commands" \
"*::: :->remote" \
&& ret=0

    case $state in
    (remote)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-git-remote-command-$line[1]:"
        case $line[1] in
            (add)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':remote -- The remote'\''s name:' \
':url -- The remote'\''s URL:' \
&& ret=0
;;
(remove)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':remote -- The remote'\''s name:' \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
":: :_jj__git__remote__help_commands" \
"*::: :->help" \
&& ret=0

    case $state in
    (help)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-git-remote-help-command-$line[1]:"
        case $line[1] in
            (add)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(remove)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
        esac
    ;;
esac
;;
(fetch)
_arguments "${_arguments_options[@]}" \
'--remote=[The remote to fetch from (only named remotes are supported)]:REMOTE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(clone)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':source -- URL or path of the Git repo to clone:_files -/' \
'::destination -- The directory to write the Jujutsu repo to:_files -/' \
&& ret=0
;;
(push)
_arguments "${_arguments_options[@]}" \
'--remote=[The remote to push to (only named remotes are supported)]:REMOTE: ' \
'--branch=[Push only this branch]:BRANCH: ' \
'--change=[Push this commit by creating a branch based on its change ID]:CHANGE: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--all[Push all branches]' \
'--dry-run[Only display what will change on the remote]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(import)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(export)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
":: :_jj__git__help_commands" \
"*::: :->help" \
&& ret=0

    case $state in
    (help)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-git-help-command-$line[1]:"
        case $line[1] in
            (remote)
_arguments "${_arguments_options[@]}" \
":: :_jj__git__help__remote_commands" \
"*::: :->remote" \
&& ret=0

    case $state in
    (remote)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-git-help-remote-command-$line[1]:"
        case $line[1] in
            (add)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(remove)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
(fetch)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(clone)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(push)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(import)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(export)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
        esac
    ;;
esac
;;
(debug)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
":: :_jj__debug_commands" \
"*::: :->debug" \
&& ret=0

    case $state in
    (debug)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-debug-command-$line[1]:"
        case $line[1] in
            (completion)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--bash[Print a completion script for Bash]' \
'--fish[Print a completion script for Fish]' \
'--zsh[Print a completion script for Zsh]' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(mangen)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(resolverev)
_arguments "${_arguments_options[@]}" \
'-r+[]:REVISION: ' \
'--revision=[]:REVISION: ' \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(workingcopy)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(template)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
':template:' \
&& ret=0
;;
(index)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(reindex)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
&& ret=0
;;
(operation)
_arguments "${_arguments_options[@]}" \
'-R+[Path to repository to operate on]:REPOSITORY:_files -/' \
'--repository=[Path to repository to operate on]:REPOSITORY:_files -/' \
'--at-operation=[Operation to load the repo at]:AT_OPERATION: ' \
'--at-op=[Operation to load the repo at]:AT_OPERATION: ' \
'--color=[When to colorize output (always, never, auto)]:WHEN: ' \
'--no-commit-working-copy[Don'\''t commit the working copy]' \
'-h[Print help information (use `--help` for more detail)]' \
'--help[Print help information (use `--help` for more detail)]' \
'::operation:' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
":: :_jj__debug__help_commands" \
"*::: :->help" \
&& ret=0

    case $state in
    (help)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-debug-help-command-$line[1]:"
        case $line[1] in
            (completion)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(mangen)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(resolverev)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(workingcopy)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(template)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(index)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(reindex)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(operation)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
        esac
    ;;
esac
;;
(help)
_arguments "${_arguments_options[@]}" \
":: :_jj__help_commands" \
"*::: :->help" \
&& ret=0

    case $state in
    (help)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-help-command-$line[1]:"
        case $line[1] in
            (version)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(init)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(checkout)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(untrack)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(files)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(print)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(diff)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(show)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(status)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(log)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(obslog)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(interdiff)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(describe)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(close)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(open)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(duplicate)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(abandon)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(edit)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(new)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(move)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(squash)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(unsquash)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(restore)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(touchup)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(split)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(merge)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(rebase)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(backout)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(branch)
_arguments "${_arguments_options[@]}" \
":: :_jj__help__branch_commands" \
"*::: :->branch" \
&& ret=0

    case $state in
    (branch)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-help-branch-command-$line[1]:"
        case $line[1] in
            (create)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(delete)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(forget)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(set)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
(undo)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(operation)
_arguments "${_arguments_options[@]}" \
":: :_jj__help__operation_commands" \
"*::: :->operation" \
&& ret=0

    case $state in
    (operation)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-help-operation-command-$line[1]:"
        case $line[1] in
            (log)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(undo)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(restore)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
(workspace)
_arguments "${_arguments_options[@]}" \
":: :_jj__help__workspace_commands" \
"*::: :->workspace" \
&& ret=0

    case $state in
    (workspace)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-help-workspace-command-$line[1]:"
        case $line[1] in
            (add)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(forget)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
(sparse)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(git)
_arguments "${_arguments_options[@]}" \
":: :_jj__help__git_commands" \
"*::: :->git" \
&& ret=0

    case $state in
    (git)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-help-git-command-$line[1]:"
        case $line[1] in
            (remote)
_arguments "${_arguments_options[@]}" \
":: :_jj__help__git__remote_commands" \
"*::: :->remote" \
&& ret=0

    case $state in
    (remote)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-help-git-remote-command-$line[1]:"
        case $line[1] in
            (add)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(remove)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(list)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
(fetch)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(clone)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(push)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(import)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(export)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
(debug)
_arguments "${_arguments_options[@]}" \
":: :_jj__help__debug_commands" \
"*::: :->debug" \
&& ret=0

    case $state in
    (debug)
        words=($line[1] "${words[@]}")
        (( CURRENT += 1 ))
        curcontext="${curcontext%:*:*}:jj-help-debug-command-$line[1]:"
        case $line[1] in
            (completion)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(mangen)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(resolverev)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(workingcopy)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(template)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(index)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(reindex)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
(operation)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
(help)
_arguments "${_arguments_options[@]}" \
&& ret=0
;;
        esac
    ;;
esac
;;
        esac
    ;;
esac
}

(( $+functions[_jj_commands] )) ||
_jj_commands() {
    local commands; commands=(
'version:Display version information' \
'init:Create a new repo in the given directory' \
'checkout:Create a new, empty change and edit it in the working copy' \
'co:Create a new, empty change and edit it in the working copy' \
'update:Create a new, empty change and edit it in the working copy' \
'up:Create a new, empty change and edit it in the working copy' \
'untrack:Stop tracking specified paths in the working copy' \
'files:List files in a revision' \
'print:Print contents of a file in a revision' \
'diff:Show changes in a revision' \
'show:Show commit description and changes in a revision' \
'status:Show high-level repo status' \
'st:Show high-level repo status' \
'log:Show commit history' \
'obslog:Show how a change has evolved' \
'interdiff:Compare the changes of two commits' \
'describe:Edit the change description' \
'close:Mark a revision closed' \
'commit:Mark a revision closed' \
'open:Mark a revision open' \
'duplicate:Create a new change with the same content as an existing one' \
'abandon:Abandon a revision' \
'hide:Abandon a revision' \
'edit:Edit a commit in the working copy' \
'new:Create a new, empty change and edit it in the working copy' \
'move:Move changes from one revision into another' \
'squash:Move changes from a revision into its parent' \
'amend:Move changes from a revision into its parent' \
'unsquash:Move changes from a revision'\''s parent into the revision' \
'unamend:Move changes from a revision'\''s parent into the revision' \
'restore:Restore paths from another revision' \
'touchup:Touch up the content changes in a revision' \
'split:Split a revision in two' \
'merge:Merge work from multiple branches' \
'rebase:Move revisions to different parent(s)' \
'backout:Apply the reverse of a revision on top of another revision' \
'branch:Manage branches' \
'undo:Undo an operation (shortcut for `jj op undo`)' \
'operation:Commands for working with the operation log' \
'op:Commands for working with the operation log' \
'workspace:Commands for working with workspaces' \
'sparse:Manage which paths from the current checkout are present in the working copy' \
'git:Commands for working with the underlying Git repo' \
'debug:Low-level commands not intended for users' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj commands' commands "$@"
}
(( $+functions[_jj__abandon_commands] )) ||
_jj__abandon_commands() {
    local commands; commands=()
    _describe -t commands 'jj abandon commands' commands "$@"
}
(( $+functions[_jj__help__abandon_commands] )) ||
_jj__help__abandon_commands() {
    local commands; commands=()
    _describe -t commands 'jj help abandon commands' commands "$@"
}
(( $+functions[_jj__git__help__remote__add_commands] )) ||
_jj__git__help__remote__add_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help remote add commands' commands "$@"
}
(( $+functions[_jj__git__remote__add_commands] )) ||
_jj__git__remote__add_commands() {
    local commands; commands=()
    _describe -t commands 'jj git remote add commands' commands "$@"
}
(( $+functions[_jj__git__remote__help__add_commands] )) ||
_jj__git__remote__help__add_commands() {
    local commands; commands=()
    _describe -t commands 'jj git remote help add commands' commands "$@"
}
(( $+functions[_jj__help__git__remote__add_commands] )) ||
_jj__help__git__remote__add_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git remote add commands' commands "$@"
}
(( $+functions[_jj__help__workspace__add_commands] )) ||
_jj__help__workspace__add_commands() {
    local commands; commands=()
    _describe -t commands 'jj help workspace add commands' commands "$@"
}
(( $+functions[_jj__workspace__add_commands] )) ||
_jj__workspace__add_commands() {
    local commands; commands=()
    _describe -t commands 'jj workspace add commands' commands "$@"
}
(( $+functions[_jj__workspace__help__add_commands] )) ||
_jj__workspace__help__add_commands() {
    local commands; commands=()
    _describe -t commands 'jj workspace help add commands' commands "$@"
}
(( $+functions[_jj__backout_commands] )) ||
_jj__backout_commands() {
    local commands; commands=()
    _describe -t commands 'jj backout commands' commands "$@"
}
(( $+functions[_jj__help__backout_commands] )) ||
_jj__help__backout_commands() {
    local commands; commands=()
    _describe -t commands 'jj help backout commands' commands "$@"
}
(( $+functions[_jj__branch_commands] )) ||
_jj__branch_commands() {
    local commands; commands=(
'create:Create a new branch' \
'c:Create a new branch' \
'delete:Delete an existing branch and propagate the deletion to remotes on the next push' \
'd:Delete an existing branch and propagate the deletion to remotes on the next push' \
'forget:Forget everything about a branch, including its local and remote targets' \
'f:Forget everything about a branch, including its local and remote targets' \
'list:List branches and their targets' \
'l:List branches and their targets' \
'set:Update a given branch to point to a certain commit' \
's:Update a given branch to point to a certain commit' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj branch commands' commands "$@"
}
(( $+functions[_jj__help__branch_commands] )) ||
_jj__help__branch_commands() {
    local commands; commands=(
'create:Create a new branch' \
'delete:Delete an existing branch and propagate the deletion to remotes on the next push' \
'forget:Forget everything about a branch, including its local and remote targets' \
'list:List branches and their targets' \
'set:Update a given branch to point to a certain commit' \
    )
    _describe -t commands 'jj help branch commands' commands "$@"
}
(( $+functions[_jj__checkout_commands] )) ||
_jj__checkout_commands() {
    local commands; commands=()
    _describe -t commands 'jj checkout commands' commands "$@"
}
(( $+functions[_jj__help__checkout_commands] )) ||
_jj__help__checkout_commands() {
    local commands; commands=()
    _describe -t commands 'jj help checkout commands' commands "$@"
}
(( $+functions[_jj__git__clone_commands] )) ||
_jj__git__clone_commands() {
    local commands; commands=()
    _describe -t commands 'jj git clone commands' commands "$@"
}
(( $+functions[_jj__git__help__clone_commands] )) ||
_jj__git__help__clone_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help clone commands' commands "$@"
}
(( $+functions[_jj__help__git__clone_commands] )) ||
_jj__help__git__clone_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git clone commands' commands "$@"
}
(( $+functions[_jj__close_commands] )) ||
_jj__close_commands() {
    local commands; commands=()
    _describe -t commands 'jj close commands' commands "$@"
}
(( $+functions[_jj__help__close_commands] )) ||
_jj__help__close_commands() {
    local commands; commands=()
    _describe -t commands 'jj help close commands' commands "$@"
}
(( $+functions[_jj__debug__completion_commands] )) ||
_jj__debug__completion_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug completion commands' commands "$@"
}
(( $+functions[_jj__debug__help__completion_commands] )) ||
_jj__debug__help__completion_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help completion commands' commands "$@"
}
(( $+functions[_jj__help__debug__completion_commands] )) ||
_jj__help__debug__completion_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug completion commands' commands "$@"
}
(( $+functions[_jj__branch__create_commands] )) ||
_jj__branch__create_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch create commands' commands "$@"
}
(( $+functions[_jj__branch__help__create_commands] )) ||
_jj__branch__help__create_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch help create commands' commands "$@"
}
(( $+functions[_jj__help__branch__create_commands] )) ||
_jj__help__branch__create_commands() {
    local commands; commands=()
    _describe -t commands 'jj help branch create commands' commands "$@"
}
(( $+functions[_jj__debug_commands] )) ||
_jj__debug_commands() {
    local commands; commands=(
'completion:Print a command-line-completion script' \
'mangen:Print a ROFF (manpage)' \
'resolverev:Resolve a revision identifier to its full ID' \
'workingcopy:Show information about the working copy state' \
'template:Parse a template' \
'index:Show commit index stats' \
'reindex:Rebuild commit index' \
'operation:Show information about an operation and its view' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj debug commands' commands "$@"
}
(( $+functions[_jj__help__debug_commands] )) ||
_jj__help__debug_commands() {
    local commands; commands=(
'completion:Print a command-line-completion script' \
'mangen:Print a ROFF (manpage)' \
'resolverev:Resolve a revision identifier to its full ID' \
'workingcopy:Show information about the working copy state' \
'template:Parse a template' \
'index:Show commit index stats' \
'reindex:Rebuild commit index' \
'operation:Show information about an operation and its view' \
    )
    _describe -t commands 'jj help debug commands' commands "$@"
}
(( $+functions[_jj__branch__delete_commands] )) ||
_jj__branch__delete_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch delete commands' commands "$@"
}
(( $+functions[_jj__branch__help__delete_commands] )) ||
_jj__branch__help__delete_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch help delete commands' commands "$@"
}
(( $+functions[_jj__help__branch__delete_commands] )) ||
_jj__help__branch__delete_commands() {
    local commands; commands=()
    _describe -t commands 'jj help branch delete commands' commands "$@"
}
(( $+functions[_jj__describe_commands] )) ||
_jj__describe_commands() {
    local commands; commands=()
    _describe -t commands 'jj describe commands' commands "$@"
}
(( $+functions[_jj__help__describe_commands] )) ||
_jj__help__describe_commands() {
    local commands; commands=()
    _describe -t commands 'jj help describe commands' commands "$@"
}
(( $+functions[_jj__diff_commands] )) ||
_jj__diff_commands() {
    local commands; commands=()
    _describe -t commands 'jj diff commands' commands "$@"
}
(( $+functions[_jj__help__diff_commands] )) ||
_jj__help__diff_commands() {
    local commands; commands=()
    _describe -t commands 'jj help diff commands' commands "$@"
}
(( $+functions[_jj__duplicate_commands] )) ||
_jj__duplicate_commands() {
    local commands; commands=()
    _describe -t commands 'jj duplicate commands' commands "$@"
}
(( $+functions[_jj__help__duplicate_commands] )) ||
_jj__help__duplicate_commands() {
    local commands; commands=()
    _describe -t commands 'jj help duplicate commands' commands "$@"
}
(( $+functions[_jj__edit_commands] )) ||
_jj__edit_commands() {
    local commands; commands=()
    _describe -t commands 'jj edit commands' commands "$@"
}
(( $+functions[_jj__help__edit_commands] )) ||
_jj__help__edit_commands() {
    local commands; commands=()
    _describe -t commands 'jj help edit commands' commands "$@"
}
(( $+functions[_jj__git__export_commands] )) ||
_jj__git__export_commands() {
    local commands; commands=()
    _describe -t commands 'jj git export commands' commands "$@"
}
(( $+functions[_jj__git__help__export_commands] )) ||
_jj__git__help__export_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help export commands' commands "$@"
}
(( $+functions[_jj__help__git__export_commands] )) ||
_jj__help__git__export_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git export commands' commands "$@"
}
(( $+functions[_jj__git__fetch_commands] )) ||
_jj__git__fetch_commands() {
    local commands; commands=()
    _describe -t commands 'jj git fetch commands' commands "$@"
}
(( $+functions[_jj__git__help__fetch_commands] )) ||
_jj__git__help__fetch_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help fetch commands' commands "$@"
}
(( $+functions[_jj__help__git__fetch_commands] )) ||
_jj__help__git__fetch_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git fetch commands' commands "$@"
}
(( $+functions[_jj__files_commands] )) ||
_jj__files_commands() {
    local commands; commands=()
    _describe -t commands 'jj files commands' commands "$@"
}
(( $+functions[_jj__help__files_commands] )) ||
_jj__help__files_commands() {
    local commands; commands=()
    _describe -t commands 'jj help files commands' commands "$@"
}
(( $+functions[_jj__branch__forget_commands] )) ||
_jj__branch__forget_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch forget commands' commands "$@"
}
(( $+functions[_jj__branch__help__forget_commands] )) ||
_jj__branch__help__forget_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch help forget commands' commands "$@"
}
(( $+functions[_jj__help__branch__forget_commands] )) ||
_jj__help__branch__forget_commands() {
    local commands; commands=()
    _describe -t commands 'jj help branch forget commands' commands "$@"
}
(( $+functions[_jj__help__workspace__forget_commands] )) ||
_jj__help__workspace__forget_commands() {
    local commands; commands=()
    _describe -t commands 'jj help workspace forget commands' commands "$@"
}
(( $+functions[_jj__workspace__forget_commands] )) ||
_jj__workspace__forget_commands() {
    local commands; commands=()
    _describe -t commands 'jj workspace forget commands' commands "$@"
}
(( $+functions[_jj__workspace__help__forget_commands] )) ||
_jj__workspace__help__forget_commands() {
    local commands; commands=()
    _describe -t commands 'jj workspace help forget commands' commands "$@"
}
(( $+functions[_jj__git_commands] )) ||
_jj__git_commands() {
    local commands; commands=(
'remote:Manage Git remotes' \
'fetch:Fetch from a Git remote' \
'clone:Create a new repo backed by a clone of a Git repo' \
'push:Push to a Git remote' \
'import:Update repo with changes made in the underlying Git repo' \
'export:Update the underlying Git repo with changes made in the repo' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj git commands' commands "$@"
}
(( $+functions[_jj__help__git_commands] )) ||
_jj__help__git_commands() {
    local commands; commands=(
'remote:Manage Git remotes' \
'fetch:Fetch from a Git remote' \
'clone:Create a new repo backed by a clone of a Git repo' \
'push:Push to a Git remote' \
'import:Update repo with changes made in the underlying Git repo' \
'export:Update the underlying Git repo with changes made in the repo' \
    )
    _describe -t commands 'jj help git commands' commands "$@"
}
(( $+functions[_jj__branch__help_commands] )) ||
_jj__branch__help_commands() {
    local commands; commands=(
'create:Create a new branch' \
'delete:Delete an existing branch and propagate the deletion to remotes on the next push' \
'forget:Forget everything about a branch, including its local and remote targets' \
'list:List branches and their targets' \
'set:Update a given branch to point to a certain commit' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj branch help commands' commands "$@"
}
(( $+functions[_jj__branch__help__help_commands] )) ||
_jj__branch__help__help_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch help help commands' commands "$@"
}
(( $+functions[_jj__debug__help_commands] )) ||
_jj__debug__help_commands() {
    local commands; commands=(
'completion:Print a command-line-completion script' \
'mangen:Print a ROFF (manpage)' \
'resolverev:Resolve a revision identifier to its full ID' \
'workingcopy:Show information about the working copy state' \
'template:Parse a template' \
'index:Show commit index stats' \
'reindex:Rebuild commit index' \
'operation:Show information about an operation and its view' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj debug help commands' commands "$@"
}
(( $+functions[_jj__debug__help__help_commands] )) ||
_jj__debug__help__help_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help help commands' commands "$@"
}
(( $+functions[_jj__git__help_commands] )) ||
_jj__git__help_commands() {
    local commands; commands=(
'remote:Manage Git remotes' \
'fetch:Fetch from a Git remote' \
'clone:Create a new repo backed by a clone of a Git repo' \
'push:Push to a Git remote' \
'import:Update repo with changes made in the underlying Git repo' \
'export:Update the underlying Git repo with changes made in the repo' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj git help commands' commands "$@"
}
(( $+functions[_jj__git__help__help_commands] )) ||
_jj__git__help__help_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help help commands' commands "$@"
}
(( $+functions[_jj__git__remote__help_commands] )) ||
_jj__git__remote__help_commands() {
    local commands; commands=(
'add:Add a Git remote' \
'remove:Remove a Git remote and forget its branches' \
'list:List Git remotes' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj git remote help commands' commands "$@"
}
(( $+functions[_jj__git__remote__help__help_commands] )) ||
_jj__git__remote__help__help_commands() {
    local commands; commands=()
    _describe -t commands 'jj git remote help help commands' commands "$@"
}
(( $+functions[_jj__help_commands] )) ||
_jj__help_commands() {
    local commands; commands=(
'version:Display version information' \
'init:Create a new repo in the given directory' \
'checkout:Create a new, empty change and edit it in the working copy' \
'untrack:Stop tracking specified paths in the working copy' \
'files:List files in a revision' \
'print:Print contents of a file in a revision' \
'diff:Show changes in a revision' \
'show:Show commit description and changes in a revision' \
'status:Show high-level repo status' \
'log:Show commit history' \
'obslog:Show how a change has evolved' \
'interdiff:Compare the changes of two commits' \
'describe:Edit the change description' \
'close:Mark a revision closed' \
'open:Mark a revision open' \
'duplicate:Create a new change with the same content as an existing one' \
'abandon:Abandon a revision' \
'edit:Edit a commit in the working copy' \
'new:Create a new, empty change and edit it in the working copy' \
'move:Move changes from one revision into another' \
'squash:Move changes from a revision into its parent' \
'unsquash:Move changes from a revision'\''s parent into the revision' \
'restore:Restore paths from another revision' \
'touchup:Touch up the content changes in a revision' \
'split:Split a revision in two' \
'merge:Merge work from multiple branches' \
'rebase:Move revisions to different parent(s)' \
'backout:Apply the reverse of a revision on top of another revision' \
'branch:Manage branches' \
'undo:Undo an operation (shortcut for `jj op undo`)' \
'operation:Commands for working with the operation log' \
'workspace:Commands for working with workspaces' \
'sparse:Manage which paths from the current checkout are present in the working copy' \
'git:Commands for working with the underlying Git repo' \
'debug:Low-level commands not intended for users' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj help commands' commands "$@"
}
(( $+functions[_jj__help__help_commands] )) ||
_jj__help__help_commands() {
    local commands; commands=()
    _describe -t commands 'jj help help commands' commands "$@"
}
(( $+functions[_jj__operation__help_commands] )) ||
_jj__operation__help_commands() {
    local commands; commands=(
'log:Show the operation log' \
'undo:Undo an operation' \
'restore:Restore to the state at an operation' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj operation help commands' commands "$@"
}
(( $+functions[_jj__operation__help__help_commands] )) ||
_jj__operation__help__help_commands() {
    local commands; commands=()
    _describe -t commands 'jj operation help help commands' commands "$@"
}
(( $+functions[_jj__workspace__help_commands] )) ||
_jj__workspace__help_commands() {
    local commands; commands=(
'add:Add a workspace' \
'forget:Stop tracking a workspace'\''s checkout in the repo' \
'list:List workspaces' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj workspace help commands' commands "$@"
}
(( $+functions[_jj__workspace__help__help_commands] )) ||
_jj__workspace__help__help_commands() {
    local commands; commands=()
    _describe -t commands 'jj workspace help help commands' commands "$@"
}
(( $+functions[_jj__git__help__import_commands] )) ||
_jj__git__help__import_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help import commands' commands "$@"
}
(( $+functions[_jj__git__import_commands] )) ||
_jj__git__import_commands() {
    local commands; commands=()
    _describe -t commands 'jj git import commands' commands "$@"
}
(( $+functions[_jj__help__git__import_commands] )) ||
_jj__help__git__import_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git import commands' commands "$@"
}
(( $+functions[_jj__debug__help__index_commands] )) ||
_jj__debug__help__index_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help index commands' commands "$@"
}
(( $+functions[_jj__debug__index_commands] )) ||
_jj__debug__index_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug index commands' commands "$@"
}
(( $+functions[_jj__help__debug__index_commands] )) ||
_jj__help__debug__index_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug index commands' commands "$@"
}
(( $+functions[_jj__help__init_commands] )) ||
_jj__help__init_commands() {
    local commands; commands=()
    _describe -t commands 'jj help init commands' commands "$@"
}
(( $+functions[_jj__init_commands] )) ||
_jj__init_commands() {
    local commands; commands=()
    _describe -t commands 'jj init commands' commands "$@"
}
(( $+functions[_jj__help__interdiff_commands] )) ||
_jj__help__interdiff_commands() {
    local commands; commands=()
    _describe -t commands 'jj help interdiff commands' commands "$@"
}
(( $+functions[_jj__interdiff_commands] )) ||
_jj__interdiff_commands() {
    local commands; commands=()
    _describe -t commands 'jj interdiff commands' commands "$@"
}
(( $+functions[_jj__branch__help__list_commands] )) ||
_jj__branch__help__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch help list commands' commands "$@"
}
(( $+functions[_jj__branch__list_commands] )) ||
_jj__branch__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch list commands' commands "$@"
}
(( $+functions[_jj__git__help__remote__list_commands] )) ||
_jj__git__help__remote__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help remote list commands' commands "$@"
}
(( $+functions[_jj__git__remote__help__list_commands] )) ||
_jj__git__remote__help__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj git remote help list commands' commands "$@"
}
(( $+functions[_jj__git__remote__list_commands] )) ||
_jj__git__remote__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj git remote list commands' commands "$@"
}
(( $+functions[_jj__help__branch__list_commands] )) ||
_jj__help__branch__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj help branch list commands' commands "$@"
}
(( $+functions[_jj__help__git__remote__list_commands] )) ||
_jj__help__git__remote__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git remote list commands' commands "$@"
}
(( $+functions[_jj__help__workspace__list_commands] )) ||
_jj__help__workspace__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj help workspace list commands' commands "$@"
}
(( $+functions[_jj__workspace__help__list_commands] )) ||
_jj__workspace__help__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj workspace help list commands' commands "$@"
}
(( $+functions[_jj__workspace__list_commands] )) ||
_jj__workspace__list_commands() {
    local commands; commands=()
    _describe -t commands 'jj workspace list commands' commands "$@"
}
(( $+functions[_jj__help__log_commands] )) ||
_jj__help__log_commands() {
    local commands; commands=()
    _describe -t commands 'jj help log commands' commands "$@"
}
(( $+functions[_jj__help__operation__log_commands] )) ||
_jj__help__operation__log_commands() {
    local commands; commands=()
    _describe -t commands 'jj help operation log commands' commands "$@"
}
(( $+functions[_jj__log_commands] )) ||
_jj__log_commands() {
    local commands; commands=()
    _describe -t commands 'jj log commands' commands "$@"
}
(( $+functions[_jj__operation__help__log_commands] )) ||
_jj__operation__help__log_commands() {
    local commands; commands=()
    _describe -t commands 'jj operation help log commands' commands "$@"
}
(( $+functions[_jj__operation__log_commands] )) ||
_jj__operation__log_commands() {
    local commands; commands=()
    _describe -t commands 'jj operation log commands' commands "$@"
}
(( $+functions[_jj__debug__help__mangen_commands] )) ||
_jj__debug__help__mangen_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help mangen commands' commands "$@"
}
(( $+functions[_jj__debug__mangen_commands] )) ||
_jj__debug__mangen_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug mangen commands' commands "$@"
}
(( $+functions[_jj__help__debug__mangen_commands] )) ||
_jj__help__debug__mangen_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug mangen commands' commands "$@"
}
(( $+functions[_jj__help__merge_commands] )) ||
_jj__help__merge_commands() {
    local commands; commands=()
    _describe -t commands 'jj help merge commands' commands "$@"
}
(( $+functions[_jj__merge_commands] )) ||
_jj__merge_commands() {
    local commands; commands=()
    _describe -t commands 'jj merge commands' commands "$@"
}
(( $+functions[_jj__help__move_commands] )) ||
_jj__help__move_commands() {
    local commands; commands=()
    _describe -t commands 'jj help move commands' commands "$@"
}
(( $+functions[_jj__move_commands] )) ||
_jj__move_commands() {
    local commands; commands=()
    _describe -t commands 'jj move commands' commands "$@"
}
(( $+functions[_jj__help__new_commands] )) ||
_jj__help__new_commands() {
    local commands; commands=()
    _describe -t commands 'jj help new commands' commands "$@"
}
(( $+functions[_jj__new_commands] )) ||
_jj__new_commands() {
    local commands; commands=()
    _describe -t commands 'jj new commands' commands "$@"
}
(( $+functions[_jj__help__obslog_commands] )) ||
_jj__help__obslog_commands() {
    local commands; commands=()
    _describe -t commands 'jj help obslog commands' commands "$@"
}
(( $+functions[_jj__obslog_commands] )) ||
_jj__obslog_commands() {
    local commands; commands=()
    _describe -t commands 'jj obslog commands' commands "$@"
}
(( $+functions[_jj__help__open_commands] )) ||
_jj__help__open_commands() {
    local commands; commands=()
    _describe -t commands 'jj help open commands' commands "$@"
}
(( $+functions[_jj__open_commands] )) ||
_jj__open_commands() {
    local commands; commands=()
    _describe -t commands 'jj open commands' commands "$@"
}
(( $+functions[_jj__debug__help__operation_commands] )) ||
_jj__debug__help__operation_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help operation commands' commands "$@"
}
(( $+functions[_jj__debug__operation_commands] )) ||
_jj__debug__operation_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug operation commands' commands "$@"
}
(( $+functions[_jj__help__debug__operation_commands] )) ||
_jj__help__debug__operation_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug operation commands' commands "$@"
}
(( $+functions[_jj__help__operation_commands] )) ||
_jj__help__operation_commands() {
    local commands; commands=(
'log:Show the operation log' \
'undo:Undo an operation' \
'restore:Restore to the state at an operation' \
    )
    _describe -t commands 'jj help operation commands' commands "$@"
}
(( $+functions[_jj__operation_commands] )) ||
_jj__operation_commands() {
    local commands; commands=(
'log:Show the operation log' \
'undo:Undo an operation' \
'restore:Restore to the state at an operation' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj operation commands' commands "$@"
}
(( $+functions[_jj__help__print_commands] )) ||
_jj__help__print_commands() {
    local commands; commands=()
    _describe -t commands 'jj help print commands' commands "$@"
}
(( $+functions[_jj__print_commands] )) ||
_jj__print_commands() {
    local commands; commands=()
    _describe -t commands 'jj print commands' commands "$@"
}
(( $+functions[_jj__git__help__push_commands] )) ||
_jj__git__help__push_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help push commands' commands "$@"
}
(( $+functions[_jj__git__push_commands] )) ||
_jj__git__push_commands() {
    local commands; commands=()
    _describe -t commands 'jj git push commands' commands "$@"
}
(( $+functions[_jj__help__git__push_commands] )) ||
_jj__help__git__push_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git push commands' commands "$@"
}
(( $+functions[_jj__help__rebase_commands] )) ||
_jj__help__rebase_commands() {
    local commands; commands=()
    _describe -t commands 'jj help rebase commands' commands "$@"
}
(( $+functions[_jj__rebase_commands] )) ||
_jj__rebase_commands() {
    local commands; commands=()
    _describe -t commands 'jj rebase commands' commands "$@"
}
(( $+functions[_jj__debug__help__reindex_commands] )) ||
_jj__debug__help__reindex_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help reindex commands' commands "$@"
}
(( $+functions[_jj__debug__reindex_commands] )) ||
_jj__debug__reindex_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug reindex commands' commands "$@"
}
(( $+functions[_jj__help__debug__reindex_commands] )) ||
_jj__help__debug__reindex_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug reindex commands' commands "$@"
}
(( $+functions[_jj__git__help__remote_commands] )) ||
_jj__git__help__remote_commands() {
    local commands; commands=(
'add:Add a Git remote' \
'remove:Remove a Git remote and forget its branches' \
'list:List Git remotes' \
    )
    _describe -t commands 'jj git help remote commands' commands "$@"
}
(( $+functions[_jj__git__remote_commands] )) ||
_jj__git__remote_commands() {
    local commands; commands=(
'add:Add a Git remote' \
'remove:Remove a Git remote and forget its branches' \
'list:List Git remotes' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj git remote commands' commands "$@"
}
(( $+functions[_jj__help__git__remote_commands] )) ||
_jj__help__git__remote_commands() {
    local commands; commands=(
'add:Add a Git remote' \
'remove:Remove a Git remote and forget its branches' \
'list:List Git remotes' \
    )
    _describe -t commands 'jj help git remote commands' commands "$@"
}
(( $+functions[_jj__git__help__remote__remove_commands] )) ||
_jj__git__help__remote__remove_commands() {
    local commands; commands=()
    _describe -t commands 'jj git help remote remove commands' commands "$@"
}
(( $+functions[_jj__git__remote__help__remove_commands] )) ||
_jj__git__remote__help__remove_commands() {
    local commands; commands=()
    _describe -t commands 'jj git remote help remove commands' commands "$@"
}
(( $+functions[_jj__git__remote__remove_commands] )) ||
_jj__git__remote__remove_commands() {
    local commands; commands=()
    _describe -t commands 'jj git remote remove commands' commands "$@"
}
(( $+functions[_jj__help__git__remote__remove_commands] )) ||
_jj__help__git__remote__remove_commands() {
    local commands; commands=()
    _describe -t commands 'jj help git remote remove commands' commands "$@"
}
(( $+functions[_jj__debug__help__resolverev_commands] )) ||
_jj__debug__help__resolverev_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help resolverev commands' commands "$@"
}
(( $+functions[_jj__debug__resolverev_commands] )) ||
_jj__debug__resolverev_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug resolverev commands' commands "$@"
}
(( $+functions[_jj__help__debug__resolverev_commands] )) ||
_jj__help__debug__resolverev_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug resolverev commands' commands "$@"
}
(( $+functions[_jj__help__operation__restore_commands] )) ||
_jj__help__operation__restore_commands() {
    local commands; commands=()
    _describe -t commands 'jj help operation restore commands' commands "$@"
}
(( $+functions[_jj__help__restore_commands] )) ||
_jj__help__restore_commands() {
    local commands; commands=()
    _describe -t commands 'jj help restore commands' commands "$@"
}
(( $+functions[_jj__operation__help__restore_commands] )) ||
_jj__operation__help__restore_commands() {
    local commands; commands=()
    _describe -t commands 'jj operation help restore commands' commands "$@"
}
(( $+functions[_jj__operation__restore_commands] )) ||
_jj__operation__restore_commands() {
    local commands; commands=()
    _describe -t commands 'jj operation restore commands' commands "$@"
}
(( $+functions[_jj__restore_commands] )) ||
_jj__restore_commands() {
    local commands; commands=()
    _describe -t commands 'jj restore commands' commands "$@"
}
(( $+functions[_jj__branch__help__set_commands] )) ||
_jj__branch__help__set_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch help set commands' commands "$@"
}
(( $+functions[_jj__branch__set_commands] )) ||
_jj__branch__set_commands() {
    local commands; commands=()
    _describe -t commands 'jj branch set commands' commands "$@"
}
(( $+functions[_jj__help__branch__set_commands] )) ||
_jj__help__branch__set_commands() {
    local commands; commands=()
    _describe -t commands 'jj help branch set commands' commands "$@"
}
(( $+functions[_jj__help__show_commands] )) ||
_jj__help__show_commands() {
    local commands; commands=()
    _describe -t commands 'jj help show commands' commands "$@"
}
(( $+functions[_jj__show_commands] )) ||
_jj__show_commands() {
    local commands; commands=()
    _describe -t commands 'jj show commands' commands "$@"
}
(( $+functions[_jj__help__sparse_commands] )) ||
_jj__help__sparse_commands() {
    local commands; commands=()
    _describe -t commands 'jj help sparse commands' commands "$@"
}
(( $+functions[_jj__sparse_commands] )) ||
_jj__sparse_commands() {
    local commands; commands=()
    _describe -t commands 'jj sparse commands' commands "$@"
}
(( $+functions[_jj__help__split_commands] )) ||
_jj__help__split_commands() {
    local commands; commands=()
    _describe -t commands 'jj help split commands' commands "$@"
}
(( $+functions[_jj__split_commands] )) ||
_jj__split_commands() {
    local commands; commands=()
    _describe -t commands 'jj split commands' commands "$@"
}
(( $+functions[_jj__help__squash_commands] )) ||
_jj__help__squash_commands() {
    local commands; commands=()
    _describe -t commands 'jj help squash commands' commands "$@"
}
(( $+functions[_jj__squash_commands] )) ||
_jj__squash_commands() {
    local commands; commands=()
    _describe -t commands 'jj squash commands' commands "$@"
}
(( $+functions[_jj__help__status_commands] )) ||
_jj__help__status_commands() {
    local commands; commands=()
    _describe -t commands 'jj help status commands' commands "$@"
}
(( $+functions[_jj__status_commands] )) ||
_jj__status_commands() {
    local commands; commands=()
    _describe -t commands 'jj status commands' commands "$@"
}
(( $+functions[_jj__debug__help__template_commands] )) ||
_jj__debug__help__template_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help template commands' commands "$@"
}
(( $+functions[_jj__debug__template_commands] )) ||
_jj__debug__template_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug template commands' commands "$@"
}
(( $+functions[_jj__help__debug__template_commands] )) ||
_jj__help__debug__template_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug template commands' commands "$@"
}
(( $+functions[_jj__help__touchup_commands] )) ||
_jj__help__touchup_commands() {
    local commands; commands=()
    _describe -t commands 'jj help touchup commands' commands "$@"
}
(( $+functions[_jj__touchup_commands] )) ||
_jj__touchup_commands() {
    local commands; commands=()
    _describe -t commands 'jj touchup commands' commands "$@"
}
(( $+functions[_jj__help__operation__undo_commands] )) ||
_jj__help__operation__undo_commands() {
    local commands; commands=()
    _describe -t commands 'jj help operation undo commands' commands "$@"
}
(( $+functions[_jj__help__undo_commands] )) ||
_jj__help__undo_commands() {
    local commands; commands=()
    _describe -t commands 'jj help undo commands' commands "$@"
}
(( $+functions[_jj__operation__help__undo_commands] )) ||
_jj__operation__help__undo_commands() {
    local commands; commands=()
    _describe -t commands 'jj operation help undo commands' commands "$@"
}
(( $+functions[_jj__operation__undo_commands] )) ||
_jj__operation__undo_commands() {
    local commands; commands=()
    _describe -t commands 'jj operation undo commands' commands "$@"
}
(( $+functions[_jj__undo_commands] )) ||
_jj__undo_commands() {
    local commands; commands=()
    _describe -t commands 'jj undo commands' commands "$@"
}
(( $+functions[_jj__help__unsquash_commands] )) ||
_jj__help__unsquash_commands() {
    local commands; commands=()
    _describe -t commands 'jj help unsquash commands' commands "$@"
}
(( $+functions[_jj__unsquash_commands] )) ||
_jj__unsquash_commands() {
    local commands; commands=()
    _describe -t commands 'jj unsquash commands' commands "$@"
}
(( $+functions[_jj__help__untrack_commands] )) ||
_jj__help__untrack_commands() {
    local commands; commands=()
    _describe -t commands 'jj help untrack commands' commands "$@"
}
(( $+functions[_jj__untrack_commands] )) ||
_jj__untrack_commands() {
    local commands; commands=()
    _describe -t commands 'jj untrack commands' commands "$@"
}
(( $+functions[_jj__help__version_commands] )) ||
_jj__help__version_commands() {
    local commands; commands=()
    _describe -t commands 'jj help version commands' commands "$@"
}
(( $+functions[_jj__version_commands] )) ||
_jj__version_commands() {
    local commands; commands=()
    _describe -t commands 'jj version commands' commands "$@"
}
(( $+functions[_jj__debug__help__workingcopy_commands] )) ||
_jj__debug__help__workingcopy_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug help workingcopy commands' commands "$@"
}
(( $+functions[_jj__debug__workingcopy_commands] )) ||
_jj__debug__workingcopy_commands() {
    local commands; commands=()
    _describe -t commands 'jj debug workingcopy commands' commands "$@"
}
(( $+functions[_jj__help__debug__workingcopy_commands] )) ||
_jj__help__debug__workingcopy_commands() {
    local commands; commands=()
    _describe -t commands 'jj help debug workingcopy commands' commands "$@"
}
(( $+functions[_jj__help__workspace_commands] )) ||
_jj__help__workspace_commands() {
    local commands; commands=(
'add:Add a workspace' \
'forget:Stop tracking a workspace'\''s checkout in the repo' \
'list:List workspaces' \
    )
    _describe -t commands 'jj help workspace commands' commands "$@"
}
(( $+functions[_jj__workspace_commands] )) ||
_jj__workspace_commands() {
    local commands; commands=(
'add:Add a workspace' \
'forget:Stop tracking a workspace'\''s checkout in the repo' \
'list:List workspaces' \
'help:Print this message or the help of the given subcommand(s)' \
    )
    _describe -t commands 'jj workspace commands' commands "$@"
}

_jj "$@"
