_rustic() {
    local i cur prev opts cmd
    COMPREPLY=()
    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
        cur="$2"
    else
        cur="${COMP_WORDS[COMP_CWORD]}"
    fi
    prev="$3"
    cmd=""
    opts=""

    for i in "${COMP_WORDS[@]:0:COMP_CWORD}"
    do
        case "${cmd},${i}" in
            ",$1")
                cmd="rustic"
                ;;
            rustic,backup)
                cmd="rustic__subcmd__backup"
                ;;
            rustic,cat)
                cmd="rustic__subcmd__cat"
                ;;
            rustic,check)
                cmd="rustic__subcmd__check"
                ;;
            rustic,completions)
                cmd="rustic__subcmd__completions"
                ;;
            rustic,config)
                cmd="rustic__subcmd__config"
                ;;
            rustic,copy)
                cmd="rustic__subcmd__copy"
                ;;
            rustic,diff)
                cmd="rustic__subcmd__diff"
                ;;
            rustic,docs)
                cmd="rustic__subcmd__docs"
                ;;
            rustic,dump)
                cmd="rustic__subcmd__dump"
                ;;
            rustic,find)
                cmd="rustic__subcmd__find"
                ;;
            rustic,forget)
                cmd="rustic__subcmd__forget"
                ;;
            rustic,help)
                cmd="rustic__subcmd__help"
                ;;
            rustic,init)
                cmd="rustic__subcmd__init"
                ;;
            rustic,key)
                cmd="rustic__subcmd__key"
                ;;
            rustic,list)
                cmd="rustic__subcmd__list"
                ;;
            rustic,ls)
                cmd="rustic__subcmd__ls"
                ;;
            rustic,merge)
                cmd="rustic__subcmd__merge"
                ;;
            rustic,prune)
                cmd="rustic__subcmd__prune"
                ;;
            rustic,repair)
                cmd="rustic__subcmd__repair"
                ;;
            rustic,repoinfo)
                cmd="rustic__subcmd__repoinfo"
                ;;
            rustic,restore)
                cmd="rustic__subcmd__restore"
                ;;
            rustic,rewrite)
                cmd="rustic__subcmd__rewrite"
                ;;
            rustic,self-update)
                cmd="rustic__subcmd__self__subcmd__update"
                ;;
            rustic,show-config)
                cmd="rustic__subcmd__show__subcmd__config"
                ;;
            rustic,snapshots)
                cmd="rustic__subcmd__snapshots"
                ;;
            rustic,tag)
                cmd="rustic__subcmd__tag"
                ;;
            rustic,version)
                cmd="rustic__subcmd__version"
                ;;
            rustic,webdav)
                cmd="rustic__subcmd__webdav"
                ;;
            rustic__subcmd__cat,config)
                cmd="rustic__subcmd__cat__subcmd__config"
                ;;
            rustic__subcmd__cat,data-blob)
                cmd="rustic__subcmd__cat__subcmd__data__subcmd__blob"
                ;;
            rustic__subcmd__cat,help)
                cmd="rustic__subcmd__cat__subcmd__help"
                ;;
            rustic__subcmd__cat,index)
                cmd="rustic__subcmd__cat__subcmd__index"
                ;;
            rustic__subcmd__cat,masterkey)
                cmd="rustic__subcmd__cat__subcmd__masterkey"
                ;;
            rustic__subcmd__cat,snapshot)
                cmd="rustic__subcmd__cat__subcmd__snapshot"
                ;;
            rustic__subcmd__cat,tree)
                cmd="rustic__subcmd__cat__subcmd__tree"
                ;;
            rustic__subcmd__cat,tree-blob)
                cmd="rustic__subcmd__cat__subcmd__tree__subcmd__blob"
                ;;
            rustic__subcmd__cat__subcmd__help,config)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__config"
                ;;
            rustic__subcmd__cat__subcmd__help,data-blob)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__data__subcmd__blob"
                ;;
            rustic__subcmd__cat__subcmd__help,help)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__help"
                ;;
            rustic__subcmd__cat__subcmd__help,index)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__index"
                ;;
            rustic__subcmd__cat__subcmd__help,masterkey)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__masterkey"
                ;;
            rustic__subcmd__cat__subcmd__help,snapshot)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__snapshot"
                ;;
            rustic__subcmd__cat__subcmd__help,tree)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__tree"
                ;;
            rustic__subcmd__cat__subcmd__help,tree-blob)
                cmd="rustic__subcmd__cat__subcmd__help__subcmd__tree__subcmd__blob"
                ;;
            rustic__subcmd__docs,config)
                cmd="rustic__subcmd__docs__subcmd__config"
                ;;
            rustic__subcmd__docs,dev)
                cmd="rustic__subcmd__docs__subcmd__dev"
                ;;
            rustic__subcmd__docs,help)
                cmd="rustic__subcmd__docs__subcmd__help"
                ;;
            rustic__subcmd__docs,user)
                cmd="rustic__subcmd__docs__subcmd__user"
                ;;
            rustic__subcmd__docs__subcmd__help,config)
                cmd="rustic__subcmd__docs__subcmd__help__subcmd__config"
                ;;
            rustic__subcmd__docs__subcmd__help,dev)
                cmd="rustic__subcmd__docs__subcmd__help__subcmd__dev"
                ;;
            rustic__subcmd__docs__subcmd__help,help)
                cmd="rustic__subcmd__docs__subcmd__help__subcmd__help"
                ;;
            rustic__subcmd__docs__subcmd__help,user)
                cmd="rustic__subcmd__docs__subcmd__help__subcmd__user"
                ;;
            rustic__subcmd__help,backup)
                cmd="rustic__subcmd__help__subcmd__backup"
                ;;
            rustic__subcmd__help,cat)
                cmd="rustic__subcmd__help__subcmd__cat"
                ;;
            rustic__subcmd__help,check)
                cmd="rustic__subcmd__help__subcmd__check"
                ;;
            rustic__subcmd__help,completions)
                cmd="rustic__subcmd__help__subcmd__completions"
                ;;
            rustic__subcmd__help,config)
                cmd="rustic__subcmd__help__subcmd__config"
                ;;
            rustic__subcmd__help,copy)
                cmd="rustic__subcmd__help__subcmd__copy"
                ;;
            rustic__subcmd__help,diff)
                cmd="rustic__subcmd__help__subcmd__diff"
                ;;
            rustic__subcmd__help,docs)
                cmd="rustic__subcmd__help__subcmd__docs"
                ;;
            rustic__subcmd__help,dump)
                cmd="rustic__subcmd__help__subcmd__dump"
                ;;
            rustic__subcmd__help,find)
                cmd="rustic__subcmd__help__subcmd__find"
                ;;
            rustic__subcmd__help,forget)
                cmd="rustic__subcmd__help__subcmd__forget"
                ;;
            rustic__subcmd__help,help)
                cmd="rustic__subcmd__help__subcmd__help"
                ;;
            rustic__subcmd__help,init)
                cmd="rustic__subcmd__help__subcmd__init"
                ;;
            rustic__subcmd__help,key)
                cmd="rustic__subcmd__help__subcmd__key"
                ;;
            rustic__subcmd__help,list)
                cmd="rustic__subcmd__help__subcmd__list"
                ;;
            rustic__subcmd__help,ls)
                cmd="rustic__subcmd__help__subcmd__ls"
                ;;
            rustic__subcmd__help,merge)
                cmd="rustic__subcmd__help__subcmd__merge"
                ;;
            rustic__subcmd__help,prune)
                cmd="rustic__subcmd__help__subcmd__prune"
                ;;
            rustic__subcmd__help,repair)
                cmd="rustic__subcmd__help__subcmd__repair"
                ;;
            rustic__subcmd__help,repoinfo)
                cmd="rustic__subcmd__help__subcmd__repoinfo"
                ;;
            rustic__subcmd__help,restore)
                cmd="rustic__subcmd__help__subcmd__restore"
                ;;
            rustic__subcmd__help,rewrite)
                cmd="rustic__subcmd__help__subcmd__rewrite"
                ;;
            rustic__subcmd__help,self-update)
                cmd="rustic__subcmd__help__subcmd__self__subcmd__update"
                ;;
            rustic__subcmd__help,show-config)
                cmd="rustic__subcmd__help__subcmd__show__subcmd__config"
                ;;
            rustic__subcmd__help,snapshots)
                cmd="rustic__subcmd__help__subcmd__snapshots"
                ;;
            rustic__subcmd__help,tag)
                cmd="rustic__subcmd__help__subcmd__tag"
                ;;
            rustic__subcmd__help,version)
                cmd="rustic__subcmd__help__subcmd__version"
                ;;
            rustic__subcmd__help,webdav)
                cmd="rustic__subcmd__help__subcmd__webdav"
                ;;
            rustic__subcmd__help__subcmd__cat,config)
                cmd="rustic__subcmd__help__subcmd__cat__subcmd__config"
                ;;
            rustic__subcmd__help__subcmd__cat,data-blob)
                cmd="rustic__subcmd__help__subcmd__cat__subcmd__data__subcmd__blob"
                ;;
            rustic__subcmd__help__subcmd__cat,index)
                cmd="rustic__subcmd__help__subcmd__cat__subcmd__index"
                ;;
            rustic__subcmd__help__subcmd__cat,masterkey)
                cmd="rustic__subcmd__help__subcmd__cat__subcmd__masterkey"
                ;;
            rustic__subcmd__help__subcmd__cat,snapshot)
                cmd="rustic__subcmd__help__subcmd__cat__subcmd__snapshot"
                ;;
            rustic__subcmd__help__subcmd__cat,tree)
                cmd="rustic__subcmd__help__subcmd__cat__subcmd__tree"
                ;;
            rustic__subcmd__help__subcmd__cat,tree-blob)
                cmd="rustic__subcmd__help__subcmd__cat__subcmd__tree__subcmd__blob"
                ;;
            rustic__subcmd__help__subcmd__docs,config)
                cmd="rustic__subcmd__help__subcmd__docs__subcmd__config"
                ;;
            rustic__subcmd__help__subcmd__docs,dev)
                cmd="rustic__subcmd__help__subcmd__docs__subcmd__dev"
                ;;
            rustic__subcmd__help__subcmd__docs,user)
                cmd="rustic__subcmd__help__subcmd__docs__subcmd__user"
                ;;
            rustic__subcmd__help__subcmd__key,add)
                cmd="rustic__subcmd__help__subcmd__key__subcmd__add"
                ;;
            rustic__subcmd__help__subcmd__key,create)
                cmd="rustic__subcmd__help__subcmd__key__subcmd__create"
                ;;
            rustic__subcmd__help__subcmd__key,export)
                cmd="rustic__subcmd__help__subcmd__key__subcmd__export"
                ;;
            rustic__subcmd__help__subcmd__key,list)
                cmd="rustic__subcmd__help__subcmd__key__subcmd__list"
                ;;
            rustic__subcmd__help__subcmd__key,password)
                cmd="rustic__subcmd__help__subcmd__key__subcmd__password"
                ;;
            rustic__subcmd__help__subcmd__key,remove)
                cmd="rustic__subcmd__help__subcmd__key__subcmd__remove"
                ;;
            rustic__subcmd__help__subcmd__repair,index)
                cmd="rustic__subcmd__help__subcmd__repair__subcmd__index"
                ;;
            rustic__subcmd__help__subcmd__repair,snapshots)
                cmd="rustic__subcmd__help__subcmd__repair__subcmd__snapshots"
                ;;
            rustic__subcmd__key,add)
                cmd="rustic__subcmd__key__subcmd__add"
                ;;
            rustic__subcmd__key,create)
                cmd="rustic__subcmd__key__subcmd__create"
                ;;
            rustic__subcmd__key,export)
                cmd="rustic__subcmd__key__subcmd__export"
                ;;
            rustic__subcmd__key,help)
                cmd="rustic__subcmd__key__subcmd__help"
                ;;
            rustic__subcmd__key,list)
                cmd="rustic__subcmd__key__subcmd__list"
                ;;
            rustic__subcmd__key,password)
                cmd="rustic__subcmd__key__subcmd__password"
                ;;
            rustic__subcmd__key,remove)
                cmd="rustic__subcmd__key__subcmd__remove"
                ;;
            rustic__subcmd__key__subcmd__help,add)
                cmd="rustic__subcmd__key__subcmd__help__subcmd__add"
                ;;
            rustic__subcmd__key__subcmd__help,create)
                cmd="rustic__subcmd__key__subcmd__help__subcmd__create"
                ;;
            rustic__subcmd__key__subcmd__help,export)
                cmd="rustic__subcmd__key__subcmd__help__subcmd__export"
                ;;
            rustic__subcmd__key__subcmd__help,help)
                cmd="rustic__subcmd__key__subcmd__help__subcmd__help"
                ;;
            rustic__subcmd__key__subcmd__help,list)
                cmd="rustic__subcmd__key__subcmd__help__subcmd__list"
                ;;
            rustic__subcmd__key__subcmd__help,password)
                cmd="rustic__subcmd__key__subcmd__help__subcmd__password"
                ;;
            rustic__subcmd__key__subcmd__help,remove)
                cmd="rustic__subcmd__key__subcmd__help__subcmd__remove"
                ;;
            rustic__subcmd__repair,help)
                cmd="rustic__subcmd__repair__subcmd__help"
                ;;
            rustic__subcmd__repair,index)
                cmd="rustic__subcmd__repair__subcmd__index"
                ;;
            rustic__subcmd__repair,snapshots)
                cmd="rustic__subcmd__repair__subcmd__snapshots"
                ;;
            rustic__subcmd__repair__subcmd__help,help)
                cmd="rustic__subcmd__repair__subcmd__help__subcmd__help"
                ;;
            rustic__subcmd__repair__subcmd__help,index)
                cmd="rustic__subcmd__repair__subcmd__help__subcmd__index"
                ;;
            rustic__subcmd__repair__subcmd__help,snapshots)
                cmd="rustic__subcmd__repair__subcmd__help__subcmd__snapshots"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        rustic)
            opts="-P -g -n -r -p -h -V --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --prometheus-user --prometheus-pass --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help --version backup cat config completions check copy diff docs dump find forget init key list ls merge snapshots show-config self-update prune restore rewrite repair repoinfo tag webdav version help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus-user)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus-pass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__backup)
            opts="-g -f -x -P -n -r -p -h --name --ls --stdin-filename --stdin-command --as-path --no-scan --json --long --init --set-atime --set-ctime --set-devid --set-blockdev --set-xattrs --group-by --parent --skip-if-unchanged --force --ignore-ctime --ignore-inode --glob --iglob --glob-file --iglob-file --git-ignore --no-require-git --custom-ignorefile --exclude-if-present --exclude-if-xattr --one-file-system --exclude-larger-than --label --tag --description --description-from --time --delete-never --delete-after --host --command --hostname --username --with-created --set-version --set-chunker --set-chunk-size --set-chunk-min-size --set-chunk-max-size --set-compression --set-append-only --set-treepack-size --set-treepack-size-limit --set-treepack-growfactor --set-datapack-size --set-datapack-growfactor --set-datapack-size-limit --set-min-packsize-tolerate-percent --set-max-packsize-tolerate-percent --set-extra-verify --metrics-job --metrics-labels --profile-substitute-env --use-profile --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [SOURCE]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --stdin-filename)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --stdin-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --as-path)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --set-atime)
                    COMPREPLY=($(compgen -W "yes mtime no" -- "${cur}"))
                    return 0
                    ;;
                --set-ctime)
                    COMPREPLY=($(compgen -W "yes mtime no" -- "${cur}"))
                    return 0
                    ;;
                --set-devid)
                    COMPREPLY=($(compgen -W "yes hardlink no" -- "${cur}"))
                    return 0
                    ;;
                --set-blockdev)
                    COMPREPLY=($(compgen -W "special file" -- "${cur}"))
                    return 0
                    ;;
                --set-xattrs)
                    COMPREPLY=($(compgen -W "yes no" -- "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --parent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --custom-ignorefile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-if-present)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-if-xattr)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-larger-than)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --tag)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --description)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --description-from)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --delete-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --hostname)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --username)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunker)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-min-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-max-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-compression)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-append-only)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --set-treepack-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-treepack-size-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-treepack-growfactor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-growfactor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-size-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-min-packsize-tolerate-percent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-max-packsize-tolerate-percent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-extra-verify)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --metrics-job)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --metrics-labels)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help tree-blob data-blob config index snapshot tree masterkey help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__config)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__data__subcmd__blob)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help <ID>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help)
            opts="tree-blob data-blob config index snapshot tree masterkey help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__config)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__data__subcmd__blob)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__help)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__index)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__masterkey)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__snapshot)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__tree)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__help__subcmd__tree__subcmd__blob)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__index)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help <ID>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__masterkey)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__snapshot)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help <ID>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__tree)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help <SNAPSHOT[:PATH]>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__cat__subcmd__tree__subcmd__blob)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help <ID>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__check)
            opts="-P -g -n -r -p -h --trust-cache --read-data --read-data-subset --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --read-data-subset)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__completions)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help bash fish zsh powershell"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__config)
            opts="-P -g -n -r -p -h --set-version --set-chunker --set-chunk-size --set-chunk-min-size --set-chunk-max-size --set-compression --set-append-only --set-treepack-size --set-treepack-size-limit --set-treepack-growfactor --set-datapack-size --set-datapack-growfactor --set-datapack-size-limit --set-min-packsize-tolerate-percent --set-max-packsize-tolerate-percent --set-extra-verify --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --set-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunker)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-min-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-max-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-compression)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-append-only)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --set-treepack-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-treepack-size-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-treepack-growfactor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-growfactor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-size-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-min-packsize-tolerate-percent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-max-packsize-tolerate-percent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-extra-verify)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__copy)
            opts="-P -g -n -r -p -h --target --init --force --hostname --username --with-created --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --target)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --hostname)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --username)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__diff)
            opts="-i -x -P -g -n -r -p -h --metadata --no-content --only-identical --interactive --glob --iglob --glob-file --iglob-file --git-ignore --no-require-git --custom-ignorefile --exclude-if-present --exclude-if-xattr --one-file-system --exclude-larger-than --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [SNAPSHOT1[:PATH1]] [SNAPSHOT2[:PATH2]|PATH2]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --glob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --custom-ignorefile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-if-present)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-if-xattr)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-larger-than)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help user dev config help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__config)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__dev)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__help)
            opts="user dev config help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__help__subcmd__config)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__help__subcmd__dev)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__help__subcmd__help)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__help__subcmd__user)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__docs__subcmd__user)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__dump)
            opts="-P -g -n -r -p -h --archive --file --glob --iglob --glob-file --iglob-file --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help <SNAPSHOT[:PATH]>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --archive)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__find)
            opts="-P -g -n -r -p -h --glob --iglob --path --all --show-misses --numeric-uid-gid --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --glob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__forget)
            opts="-g -l -M -H -d -w -m -y -P -n -r -p -h --forget-time --json --group-by --prune --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --keep-tags --keep-id --keep-last --keep-minutely --keep-hourly --keep-daily --keep-weekly --keep-monthly --keep-quarter-yearly --keep-half-yearly --keep-yearly --keep-within --keep-within-minutely --keep-within-hourly --keep-within-daily --keep-within-weekly --keep-within-monthly --keep-within-quarter-yearly --keep-within-half-yearly --keep-within-yearly --keep-none --delete-unchanged --max-repack --max-unused --keep-pack --keep-delete --instant-delete --early-delete-index --fast-repack --repack-uncompressed --repack-all --repack-cacheable-only --no-resize --profile-substitute-env --use-profile --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --forget-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-id)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -l)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-minutely)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -M)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-hourly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -H)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-daily)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -d)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-weekly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-monthly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-quarter-yearly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-half-yearly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-yearly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -y)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-minutely)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-hourly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-daily)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-weekly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-monthly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-quarter-yearly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-half-yearly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-within-yearly)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-repack)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-unused)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-pack)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-delete)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repack-cacheable-only)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help)
            opts="backup cat config completions check copy diff docs dump find forget init key list ls merge snapshots show-config self-update prune restore rewrite repair repoinfo tag webdav version help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__backup)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat)
            opts="tree-blob data-blob config index snapshot tree masterkey"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat__subcmd__config)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat__subcmd__data__subcmd__blob)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat__subcmd__index)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat__subcmd__masterkey)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat__subcmd__snapshot)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat__subcmd__tree)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__cat__subcmd__tree__subcmd__blob)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__check)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__completions)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__config)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__copy)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__diff)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__docs)
            opts="user dev config"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__docs__subcmd__config)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__docs__subcmd__dev)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__docs__subcmd__user)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__dump)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__find)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__forget)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__help)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__init)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__key)
            opts="add list remove password export create"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__key__subcmd__add)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__key__subcmd__create)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__key__subcmd__export)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__key__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__key__subcmd__password)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__key__subcmd__remove)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__ls)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__merge)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__prune)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__repair)
            opts="index snapshots"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__repair__subcmd__index)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__repair__subcmd__snapshots)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__repoinfo)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__restore)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__rewrite)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__self__subcmd__update)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__show__subcmd__config)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__snapshots)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__tag)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__version)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__help__subcmd__webdav)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__init)
            opts="-P -g -n -r -p -h --hot-only --hostname --username --with-created --set-version --set-chunker --set-chunk-size --set-chunk-min-size --set-chunk-max-size --set-compression --set-append-only --set-treepack-size --set-treepack-size-limit --set-treepack-growfactor --set-datapack-size --set-datapack-growfactor --set-datapack-size-limit --set-min-packsize-tolerate-percent --set-max-packsize-tolerate-percent --set-extra-verify --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --hostname)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --username)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunker)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-min-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-chunk-max-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-compression)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-append-only)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --set-treepack-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-treepack-size-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-treepack-growfactor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-growfactor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-datapack-size-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-min-packsize-tolerate-percent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-max-packsize-tolerate-percent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-extra-verify)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help add list remove password export create help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__add)
            opts="-P -g -n -r -p -h --new-password --new-password-file --new-password-command --hostname --username --with-created --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --new-password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --new-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --new-password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --hostname)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --username)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__create)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [FILE]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__export)
            opts="-P -g -n -r -p -h --qr --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [FILE]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help)
            opts="add list remove password export create help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help__subcmd__add)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help__subcmd__create)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help__subcmd__export)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help__subcmd__help)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help__subcmd__password)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__help__subcmd__remove)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__list)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__password)
            opts="-P -g -n -r -p -h --new-password --new-password-file --new-password-command --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --new-password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --new-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --new-password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__key__subcmd__remove)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [IDS]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__list)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help blobs indexpacks indexcontent index packs snapshots keys"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__ls)
            opts="-s -l -i -x -P -g -n -r -p -h --summary --long --json --numeric-uid-gid --recursive --interactive --glob --iglob --glob-file --iglob-file --git-ignore --no-require-git --custom-ignorefile --exclude-if-present --exclude-if-xattr --one-file-system --exclude-larger-than --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help <SNAPSHOT[:PATH]|PATH>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --glob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --custom-ignorefile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-if-present)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-if-xattr)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exclude-larger-than)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__merge)
            opts="-P -g -n -r -p -h --json --delete --label --tag --description --description-from --time --delete-never --delete-after --host --command --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --tag)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --description)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --description-from)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --delete-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__prune)
            opts="-P -g -n -r -p -h --max-repack --max-unused --keep-pack --keep-delete --instant-delete --early-delete-index --fast-repack --repack-uncompressed --repack-all --repack-cacheable-only --no-resize --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --max-repack)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-unused)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-pack)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keep-delete)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repack-cacheable-only)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repair)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help index snapshots help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repair__subcmd__help)
            opts="index snapshots help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repair__subcmd__help__subcmd__help)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repair__subcmd__help__subcmd__index)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repair__subcmd__help__subcmd__snapshots)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repair__subcmd__index)
            opts="-P -g -n -r -p -h --read-all --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repair__subcmd__snapshots)
            opts="-P -g -n -r -p -h --delete --suffix --tag --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --suffix)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --tag)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__repoinfo)
            opts="-P -g -n -r -p -h --only-files --only-index --json --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__restore)
            opts="-P -g -n -r -p -h --delete --numeric-id --no-ownership --verify-existing --glob --iglob --glob-file --iglob-file --recursive --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --help <SNAPSHOT[:PATH]> <DESTINATION>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --glob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__rewrite)
            opts="-P -g -n -r -p -h --forget --tags-rewritten --set-label --set-time --set-hostname --add-tags --set-tags --remove-tags --set-description --set-description-from --remove-description --set-delete-after --set-delete-never --remove-delete --all-trees --glob --iglob --glob-file --iglob-file --set-atime --set-ctime --set-devid --set-xattrs --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --tags-rewritten)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-hostname)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remove-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-description)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-description-from)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --set-delete-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --glob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --iglob-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-atime)
                    COMPREPLY=($(compgen -W "yes mtime no" -- "${cur}"))
                    return 0
                    ;;
                --set-ctime)
                    COMPREPLY=($(compgen -W "yes mtime no" -- "${cur}"))
                    return 0
                    ;;
                --set-devid)
                    COMPREPLY=($(compgen -W "yes hardlink no" -- "${cur}"))
                    return 0
                    ;;
                --set-xattrs)
                    COMPREPLY=($(compgen -W "yes no" -- "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__self__subcmd__update)
            opts="-P -g -n -r -p -h --force --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__show__subcmd__config)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__snapshots)
            opts="-i -P -g -n -r -p -h --long --json --all --interactive --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__tag)
            opts="-P -g -n -r -p -h --add --remove --set --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [ID]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --add)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remove)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__version)
            opts="-P -g -n -r -p -h --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rustic__subcmd__webdav)
            opts="-P -g -n -r -p -h --address --path-template --time-template --symlinks --file-access --profile-substitute-env --use-profile --group-by --dry-run --dry-run-warmup --check-index --log-level --log-level-logfile --log-level-dryrun --log-level-dependencies --log-file --no-progress --json-progress --progress-interval --prometheus --opentelemetry --show-time-offset --repo --repository --repo-hot --no-cache --cache-dir --warm-up --warm-up-command --warm-up-wait-command --warm-up-wait --warm-up-batch --key --key-file --key-command --password --password-file --password-command --filter-host --filter-label --filter-paths --filter-paths-exact --filter-tags --filter-tags-exact --filter-after --filter-before --filter-size --filter-size-added --filter-last --filter-jq --help [SNAPSHOT[:PATH]]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --address)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --path-template)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time-template)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --file-access)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-profile)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --group-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-logfile)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dryrun)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-level-dependencies)
                    COMPREPLY=($(compgen -W "off error warn info debug trace" -- "${cur}"))
                    return 0
                    ;;
                --log-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --progress-interval)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prometheus)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --opentelemetry)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --repository)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                -r)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --repo-hot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cache-dir)
                    COMPREPLY=()
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o plusdirs
                    fi
                    return 0
                    ;;
                --warm-up-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-wait)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --warm-up-batch)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --key-command)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                -p)
                    local oldifs
                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
                        compopt -o filenames
                    fi
                    return 0
                    ;;
                --password-command)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-host)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-paths-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-tags-exact)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-before)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-size-added)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-last)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --filter-jq)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
    esac
}

if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
    complete -F _rustic -o nosort -o bashdefault -o default rustic
else
    complete -F _rustic -o bashdefault -o default rustic
fi
