_nitrocli() {
    local i cur prev opts cmds
    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    prev="${COMP_WORDS[COMP_CWORD-1]}"
    cmd=""
    opts=""

    for i in ${COMP_WORDS[@]}
    do
        case "${i}" in
            nitrocli)
                cmd="nitrocli"
                ;;
            
            add)
                cmd+="__add"
                ;;
            clear)
                cmd+="__clear"
                ;;
            close)
                cmd+="__close"
                ;;
            config)
                cmd+="__config"
                ;;
            create)
                cmd+="__create"
                ;;
            encrypted)
                cmd+="__encrypted"
                ;;
            fill)
                cmd+="__fill"
                ;;
            get)
                cmd+="__get"
                ;;
            help)
                cmd+="__help"
                ;;
            hidden)
                cmd+="__hidden"
                ;;
            list)
                cmd+="__list"
                ;;
            lock)
                cmd+="__lock"
                ;;
            open)
                cmd+="__open"
                ;;
            otp)
                cmd+="__otp"
                ;;
            pin)
                cmd+="__pin"
                ;;
            pws)
                cmd+="__pws"
                ;;
            reset)
                cmd+="__reset"
                ;;
            set)
                cmd+="__set"
                ;;
            status)
                cmd+="__status"
                ;;
            unblock)
                cmd+="__unblock"
                ;;
            unencrypted)
                cmd+="__unencrypted"
                ;;
            update)
                cmd+="__update"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        nitrocli)
            opts=" -v -h -V -m  --verbose --no-cache --help --version --model --serial-number --usb-path   config encrypted fill hidden list lock otp pin pws reset status unencrypted help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        
        nitrocli__config)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path   get set help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__config__get)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__config__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__config__set)
            opts=" -N -C -S -o -O -h -V -v -n -c -s -m  --no-num-lock --no-caps-lock --no-scroll-lock --otp-pin --no-otp-pin --help --version --verbose --no-cache --num-lock --caps-lock --scroll-lock --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --num-lock)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --caps-lock)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --scroll-lock)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__encrypted)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path   close open help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__encrypted__close)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__encrypted__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__encrypted__open)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__fill)
            opts=" -a -h -V -v -m  --attach --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__hidden)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path   close create open help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__hidden__close)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__hidden__create)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  <slot> <start> <end> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__hidden__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__hidden__open)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__list)
            opts=" -n -h -V -v -m  --no-connect --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__lock)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__otp)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path   clear get set status help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__otp__clear)
            opts=" -h -V -v -a -m  --help --version --verbose --no-cache --algorithm --model --serial-number --usb-path  <slot> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --algorithm)
                    COMPREPLY=($(compgen -W "hotp totp" -- "${cur}"))
                    return 0
                    ;;
                    -a)
                    COMPREPLY=($(compgen -W "hotp totp" -- "${cur}"))
                    return 0
                    ;;
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__otp__get)
            opts=" -h -V -v -a -t -m  --help --version --verbose --no-cache --algorithm --time --model --serial-number --usb-path  <slot> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --algorithm)
                    COMPREPLY=($(compgen -W "hotp totp" -- "${cur}"))
                    return 0
                    ;;
                    -a)
                    COMPREPLY=($(compgen -W "hotp totp" -- "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__otp__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__otp__set)
            opts=" -h -V -v -a -d -c -t -f -m  --help --version --verbose --no-cache --algorithm --digits --counter --time-window --format --model --serial-number --usb-path  <slot> <name> <secret> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --algorithm)
                    COMPREPLY=($(compgen -W "hotp totp" -- "${cur}"))
                    return 0
                    ;;
                    -a)
                    COMPREPLY=($(compgen -W "hotp totp" -- "${cur}"))
                    return 0
                    ;;
                --digits)
                    COMPREPLY=($(compgen -W "6 8" -- "${cur}"))
                    return 0
                    ;;
                    -d)
                    COMPREPLY=($(compgen -W "6 8" -- "${cur}"))
                    return 0
                    ;;
                --counter)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time-window)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --format)
                    COMPREPLY=($(compgen -W "ascii base32 hex" -- "${cur}"))
                    return 0
                    ;;
                    -f)
                    COMPREPLY=($(compgen -W "ascii base32 hex" -- "${cur}"))
                    return 0
                    ;;
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__otp__status)
            opts=" -a -h -V -v -m  --all --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pin)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path   clear set unblock help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pin__clear)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pin__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pin__set)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  <type> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pin__unblock)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pws)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path   clear get add update status help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pws__add)
            opts=" -h -V -v -s -m  --help --version --verbose --no-cache --slot --model --serial-number --usb-path  <name> <login> <password> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --slot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pws__clear)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  <slot> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pws__get)
            opts=" -n -l -p -q -h -V -v -m  --name --login --password --quiet --help --version --verbose --no-cache --model --serial-number --usb-path  <slot> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pws__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pws__status)
            opts=" -a -h -V -v -m  --all --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__pws__update)
            opts=" -h -V -v -n -l -p -m  --help --version --verbose --no-cache --name --login --password --model --serial-number --usb-path  <slot> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --login)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -l)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                    -p)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__reset)
            opts=" -h -V -v -m  --only-aes-key --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__status)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__unencrypted)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path   set help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__unencrypted__help)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        nitrocli__unencrypted__set)
            opts=" -h -V -v -m  --help --version --verbose --no-cache --model --serial-number --usb-path  <type> "
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                
                --model)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                    -m)
                    COMPREPLY=($(compgen -W "librem pro storage" -- "${cur}"))
                    return 0
                    ;;
                --serial-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --usb-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
    esac
}

complete -F _nitrocli -o bashdefault -o default nitrocli
