_rudof() {
    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="rudof"
                ;;
            rudof,compare)
                cmd="rudof__compare"
                ;;
            rudof,completion)
                cmd="rudof__completion"
                ;;
            rudof,convert)
                cmd="rudof__convert"
                ;;
            rudof,data)
                cmd="rudof__data"
                ;;
            rudof,dctap)
                cmd="rudof__dctap"
                ;;
            rudof,generate)
                cmd="rudof__generate"
                ;;
            rudof,help)
                cmd="rudof__help"
                ;;
            rudof,materialize)
                cmd="rudof__materialize"
                ;;
            rudof,node)
                cmd="rudof__node"
                ;;
            rudof,query)
                cmd="rudof__query"
                ;;
            rudof,rdf-config)
                cmd="rudof__rdf__config"
                ;;
            rudof,service)
                cmd="rudof__service"
                ;;
            rudof,shacl)
                cmd="rudof__shacl"
                ;;
            rudof,shacl-validate)
                cmd="rudof__shacl__validate"
                ;;
            rudof,shapemap)
                cmd="rudof__shapemap"
                ;;
            rudof,shex)
                cmd="rudof__shex"
                ;;
            rudof,shex-validate)
                cmd="rudof__shex__validate"
                ;;
            rudof,validate)
                cmd="rudof__validate"
                ;;
            rudof__help,compare)
                cmd="rudof__help__compare"
                ;;
            rudof__help,completion)
                cmd="rudof__help__completion"
                ;;
            rudof__help,convert)
                cmd="rudof__help__convert"
                ;;
            rudof__help,data)
                cmd="rudof__help__data"
                ;;
            rudof__help,dctap)
                cmd="rudof__help__dctap"
                ;;
            rudof__help,generate)
                cmd="rudof__help__generate"
                ;;
            rudof__help,help)
                cmd="rudof__help__help"
                ;;
            rudof__help,materialize)
                cmd="rudof__help__materialize"
                ;;
            rudof__help,node)
                cmd="rudof__help__node"
                ;;
            rudof__help,query)
                cmd="rudof__help__query"
                ;;
            rudof__help,rdf-config)
                cmd="rudof__help__rdf__config"
                ;;
            rudof__help,service)
                cmd="rudof__help__service"
                ;;
            rudof__help,shacl)
                cmd="rudof__help__shacl"
                ;;
            rudof__help,shacl-validate)
                cmd="rudof__help__shacl__validate"
                ;;
            rudof__help,shapemap)
                cmd="rudof__help__shapemap"
                ;;
            rudof__help,shex)
                cmd="rudof__help__shex"
                ;;
            rudof__help,shex-validate)
                cmd="rudof__help__shex__validate"
                ;;
            rudof__help,validate)
                cmd="rudof__help__validate"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        rudof)
            opts="-d -h -V --debug --help --version shapemap shex validate shex-validate shacl-validate data node shacl dctap convert compare rdf-config service query generate materialize completion help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__compare)
            opts="-r -t -c -o -h --mode1 --mode2 --schema1 --schema2 --format1 --format2 --base1 --base2 --result-format --target-folder --shape1 --shape2 --reader-mode --show-time --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --mode1)
                    COMPREPLY=($(compgen -W "shacl shex dctap service" -- "${cur}"))
                    return 0
                    ;;
                --mode2)
                    COMPREPLY=($(compgen -W "shacl shex dctap service" -- "${cur}"))
                    return 0
                    ;;
                --schema1)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --schema2)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --format1)
                    COMPREPLY=($(compgen -W "shexc shexj turtle rdfxml ntriples" -- "${cur}"))
                    return 0
                    ;;
                --format2)
                    COMPREPLY=($(compgen -W "shexc shexj turtle rdfxml ntriples" -- "${cur}"))
                    return 0
                    ;;
                --base1)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --base2)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "internal json" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "internal json" -- "${cur}"))
                    return 0
                    ;;
                --target-folder)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shape1)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shape2)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --show-time)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__completion)
            opts="-o -h --output-file --force-overwrite --help bash elvish fig fish powershell zsh"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__convert)
            opts="-m -s -f -b -r -t -e -l -x -c -o -h --input-mode --source-file --format --base --result-format --target-folder --templates-folder --shape-label --reader-mode --export-mode --show-time --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --input-mode)
                    COMPREPLY=($(compgen -W "shacl shex dctap" -- "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -W "shacl shex dctap" -- "${cur}"))
                    return 0
                    ;;
                --source-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --format)
                    COMPREPLY=($(compgen -W "csv shexc shexj turtle" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "csv shexc shexj turtle" -- "${cur}"))
                    return 0
                    ;;
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "default internal json shexc shexj turtle plantuml html svg png" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "default internal json shexc shexj turtle plantuml html svg png" -- "${cur}"))
                    return 0
                    ;;
                --target-folder)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --templates-folder)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shape-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -l)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --export-mode)
                    COMPREPLY=($(compgen -W "sparql shex uml html shacl" -- "${cur}"))
                    return 0
                    ;;
                -x)
                    COMPREPLY=($(compgen -W "sparql shex uml html shacl" -- "${cur}"))
                    return 0
                    ;;
                --show-time)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__data)
            opts="-t -b -e -r -c -o -h --data-format --base --endpoint --reader-mode --result-format --config-file --output-file --force-overwrite --help [DATA]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --data-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --endpoint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "turtle ntriples jsonld rdfxml trig n3 nquads compact json plantuml svg png" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "turtle ntriples jsonld rdfxml trig n3 nquads compact json plantuml svg png" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__dctap)
            opts="-s -f -r -c -o -h --source-file --format --result-format --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --source-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --format)
                    COMPREPLY=($(compgen -W "csv" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "csv" -- "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "internal json" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "internal json" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__generate)
            opts="-s -f -n -r -p -c -o -h --schema --schema-format --entities --result-format --seed --parallel --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --schema-format)
                    COMPREPLY=($(compgen -W "auto shex shacl" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "auto shex shacl" -- "${cur}"))
                    return 0
                    ;;
                --entities)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --seed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --parallel)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -p)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__help)
            opts="shapemap shex validate shex-validate shacl-validate data node shacl dctap convert compare rdf-config service query generate materialize completion 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
            ;;
        rudof__help__compare)
            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
            ;;
        rudof__help__completion)
            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
            ;;
        rudof__help__convert)
            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
            ;;
        rudof__help__data)
            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
            ;;
        rudof__help__dctap)
            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
            ;;
        rudof__help__generate)
            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
            ;;
        rudof__help__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
            ;;
        rudof__help__materialize)
            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
            ;;
        rudof__help__node)
            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
            ;;
        rudof__help__query)
            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
            ;;
        rudof__help__rdf__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
            ;;
        rudof__help__service)
            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
            ;;
        rudof__help__shacl)
            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
            ;;
        rudof__help__shacl__validate)
            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
            ;;
        rudof__help__shapemap)
            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
            ;;
        rudof__help__shex)
            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
            ;;
        rudof__help__shex__validate)
            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
            ;;
        rudof__help__validate)
            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
            ;;
        rudof__materialize)
            opts="-s -f -b -m -n -r -c -o -h --schema --schema-format --reader-mode --base --map-state --node --result-format --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --schema-format)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --map-state)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --node)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "turtle ntriples jsonld rdfxml trig n3 nquads compact json plantuml svg png" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "turtle ntriples jsonld rdfxml trig n3 nquads compact json plantuml svg png" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__node)
            opts="-n -t -e -b -m -p -d -c -o -h --node --data-format --endpoint --base --reader-mode --show-node-mode --show-hyperlinks --predicates --depth --config-file --output-file --force-overwrite --help [DATA]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --node)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --data-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --endpoint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --show-node-mode)
                    COMPREPLY=($(compgen -W "outgoing incoming both" -- "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -W "outgoing incoming both" -- "${cur}"))
                    return 0
                    ;;
                --show-hyperlinks)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --predicates)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -p)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -d)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__query)
            opts="-t -b -q -e -r -c -o -h --data-format --base --query-type --reader-mode --query --endpoint --result-format --config-file --output-file --force-overwrite --help [DATA]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --data-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --query-type)
                    COMPREPLY=($(compgen -W "select construct ask describe" -- "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --query)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -q)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --endpoint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "internal turtle ntriples jsonld rdfxml csv trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "internal turtle ntriples jsonld rdfxml csv trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__rdf__config)
            opts="-s -r -f -c -o -h --source-file --result-format --format --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --source-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "internal yaml" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "internal yaml" -- "${cur}"))
                    return 0
                    ;;
                --format)
                    COMPREPLY=($(compgen -W "yaml" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "yaml" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__service)
            opts="-s -f -r -c -o -h --service --format --result-format --reader-mode --base --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --service)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "internal mie json" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "internal mie json" -- "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__shacl)
            opts="-t -e -s -f -r -c -o -h --data-format --reader-mode --endpoint --shapes --shapes-format --base-data --base-shapes --result-shapes-format --config-file --output-file --force-overwrite --help [DATA]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --data-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --endpoint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shapes)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shapes-format)
                    COMPREPLY=($(compgen -W "internal turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "internal turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --base-data)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --base-shapes)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-shapes-format)
                    COMPREPLY=($(compgen -W "internal turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "internal turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__shacl__validate)
            opts="-t -s -f -e -m -r -c -o -h --data-format --base-data --reader-mode --shapes --shapes-format --base-shapes --endpoint --mode --result-format --sort_by --config-file --output-file --force-overwrite --help [DATA]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --data-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --base-data)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --shapes)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shapes-format)
                    COMPREPLY=($(compgen -W "internal turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "internal turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --base-shapes)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --endpoint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --mode)
                    COMPREPLY=($(compgen -W "native sparql" -- "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -W "native sparql" -- "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "details turtle ntriples rdfxml trig n3 nquads minimal compact json csv" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "details turtle ntriples rdfxml trig n3 nquads minimal compact json csv" -- "${cur}"))
                    return 0
                    ;;
                --sort_by)
                    COMPREPLY=($(compgen -W "severity node component value path sourceshape details" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__shapemap)
            opts="-m -f -r -o -h --shapemap --format --base-data --base-schema --result-format --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --shapemap)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --format)
                    COMPREPLY=($(compgen -W "compact internal json details csv" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "compact internal json details csv" -- "${cur}"))
                    return 0
                    ;;
                --base-data)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --base-schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "compact internal json details csv" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "compact internal json details csv" -- "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__shex)
            opts="-s -f -r -l -t -b -c -o -h --schema --format --result-format --shape-label --show-time --show-schema --no-show-schema --statistics --base --reader-mode --show-dependencies --compile --config-file --output-file --force-overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --format)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                --shape-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -l)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --show-time)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --statistics)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --show-dependencies)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --compile)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__shex__validate)
            opts="-s -f -m -n -l -t -e -r -c -o -h --schema --schema-format --shapemap --shapemap-format --node --sort_by --shape-label --data-format --base-schema --base-data --reader-mode --endpoint --result-format --map-state --config-file --output-file --force-overwrite --help [DATA]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --schema-format)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                --shapemap)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shapemap-format)
                    COMPREPLY=($(compgen -W "compact internal json details csv" -- "${cur}"))
                    return 0
                    ;;
                --node)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --sort_by)
                    COMPREPLY=($(compgen -W "node shape status details" -- "${cur}"))
                    return 0
                    ;;
                --shape-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -l)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --data-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --base-schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --base-data)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --endpoint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "details turtle ntriples rdfxml trig n3 nquads compact json csv" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "details turtle ntriples rdfxml trig n3 nquads compact json csv" -- "${cur}"))
                    return 0
                    ;;
                --map-state)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        rudof__validate)
            opts="-M -s -f -m -n -l -t -e -S -r -c -o -h --mode --schema --schema-format --shapemap --shapemap-format --base-data --base-schema --sort_by --node --shape-label --data-format --endpoint --max-steps --shacl-mode --reader-mode --result-format --map-state --config-file --output-file --force-overwrite --help [DATA]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --mode)
                    COMPREPLY=($(compgen -W "shex shacl" -- "${cur}"))
                    return 0
                    ;;
                -M)
                    COMPREPLY=($(compgen -W "shex shacl" -- "${cur}"))
                    return 0
                    ;;
                --schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --schema-format)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "internal simple shexc shexj json jsonld turtle ntriples rdfxml trig n3 nquads" -- "${cur}"))
                    return 0
                    ;;
                --shapemap)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shapemap-format)
                    COMPREPLY=($(compgen -W "compact internal json details csv" -- "${cur}"))
                    return 0
                    ;;
                --base-data)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --base-schema)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --sort_by)
                    COMPREPLY=($(compgen -W "node details" -- "${cur}"))
                    return 0
                    ;;
                --node)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shape-label)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -l)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --data-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads jsonld" -- "${cur}"))
                    return 0
                    ;;
                --endpoint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-steps)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --shacl-mode)
                    COMPREPLY=($(compgen -W "native sparql" -- "${cur}"))
                    return 0
                    ;;
                -S)
                    COMPREPLY=($(compgen -W "native sparql" -- "${cur}"))
                    return 0
                    ;;
                --reader-mode)
                    COMPREPLY=($(compgen -W "lax strict" -- "${cur}"))
                    return 0
                    ;;
                --result-format)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads compact details json csv" -- "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -W "turtle ntriples rdfxml trig n3 nquads compact details json csv" -- "${cur}"))
                    return 0
                    ;;
                --map-state)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --config-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    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 _rudof -o nosort -o bashdefault -o default rudof
else
    complete -F _rudof -o bashdefault -o default rudof
fi
