Install the new shell completion logic

Add a new make target (completion) to generate the shell
completion scripts. This will generate the scripts for bash,
zsh and fish for both podman and podman-remote with `podman completion`.
The scripts are put into the completions directory and can be
installed system wide with `sudo make install.completions`.

This commit replaces the current handwritten scripts for bash and zsh.

The `validate.completion` target has been adjusted to make sure nobody
edits these scripts directly.

Signed-off-by: Paul Holzinger <paul.holzinger@web.de>

1 files changed, 250 insertions, 3580 deletions

diff --git a/completions/bash/podman b/completions/bash/podman
index c08bb3352..17d1e86b7 100644
--- a/completions/bash/podman
+++ b/completions/bash/podman
@@ -1,3601 +1,271 @@
-#
-# This bash script was originally copied and converted from the upstream
-# github.com:docker/docker project
-#
-: ${PROG:=$(basename ${BASH_SOURCE})}
+# bash completion for podman                               -*- shell-script -*-
 
-
-__podman_previous_extglob_setting=$(shopt -p extglob)
-shopt -s extglob
-
-__podman_q() {
-    podman ${host:+-H "$host"} ${config:+--config "$config"} 2>/dev/null "$@"
-}
-
-# __podman_containers returns a list of containers. Additional options to
-# `podman ps` may be specified in order to filter the list, e.g.
-# `__podman_containers --filter status=running`
-# By default, only names are returned.
-# Set PODMAN_COMPLETION_SHOW_CONTAINER_IDS=yes to also complete IDs.
-# An optional first option `--id|--name` may be used to limit the
-# output to the IDs or names of matching items. This setting takes
-# precedence over the environment setting.
-__podman_containers() {
-	local format
-	if [ "$1" = "--id" ] ; then
-		format='{{.ID}}'
-		shift
-	elif [ "$1" = "--name" ] ; then
-		format='{{.Names}}'
-		shift
-	elif [ "${PODMAN_COMPLETION_SHOW_CONTAINER_IDS}" = yes ] ; then
-		format='{{.ID}} {{.Names}}'
-	else
-		format='{{.Names}}'
-	fi
-	__podman_q ps --format "$format" "$@"
-}
-
-__podman_list_registries() {
-        sed -n -e '/registries.*=/ {s/.*\[\([^]]*\).*/\1/p;q}' /etc/containers/registries.conf  | sed -e "s/[,']//g"
-}
-
-# __podman_pods returns a list of pods. Additional options to
-# `podman pod ps` may be specified in order to filter the list, e.g.
-# `__podman_containers --filter status=running`
-# By default, only names are returned.
-# Set PODMAN_COMPLETION_SHOW_CONTAINER_IDS=yes to also complete IDs.
-# An optional first option `--id|--name` may be used to limit the
-# output to the IDs or names of matching items. This setting takes
-# precedence over the environment setting.
-__podman_pods() {
-	local format
-	if [ "$1" = "--id" ] ; then
-		format='{{.ID}}'
-		shift
-	elif [ "$1" = "--name" ] ; then
-		format='{{.Name}}'
-		shift
-	else
-		format='{{.Name}}'
-	fi
-	__podman_q pod ps --format "$format" "$@"
-}
-
-# __podman_complete_containers applies completion of containers based on the current
-# value of `$cur` or the value of the optional first option `--cur`, if given.
-# Additional filters may be appended, see `__podman_containers`.
-__podman_complete_containers() {
-	local current="$cur"
-	if [ "$1" = "--cur" ] ; then
-		current="$2"
-		shift 2
-	fi
-	COMPREPLY=( $(compgen -W "$(__podman_containers "$@")" -- "$current") )
-}
-
-# __podman_complete_pods applies completion of pods based on the current
-# value of `$cur` or the value of the optional first option `--cur`, if given.
-# Additional filters may be appended, see `__podman_pods`.
-__podman_complete_pods() {
-	local current="$cur"
-	if [ "$1" = "--cur" ] ; then
-		current="$2"
-		shift 2
-	fi
-	COMPREPLY=( $(compgen -W "$(__podman_pods "$@")" -- "$current") )
-}
-
-__podman_complete_pod_names() {
-	local names=( $(__podman_q pod ps --format={{.Name}}) )
-	COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
-}
-
-__podman_complete_containers_all() {
-	__podman_complete_containers "$@" --all
-}
-
-__podman_complete_containers_created() {
-	__podman_complete_containers "$@" --all --filter status=created
-}
-
-__podman_complete_containers_running() {
-	__podman_complete_containers "$@" --filter status=running
-}
-
-__podman_complete_containers_stopped() {
-	__podman_complete_containers "$@" --all --filter status=exited
-}
-
-__podman_complete_containers_unpauseable() {
-	__podman_complete_containers "$@" --all --filter status=paused
-}
-
-__podman_complete_container_names() {
-	local containers=( $(__podman_q ps -aq --no-trunc) )
-	local names=( $(__podman_q inspect --format '{{.Name}}' "${containers[@]}") )
-	names=( "${names[@]#/}" ) # trim off the leading "/" from the container names
-	COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
-}
-
-__podman_complete_container_ids() {
-	local containers=( $(__podman_q ps -aq) )
-	COMPREPLY=( $(compgen -W "${containers[*]}" -- "$cur") )
-}
-
-__podman_images() {
-	local images_args=""
-
-	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
-		all)
-			images_args="--no-trunc -a"
-			;;
-		non-intermediate)
-			images_args="--no-trunc"
-			;;
-	esac
-
-	local repo_print_command
-	if [ "${PODMAN_COMPLETION_SHOW_TAGS:-yes}" = "yes" ]; then
-		repo_print_command='print $1; print $1":"$2'
-	else
-		repo_print_command='print $1'
-	fi
-
-	local awk_script
-	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
-		all|non-intermediate)
-			awk_script='NR>1 { print $3; if ($1 != "<none>") { '"$repo_print_command"' } }'
-			;;
-		none|*)
-			awk_script='NR>1 && $1 != "<none>" { '"$repo_print_command"' }'
-			;;
-	esac
-
-	__podman_q images $images_args | awk "$awk_script" | grep -v '<none>$'
-}
-
-__podman_complete_images() {
-	COMPREPLY=( $(compgen -W "$(__podman_images)" -- "$cur") )
-	__ltrim_colon_completions "$cur"
-}
-
-__podman_complete_image_repos() {
-	local repos="$(__podman_q images | awk 'NR>1 && $1 != "<none>" { print $1 }')"
-	COMPREPLY=( $(compgen -W "$repos" -- "$cur") )
-}
-
-__podman_complete_image_repos_and_tags() {
-	local reposAndTags="$(__podman_q images | awk 'NR>1 && $1 != "<none>" { print $1; print $1":"$2 }')"
-	COMPREPLY=( $(compgen -W "$reposAndTags" -- "$cur") )
-	__ltrim_colon_completions "$cur"
-}
-
-# __podman_networks returns a list of all networks. Additional options to
-# `podman network ls` may be specified in order to filter the list, e.g.
-# `__podman_networks --filter type=custom`
-# By default, only names are returned.
-# Set PODMAN_COMPLETION_SHOW_NETWORK_IDS=yes to also complete IDs.
-# An optional first option `--id|--name` may be used to limit the
-# output to the IDs or names of matching items. This setting takes
-# precedence over the environment setting.
-__podman_networks() {
-	local format
-	if [ "$1" = "--id" ] ; then
-		format='{{.ID}}'
-		shift
-	elif [ "$1" = "--name" ] ; then
-		format='{{.Name}}'
-		shift
-	elif [ "${PODMAN_COMPLETION_SHOW_NETWORK_IDS}" = yes ] ; then
-		format='{{.ID}} {{.Name}}'
-	else
-		format='{{.Name}}'
-	fi
-	__podman_q network ls --format "$format" "$@"
-}
-
-# __podman_complete_networks applies completion of networks based on the current
-# value of `$cur` or the value of the optional first option `--cur`, if given.
-# Additional filters may be appended, see `__podman_networks`.
-__podman_complete_networks() {
-	local current="$cur"
-	if [ "$1" = "--cur" ] ; then
-		current="$2"
-		shift 2
-	fi
-	COMPREPLY=( $(compgen -W "$(__podman_networks "$@")" -- "$current") )
-}
-
-__podman_complete_containers_in_network() {
-	local containers=$(__podman_q network inspect -f '{{range $i, $c := .Containers}}{{$i}} {{$c.Name}} {{end}}' "$1")
-	COMPREPLY=( $(compgen -W "$containers" -- "$cur") )
-}
-
-__podman_runtimes() {
-	__podman_q info | sed -n 's/^Runtimes: \(.*\)/\1/p'
-}
-
-__podman_complete_runtimes() {
-	COMPREPLY=( $(compgen -W "$(__podman_runtimes)" -- "$cur") )
-}
-
-# __podman_services returns a list of all services. Additional options to
-# `podman service ls` may be specified in order to filter the list, e.g.
-# `__podman_services --filter name=xxx`
-# By default, only node names are returned.
-# Set PODMAN_COMPLETION_SHOW_SERVICE_IDS=yes to also complete IDs.
-# An optional first option `--id|--name` may be used to limit the
-# output to the IDs or names of matching items. This setting takes
-# precedence over the environment setting.
-__podman_services() {
-	local fields='$2'  # default: service name only
-	[ "${PODMAN_COMPLETION_SHOW_SERVICE_IDS}" = yes ] && fields='$1,$2' # ID & name
-
-	if [ "$1" = "--id" ] ; then
-		fields='$1' # IDs only
-		shift
-	elif [ "$1" = "--name" ] ; then
-		fields='$2' # names only
-		shift
-	fi
-	__podman_q service ls "$@" | awk "NR>1 {print $fields}"
-}
-
-# __podman_complete_services applies completion of services based on the current
-# value of `$cur` or the value of the optional first option `--cur`, if given.
-# Additional filters may be appended, see `__podman_services`.
-__podman_complete_services() {
-	local current="$cur"
-	if [ "$1" = "--cur" ] ; then
-		current="$2"
-		shift 2
-	fi
-	COMPREPLY=( $(compgen -W "$(__podman_services "$@")" -- "$current") )
-}
-
-# __podman_append_to_completions appends the word passed as an argument to every
-# word in `$COMPREPLY`.
-# Normally you do this with `compgen -S` while generating the completions.
-# This function allows you to append a suffix later. It allows you to use
-# the __podman_complete_XXX functions in cases where you need a suffix.
-__podman_append_to_completions() {
-	COMPREPLY=( ${COMPREPLY[@]/%/"$1"} )
-}
-
-# __podman_pos_first_nonflag finds the position of the first word that is neither
-# option nor an option's argument. If there are options that require arguments,
-# you should pass a glob describing those options, e.g. "--option1|-o|--option2"
-# Use this function to restrict completions to exact positions after the argument list.
-__podman_pos_first_nonflag() {
-	local argument_flags=$1
-
-	local counter=$((${subcommand_pos:-${command_pos}} + 1))
-	while [ $counter -le $cword ]; do
-		if [ -n "$argument_flags" ] && eval "case '${words[$counter]}' in $argument_flags) true ;; *) false ;; esac"; then
-			(( counter++ ))
-			# eat "=" in case of --option=arg syntax
-			[ "${words[$counter]}" = "=" ] && (( counter++ ))
-		else
-			case "${words[$counter]}" in
-				-*)
-					;;
-				*)
-					break
-					;;
-			esac
-		fi
-
-		# Bash splits words at "=", retaining "=" as a word, examples:
-		# "--debug=false" => 3 words, "--log-opt syslog-facility=daemon" => 4 words
-		while [ "${words[$counter + 1]}" = "=" ] ; do
-			counter=$(( counter + 2))
-		done
-
-		(( counter++ ))
-	done
-
-	echo $counter
-}
-
-# __podman_map_key_of_current_option returns `key` if we are currently completing the
-# value of a map option (`key=value`) which matches the extglob given as an argument.
-# This function is needed for key-specific completions.
-__podman_map_key_of_current_option() {
-	local glob="$1"
-
-	local key glob_pos
-	if [ "$cur" = "=" ] ; then        # key= case
-		key="$prev"
-		glob_pos=$((cword - 2))
-	elif [[ $cur == *=* ]] ; then     # key=value case (OSX)
-		key=${cur%=*}
-		glob_pos=$((cword - 1))
-	elif [ "$prev" = "=" ] ; then
-		key=${words[$cword - 2]}  # key=value case
-		glob_pos=$((cword - 3))
-	else
-		return
-	fi
-
-	[ "${words[$glob_pos]}" = "=" ] && ((glob_pos--))  # --option=key=value syntax
-
-	[[ ${words[$glob_pos]} == @($glob) ]] && echo "$key"
-}
-
-# __podman_value_of_option returns the value of the first option matching `option_glob`.
-# Valid values for `option_glob` are option names like `--log-level` and globs like
-# `--log-level|-l`
-# Only positions between the command and the current word are considered.
-__podman_value_of_option() {
-	local option_extglob=$(__podman_to_extglob "$1")
-
-	local counter=$((command_pos + 1))
-	while [ $counter -lt $cword ]; do
-		case ${words[$counter]} in
-			$option_extglob )
-				echo ${words[$counter + 1]}
-				break
-				;;
-		esac
-		(( counter++ ))
-	done
-}
-
-# __podman_to_alternatives transforms a multiline list of strings into a single line
-# string with the words separated by `|`.
-# This is used to prepare arguments to __podman_pos_first_nonflag().
-__podman_to_alternatives() {
-	local parts=( $1 )
-	local IFS='|'
-	echo "${parts[*]}"
-}
-
-# __podman_to_extglob transforms a multiline list of options into an extglob pattern
-# suitable for use in case statements.
-__podman_to_extglob() {
-	local extglob=$( __podman_to_alternatives "$1" )
-	echo "@($extglob)"
-}
-
-# __podman_subcommands processes subcommands
-# Locates the first occurrence of any of the subcommands contained in the
-# first argument. In case of a match, calls the corresponding completion
-# function and returns 0.
-# If no match is found, 1 is returned. The calling function can then
-# continue processing its completion.
-#
-# TODO if the preceding command has options that accept arguments and an
-# argument is equal to one of the subcommands, this is falsely detected as
-# a match.
-__podman_subcommands() {
-	local subcommands="$1"
-
-	local counter=$(($command_pos + 1))
-
-	while [ $counter -lt $cword ]; do
-		case "${words[$counter]}" in
-			$(__podman_to_extglob "$subcommands") )
-				subcommand_pos=$counter
-				local subcommand=${words[$counter]}
-				local completions_func=_podman_${command}_${subcommand}
-				declare -F $completions_func >/dev/null && $completions_func
-				return 0
-				;;
-		esac
-		(( counter++ ))
-	done
-	return 1
-}
-
-# __podman_nospace suppresses trailing whitespace
-__podman_nospace() {
-	# compopt is not available in ancient bash versions
-	type compopt &>/dev/null && compopt -o nospace
-}
-
-__podman_complete_resolved_hostname() {
-	command -v host >/dev/null 2>&1 || return
-	COMPREPLY=( $(host 2>/dev/null "${cur%:}" | awk '/has address/ {print $4}') )
-}
-
-__podman_local_interfaces() {
-	command -v ip >/dev/null 2>&1 || return
-	ip addr show scope global 2>/dev/null | sed -n 's| \+inet \([0-9.]\+\).* \([^ ]\+\)|\1 \2|p'
-}
-
-__podman_complete_restart() {
-	case "$prev" in
-		--restart)
-			COMPREPLY=( $( compgen -W "always no on-failure unless-stopped" -- "$cur") )
-			return
-			;;
-	esac
-	return 1
-}
-
-__podman_complete_local_interfaces() {
-	local additional_interface
-	if [ "$1" = "--add" ] ; then
-		additional_interface="$2"
-	fi
-
-	COMPREPLY=( $( compgen -W "$(__podman_local_interfaces) $additional_interface" -- "$cur" ) )
-}
-
-__podman_complete_capabilities() {
-	# The list of capabilities is defined in types.go, ALL was added manually.
-	COMPREPLY=( $( compgen -W "
-		ALL
-		AUDIT_CONTROL
-		AUDIT_WRITE
-		AUDIT_READ
-		BLOCK_SUSPEND
-		CHOWN
-		DAC_OVERRIDE
-		DAC_READ_SEARCH
-		FOWNER
-		FSETID
-		IPC_LOCK
-		IPC_OWNER
-		KILL
-		LEASE
-		LINUX_IMMUTABLE
-		MAC_ADMIN
-		MAC_OVERRIDE
-		MKNOD
-		NET_ADMIN
-		NET_BIND_SERVICE
-		NET_BROADCAST
-		NET_RAW
-		SETFCAP
-		SETGID
-		SETPCAP
-		SETUID
-		SYS_ADMIN
-		SYS_BOOT
-		SYS_CHROOT
-		SYSLOG
-		SYS_MODULE
-		SYS_NICE
-		SYS_PACCT
-		SYS_PTRACE
-		SYS_RAWIO
-		SYS_RESOURCE
-		SYS_TIME
-		SYS_TTY_CONFIG
-		WAKE_ALARM
-	" -- "$cur" ) )
-}
-
-__podman_complete_detach_keys() {
-	case "$prev" in
-		--detach-keys)
-			case "$cur" in
-				*,)
-				    COMPREPLY=( $( compgen -W "${cur}ctrl-" -- "$cur" ) )
-				    ;;
-				*)
-				    COMPREPLY=( $( compgen -W "ctrl-" -- "$cur" ) )
-				    ;;
-			esac
-
-			__podman_nospace
-			return 0
-			;;
-	esac
-	return 1
-}
-
-__podman_complete_log_drivers() {
-	COMPREPLY=( $( compgen -W "
-		awslogs
-		etwlogs
-		fluentd
-		gcplogs
-		gelf
-		journald
-		json-file
-		logentries
-		none
-		splunk
-		syslog
-		k8s-file
-	" -- "$cur" ) )
-}
-
-__podman_complete_log_options() {
-	# see docs/reference/logging/index.md
-	local awslogs_options="awslogs-region awslogs-group awslogs-stream"
-	local fluentd_options="env fluentd-address fluentd-async-connect fluentd-buffer-limit fluentd-retry-wait fluentd-max-retries labels tag"
-	local gcplogs_options="env gcp-log-cmd gcp-project labels"
-	local gelf_options="env gelf-address gelf-compression-level gelf-compression-type labels tag"
-	local journald_options="env labels tag"
-	local json_file_options="env labels max-file max-size"
-	local logentries_options="logentries-token"
-	local syslog_options="env labels syslog-address syslog-facility syslog-format syslog-tls-ca-cert syslog-tls-cert syslog-tls-key syslog-tls-skip-verify tag"
-	local splunk_options="env labels splunk-caname splunk-capath splunk-format splunk-gzip splunk-gzip-level splunk-index splunk-insecureskipverify splunk-source splunk-sourcetype splunk-token splunk-url splunk-verify-connection tag"
-	local k8s_file_options="env labels max-file max-size"
-
-	local all_options="$fluentd_options $gcplogs_options $gelf_options $journald_options $logentries_options $json_file_options $syslog_options $splunk_options"
-
-	case $(__podman_value_of_option --log-driver) in
-		'')
-			COMPREPLY=( $( compgen -W "$all_options" -S = -- "$cur" ) )
-			;;
-		awslogs)
-			COMPREPLY=( $( compgen -W "$awslogs_options" -S = -- "$cur" ) )
-			;;
-		fluentd)
-			COMPREPLY=( $( compgen -W "$fluentd_options" -S = -- "$cur" ) )
-			;;
-		gcplogs)
-			COMPREPLY=( $( compgen -W "$gcplogs_options" -S = -- "$cur" ) )
-			;;
-		gelf)
-			COMPREPLY=( $( compgen -W "$gelf_options" -S = -- "$cur" ) )
-			;;
-		journald)
-			COMPREPLY=( $( compgen -W "$journald_options" -S = -- "$cur" ) )
-			;;
-		json-file)
-			COMPREPLY=( $( compgen -W "$json_file_options" -S = -- "$cur" ) )
-			;;
-		k8s-file)
-			COMPREPLY=( $( compgen -W "$k8s_file_options" -S = -- "$cur" ) )
-			;;
-		logentries)
-			COMPREPLY=( $( compgen -W "$logentries_options" -S = -- "$cur" ) )
-			;;
-		syslog)
-			COMPREPLY=( $( compgen -W "$syslog_options" -S = -- "$cur" ) )
-			;;
-		splunk)
-			COMPREPLY=( $( compgen -W "$splunk_options" -S = -- "$cur" ) )
-			;;
-		*)
-			return
-			;;
-	esac
-
-	__podman_nospace
-}
-
-__podman_complete_log_driver_options() {
-	local key=$(__podman_map_key_of_current_option '--log-opt')
-	case "$key" in
-		fluentd-async-connect)
-			COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
-			return
-			;;
-		gelf-address)
-			COMPREPLY=( $( compgen -W "udp" -S "://" -- "${cur##*=}" ) )
-			__podman_nospace
-			return
-			;;
-		gelf-compression-level)
-			COMPREPLY=( $( compgen -W "1 2 3 4 5 6 7 8 9" -- "${cur##*=}" ) )
-			return
-			;;
-		gelf-compression-type)
-			COMPREPLY=( $( compgen -W "gzip none zlib" -- "${cur##*=}" ) )
-			return
-			;;
-		syslog-address)
-			COMPREPLY=( $( compgen -W "tcp:// tcp+tls:// udp:// unix://" -- "${cur##*=}" ) )
-			__podman_nospace
-			__ltrim_colon_completions "${cur}"
-			return
-			;;
-		syslog-facility)
-			COMPREPLY=( $( compgen -W "
-				auth
-				authpriv
-				cron
-				daemon
-				ftp
-				kern
-				local0
-				local1
-				local2
-				local3
-				local4
-				local5
-				local6
-				local7
-				lpr
-				mail
-				news
-				syslog
-				user
-				uucp
-			" -- "${cur##*=}" ) )
-			return
-			;;
-		syslog-format)
-			COMPREPLY=( $( compgen -W "rfc3164 rfc5424 rfc5424micro" -- "${cur##*=}" ) )
-			return
-			;;
-		syslog-tls-ca-cert|syslog-tls-cert|syslog-tls-key)
-			_filedir
-			return
-			;;
-		syslog-tls-skip-verify)
-			COMPREPLY=( $( compgen -W "true" -- "${cur##*=}" ) )
-			return
-			;;
-		splunk-url)
-			COMPREPLY=( $( compgen -W "http:// https://" -- "${cur##*=}" ) )
-			__podman_nospace
-			__ltrim_colon_completions "${cur}"
-			return
-			;;
-		splunk-gzip|splunk-insecureskipverify|splunk-verify-connection)
-			COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
-			return
-			;;
-		splunk-format)
-			COMPREPLY=( $( compgen -W "inline json raw" -- "${cur##*=}" ) )
-			return
-			;;
-	esac
-	return 1
-}
-
-__podman_complete_log_levels() {
-	COMPREPLY=( $( compgen -W "debug info warn error fatal" -- "$cur" ) )
-}
-
-# __podman_complete_signals returns a subset of the available signals that is most likely
-# relevant in the context of podman containers
-__podman_complete_signals() {
-	local signals=(
-		SIGCONT
-		SIGHUP
-		SIGINT
-		SIGKILL
-		SIGQUIT
-		SIGSTOP
-		SIGTERM
-		SIGUSR1
-		SIGUSR2
-	)
-	COMPREPLY=( $( compgen -W "${signals[*]} ${signals[*]#SIG}" -- "$( echo $cur | tr '[:lower:]' '[:upper:]')" ) )
-}
-
-__podman_complete_user_group() {
-	if [[ $cur == *:* ]] ; then
-		COMPREPLY=( $(compgen -g -- "${cur#*:}") )
-	else
-		COMPREPLY=( $(compgen -u -S : -- "$cur") )
-		__podman_nospace
-	fi
-}
-
-__podman_list_images() {
-    COMPREPLY=($(compgen -W "$(podman images -q)" -- $cur))
-}
-
-__podman_list_containers() {
-    COMPREPLY=($(compgen -W "$(podman ps -aq)" -- $cur))
-}
-
-__podman_images() {
-	local images_args=""
-
-	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
-		all)
-			images_args="--no-trunc -a"
-			;;
-		non-intermediate)
-			images_args="--no-trunc"
-			;;
-	esac
-
-	local repo_print_command
-	if [ "${PODMAN_COMPLETION_SHOW_TAGS:-yes}" = "yes" ]; then
-		repo_print_command='print $1; print $1":"$2'
-	else
-		repo_print_command='print $1'
-	fi
-
-	local awk_script
-	case "$PODMAN_COMPLETION_SHOW_IMAGE_IDS" in
-		all|non-intermediate)
-			awk_script='NR>1 { print $3; if ($1 != "<none>") { '"$repo_print_command"' } }'
-			;;
-		none|*)
-			awk_script='NR>1 && $1 != "<none>" { '"$repo_print_command"' }'
-			;;
-	esac
-
-	__podman_q images $images_args | awk "$awk_script" | grep -v '<none>$'
-}
-
-_podman_auto_update() {
-  local options_with_args="
-      --authfile
-  "
-
-  local boolean_options="
-    --help
-    -h
-  "
-
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-        -*)
-            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-            ;;
-        *)
-            __podman_complete_volume_names
-            ;;
-    esac
-}
-
-# __podman_complete_volumes applies completion of volumes based on the current
-# value of `$cur` or the value of the optional first option `--cur`, if given.
-__podman_complete_volumes() {
-	local current="$cur"
-	if [ "$1" = "--cur" ] ; then
-		current="$2"
-		shift 2
-	fi
-	COMPREPLY=( $(compgen -W "$(__podman_volume "$@")" -- "$current") )
-}
-
-__podman_complete_volume_names() {
-	local names=( $(__podman_q volume ls --quiet) )
-	COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
-}
-
-
-_podman_attach() {
-     local options_with_args="
-     --detach-keys
-     "
-     local boolean_options="
-	  --help -h
-	  --latest -l
-	  --no-stdin
-	  --sig-proxy
-     "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-}
-
-_podman_container_attach() {
-     _podman_attach
-}
-
-_podman_container_checkpoint() {
-     local options_with_args="
-     -e
-     --export
-     "
-     local boolean_options="
-     --all -a
-     --help -h
-     --ignore-rootfs
-     --keep -k
-     --latest -l
-     --leave-running -R
-     --tcp-established
-     "
-     case "$prev" in
-        -e|--export)
-            _filedir
-            return
-            ;;
-     esac
-     case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-     esac
-}
-
-_podman_container_commit() {
-     _podman_commit
-}
-
-_podman_container_cp() {
-     _podman_cp
-}
-
-_podman_container_create() {
-     _podman_create
-}
-
-_podman_container_diff() {
-     _podman_diff
-}
-
-_podman_container_exec() {
-     _podman_exec
-}
-
-_podman_container_export() {
-     _podman_export
-}
-
-_podman_container_init() {
-     _podman_init
-}
-
-_podman_container_inspect() {
-     _podman_inspect
-}
-
-_podman_container_kill() {
-     _podman_kill
-}
-
-_podman_container_list() {
-     _podman_ls
-}
-
-_podman_container_ls() {
-     _podman_ls
-}
-
-_podman_container_logs() {
-     _podman_logs
-}
-
-_podman_container_mount() {
-     _podman_mount
-}
-
-_podman_container_pause() {
-     _podman_pause
-}
-
-_podman_container_port() {
-     _podman_port
-}
-
-_podman_container_ps() {
-     _podman_ls
-}
-
-_podman_container_refresh() {
-     local options_with_args="
-     "
-     local boolean_options="
-	--help
-	-h
-     "
-     _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_container_restart() {
-     _podman_restart
-}
-
-_podman_container_restore() {
-     local options_with_args="
-     -i
-     --import
-     -n
-     --name
-     "
-     local boolean_options="
-	  --all -a
-	  --help -h
-	  --ignore-rootfs
-	  --ignore-static-ip
-	  --ignore-static-mac
-	  --keep -k
-	  --latest -l
-	  --tcp-established
-     "
-     case "$prev" in
-        -i|--import)
-            _filedir
-            return
-            ;;
-     esac
-     case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_created
-	    ;;
-     esac
-}
-
-_podman_container_rm() {
-     _podman_rm
-}
-
-_podman_container_start() {
-     _podman_start
-}
-
-_podman_container_stats() {
-     _podman_stats
-}
-
-_podman_container_stop() {
-     _podman_stop
-}
-
-_podman_container_top() {
-     _podman_top
-}
-
-_podman_container_umount() {
-     _podman_umount
-}
-
-_podman_container_unmount() {
-     _podman_unmount
-}
-
-_podman_container_unpause() {
-     _podman_unpause
-}
-
-_podman_container_wait() {
-     _podman_wait
-}
-
-_podman_healthcheck() {
-    local boolean_options="
-	--help
-	-h
-	"
-     subcommands="
-	run
-     "
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-
-_podman_network() {
-    local boolean_options="
-	--help
-	-h
-	"
-     subcommands="
-     create
-	 inspect
-	 ls
-	 rm
-     "
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-
-_podman_network_create() {
-    local options_with_args="
-    -d
-    --driver
-    --gateway
-    --ip-range
-	--macvlan
-    --subnet
-     "
-    local boolean_options="
-        --disable-dns
-	--help -h
-	--internal
-    "
-    _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_network_inspect() {
-    local options_with_args="
-	--format
-	-f
-     "
-    local boolean_options="
-	--help
-	-h
-    "
-    _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_network_ls() {
-    local options_with_args="
-	--filter
-	--format -f
-     "
-    local boolean_options="
-    --help
-    -h
-	--quiet
-	-q
-    "
-    _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_network_rm() {
-    local options_with_args="
-     "
-    local boolean_options="
-    --force -f
-    --help -h
-    "
-    _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_generate() {
-    local boolean_options="
-	--help
-	-h
-	"
-     subcommands="
-	 kube
-	 systemd
-     "
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-
-_podman_play() {
-    local boolean_options="
-	--help
-	-h
-	"
-     subcommands="
-	 kube
-     "
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-_podman_container() {
-    local boolean_options="
-	--help
-	-h
-	"
-     subcommands="
-	 attach
-	 checkpoint
-	 commit
-	 cp
-	 create
-	 diff
-	 exec
-	 exists
-	 export
-	 inspect
-	 kill
-	 list
-	 logs
-	 mount
-	 pause
-	 port
-	 prune
-	 refresh
-	 restart
-	 restore
-	 rm
-	 run
-	 runlabel
-	 start
-	 stats
-	 stop
-	 top
-	 umount
-	 unmount
-	 unpause
-	 wait
-     "
-     local aliases="
-	 list
-	ps
-     "
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-
-_podman_system_reset() {
-	local options_with_args="
-	"
-	local boolean_options="
-	     -h
-	     --help
-	     --force
-	"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_system_df() {
-	local options_with_args="
-	--format
-	--verbose
-	"
-	local boolean_options="
-     -h
-     --help
-	 --verbose
-	 -v
-	"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_system_info() {
-   _podman_info
-}
-
-_podman_system_prune() {
-    local options_with_args="
-    "
-
-    local boolean_options="
-     --all -a
-     --force -f
-     --help -h
-     --volumes
-  "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_system_service() {
-	local options_with_args="
-	-t
-	--timeout
-	"
-	local boolean_options="
-	      --help
-	      -h
-	      --varlink
-	"
-	_complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_system() {
-    local boolean_options="
-	--help
-	-h
-	"
-     subcommands="
-	df
-	info
-	migrate
-	prune
-	renumber
-	reset
-	service
-     "
-     __podman_subcommands "$subcommands" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-
-_podman_commit() {
-    local options_with_args="
-	--author
-	-a
-	--change
-	-c
-	--message
-	-m
-	--iidfile
-     "
-    local boolean_options="
-	--help -h
-	--pause	-p
-	--quiet	-q
-     "
-    _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_podman_build() {
-     local boolean_options="
-	  --force-rm
-	  --help -h
-	  --layers
-	  --no-cache
-	  --pull
-	  --pull-always
-	  --pull-never
-	  --quiet -q
-	  --rm
-	  --squash
-	  --squash-all
-	  --tls-verify
-  "
-
-     local options_with_args="
-     --add-host
-     --annotation
-     --authfile
-     --build-arg
-     --cap-add
-     --cap-drop
-     --cgroup-parent
-     --cni-config-dir
-     --cni-plugin-path
-     --cpu-period
-     --cpu-quota
-     --cpu-shares
-     --cpuset-cpus
-     --cpuset-mems
-     --creds
-     --file -f
-     --format
-     --iidfile
-     --ipc
-     --label
-     --memory -m
-     --memory-swap
-     --mount
-     --net
-     --network
-     --pid
-     --runtime-flag
-     --security-opt
-     --shm-size
-     --tag -t
-     --ulimit
-     --userns
-     --userns-gid-map
-     --userns-gid-map-group
-     --userns-uid-map
-     --userns-uid-map-user
-     --uts
-     --volume -v
-  "
-
- case "$prev" in
-	 --file|-f)
-	     COMPREPLY=($(compgen -W "`ls`" -- "$cur"))
-	     ;;
- esac
-
- case "$cur" in
-     -*)
-	 COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	 ;;
- esac
-}
-
-_podman_diff() {
-    local options_with_args="
-     --format
-     "
-    local boolean_options="
-	--help
-	-h
-    "
-    _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_podman_exec() {
-    local options_with_args="
-    --detach-keys
-    -e
-    --env
-    --env-file
-    --user
-    -u
-    --workdir
-    -w
-     "
-    local boolean_options="
-	--help -h
-	--latest -l
-	--privileged
-	--tty -t
-     "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-
-}
-_podman_export() {
-    local options_with_args="
-     --output
-     -o
-     "
-    local boolean_options="
-	--help
-	-h
-     "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_podman_history() {
-    local options_with_args="
-     --format
-     "
-    local boolean_options="
-	--help -h
-	--human -H
-	--no-trunc
-	--quiet -q
-     "
-    _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --id
-	    ;;
-    esac
-}
-
-
-_podman_import() {
-    local options_with_args="
-	--change
-	-c
-	--message
-	-m
-     "
-    local boolean_options="
-	--help
-	-h
-	--quiet
-	-q
-     "
-     case "$prev" in
-         --change|-c|--message|-m)
-		return
-		;;
-    esac
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    local counter=$(__podman_pos_first_nonflag '--change|-c|--message|-m')
-	    if [ "$cword" -eq "$counter" ]; then
-		_filedir
-		return
-	    elif [ "$cword" -eq "$((counter + 1))" ]; then
-		__podman_complete_images --repo --tag
-		return
-	    fi
-	    ;;
-    esac
-}
-
-_podman_info() {
-    local boolean_options="
-	 --help
-	 -h
-	 --debug
-     "
-    local options_with_args="
-    -f
-    --format
-  "
-
-    local all_options="$options_with_args $boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_list_images
-	    ;;
-    esac
-}
-
-_podman_image_umount() {
-     _podman_image_unmount
-}
-
-_podman_image_unmount() {
-    local boolean_options="
-	--all -a
-	--help -h
-	--force	-f
-    "
-    local options_with_args="
-    "
-
-    local all_options="$options_with_args $boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --force-tag --id
-	    ;;
-    esac
-}
-
-_podman_image_mount() {
-    local boolean_options="
-       --all -a
-       --help -h
-    "
-
-    local options_with_args="
-	  --format
-    "
-
-    local all_options="$options_with_args $boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --force-tag --id
-	    ;;
-    esac
-}
-
-_podman_image_build() {
-     _podman_build
-}
-
-_podman_image_history() {
-     _podman_history
-}
-
-_podman_image_import() {
-     _podman_import
-}
-
-_podman_image_inspect() {
-     _podman_inspect
-}
-
-_podman_image_load() {
-     _podman_load
-}
-
-_podman_image_list() {
-     _podman_images
-}
-
-_podman_image_ls() {
-     _podman_images
-}
-
-_podman_image_pull() {
-     _podman_pull
-}
-
-_podman_image_push() {
-     _podman_push
-}
-
-_podman_image_rm() {
-     _podman_rmi
-}
-
-_podman_image_save() {
-     _podman_save
-}
-
-_podman_image_tag() {
-     _podman_tag
-}
-
-
-_podman_image_untag() {
-     _podman_untag
-}
-
-_podman_image() {
-    local boolean_options="
-	--help
-	-h
-     "
-     subcommands="
-	 build
-	 exists
-	 history
-	 import
-	 inspect
-	 load
-	 ls
-	 mount
-	 prune
-	 pull
-	 push
-	 rm
-	 save
-	 sign
-	 tag
-	 trust
-	 umount
-	 unmount
-	 untag
-     "
-     local aliases="
-	 list
-     "
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-
-_podman_images() {
-    local boolean_options="
-	--all -a
-	--digests
-	--filter -f
-	--help -h
-	--history
-	--no-trunc
-	--noheading
-	--notruncate -n
-	--quiet	-q
-     "
-    local options_with_args="
-    --format
-    --sort
-  "
-
-    local all_options="$options_with_args $boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --id
-	    ;;
-    esac
-}
-
-_podman_inspect() {
-    local boolean_options="
-	 --help -h
-	 --latest -l
-    "
-    local options_with_args="
-    --format
-     -f
-     --type
-     -t
-     --size
-     -s
-  "
-
-  local all_options="$options_with_args $boolean_options"
-
-	local preselected_type
-	local type
-
-	if [ "$1" = "--type" ] ; then
-		preselected_type=yes
-		type="$2"
-	else
-		type=$(__podman_value_of_option --type)
-	fi
-
-	case "$prev" in
-		--format|-f)
-			return
-			;;
-		--type)
-			if [ -z "$preselected_type" ] ; then
-				COMPREPLY=( $( compgen -W "container image" -- "$cur" ) )
-				return
-			fi
-			;;
-	esac
-
-	case "$cur" in
-		-*)
-			local options="--format -f --help --size -s"
-			if [ -z "$preselected_type" ] ; then
-				options+=" --type"
-			fi
-			COMPREPLY=( $( compgen -W "$options" -- "$cur" ) )
-			;;
-		*)
-			case "$type" in
-				'')
-					COMPREPLY=( $( compgen -W "
-						$(__podman_containers --all)
-						$(__podman_images --force-tag --id)
-					" -- "$cur" ) )
-					__ltrim_colon_completions "$cur"
-					;;
-				container)
-					__podman_complete_containers_all
-					;;
-				image)
-					__podman_complete_images --force-tag --id
-					;;
-			esac
-	esac
-}
-
-_podman_kill() {
-     local options_with_args="
-     --signal -s
-     "
-     local boolean_options="
-	  --all -a
-	  --help -h
-	  --latest -l
-     "
-     case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-}
-
-_podman_logs() {
-     local options_with_args="
-     --since
-     --tail
-     "
-     local boolean_options="
-	--follow -f
-	--help -h
-	--latest -l
-	--timestamps -t
-     "
-     _complete_ "$options_with_args" "$boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_list_containers
-	    ;;
-    esac
-}
-
-_podman_manifest() {
-     local boolean_options="
-     --help
-     -h
-     "
-     subcommands="
-     add
-     create
-     inspect
-     push
-     remove
-    "
-     __podman_subcommands "$subcommands" && return
-
-     case "$cur" in
-    -*)
-        COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-        ;;
-    *)
-        COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-        ;;
-     esac
-}
-
-_podman_manifest_add() {
-	 local options_with_args="
-     --annotation
-     --arch
-     --authfile
-     --cert-dir
-     --creds
-     --features
-     --os
-     --os-version
-     --variant
-     "
-
-     local boolean_options="
-     --all
-     --help
-     -h
-     --tls-verify
-     "
-
-     _complete_ "$options_with_args" "$boolean_options"
-     case "$cur" in
-         -*)
-             COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-             ;;
-         *)
-             __podman_complete_images --id
-             ;;
-     esac
-}
-
-_podman_manifest_annotate() {
-	 local options_with_args="
-     --annotation
-     --arch
-     --features
-     --os
-     --os-features
-     --os-version
-     --variant
-     "
-
-     local boolean_options="
-     --help
-     -h
-     "
-
-     _complete_ "$options_with_args" "$boolean_options"
-     case "$cur" in
-         -*)
-             COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-             ;;
-         *)
-             __podman_complete_images --id
-             ;;
-     esac
-}
-
-_podman_manifest_create() {
-    local boolean_options="
-    --all
-    --help
-    -h
-    "
-
-    _complete_ "$boolean_options"
-}
-
-_podman_manifest_inspect() {
-  local options_with_args="
-  "
-
-  local boolean_options="
-  "
-
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-        -*)
-            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-            ;;
-        *)
-			__podman_complete_images --id
-
-            ;;
-    esac
-}
-
-_podman_manifest_push() {
-	local options_with_args="
-      --authfile
-      --cert-dir
-      --creds
-      --digestfile
-      --format -f
-      --sign-by
-      --signature-policy,
-    "
-
-    local boolean_options="
-      --all
-      --help -h
-      --purge
-      --quiet
-      --remove-signatures
-      --tls-verify
-    "
-
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-        -*)
-            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-            ;;
-        *)
-            __podman_complete_images --id
-            ;;
-    esac
-}
-
-_podman_manifest_remove() {
-	local options_with_args="
-    "
-
-    local boolean_options="
-    "
-
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-        -*)
-            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-            ;;
-        *)
-            __podman_complete_images --id
-            ;;
-    esac
-}
-
-_podman_pull() {
-    local options_with_args="
-    --authfile
-    --cert-dir
-    --creds
-    --override-arch
-    --override-os
-    --override-variant
-    "
-    local boolean_options="
-	--all-tags -a
-	--disable-content-trust
-	--help -h
-	--quiet	-q
-	--tls-verify
-    "
-    _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_search() {
-	local options_with_args="
-	--authfile
-	--filter -f
-	--format
-	--limit
-	"
-	local boolean_options="
-	      --help
-	      -h
-	      --no-trunc
-	      --list-tags
-	"
-	_complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_unmount() {
-    _podman_umount $@
-}
-
-_podman_umount() {
-    local boolean_options="
-	--all -a
-	--help -h
-	--force	-f
-	--latest -l
-    "
-    local options_with_args="
-    "
-
-    local all_options="$options_with_args $boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_podman_mount() {
-    local boolean_options="
-       --all -a
-       --help -h
-       --latest -l
-       --notruncate
-    "
-
-    local options_with_args="
-	  --format
-    "
-
-    local all_options="$options_with_args $boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_podman_push() {
-    local boolean_options="
-	--compress
-	--digestflag
-	--help -h
-	--quiet	-q
-	--tls-verify
-  "
-
-    local options_with_args="
-       --authfile
-       --cert-dir
-       --creds
-       --format
-       --sign-by
-  "
-
-    local all_options="$options_with_args $boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --id
-	    ;;
-    esac
-}
-
-_podman_container_run() {
-	local options_with_args="
-		--add-host
-		--annotation
-		--attach -a
-		--blkio-weight
-		--blkio-weight-device
-		--builtin-volume
-		--cap-add
-		--cap-drop
-		--cgroup-conf
-		--cgroup-parent
-		--cidfile
-		--conmon-pidfile
-		--cpu-period
-		--cpu-quota
-		--cpu-rt-period
-		--cpu-rt-runtime
-		--cpu-shares -c
-		--cpus
-		--cpuset-cpus
-		--cpuset-mems
-		--device
-		--device-cgroup-rule
-		--device-read-bps
-		--device-read-iops
-		--device-write-bps
-		--device-write-iops
-		--dns
-		--dns-option
-		--dns-search
-		--entrypoint
-		--env -e
-		--env-file
-		--env-host
-		--expose
-		--gidmap
-		--group-add
-		--health-cmd
-		--health-interval
-		--health-retries
-		--health-start-period
-		--health-timeout
-		--hostname -h
-		--http-proxy
-		--image-volume
-		--init-path
-		--ip
-		--ipc
-		--kernel-memory
-		--label -l
-		--label-file
-		--log-driver
-		--log-opt
-		--mac-address
-		--memory -m
-		--memory-reservation
-		--memory-swap
-		--memory-swappiness
-		--name
-		--network
-		--no-healthcheck
-		--no-hosts
-		--oom-score-adj
-		--override-arch
-		--override-os
-		--override-variant
-		--pid
-		--pids-limit
-		--pod
-		--pod-id-file
-		--preserve-fds
-		--publish -p
-		--pull
-		--restart
-		--rootfs
-		--runtime
-		--security-opt
-		--shm-size
-		--stop-signal
-		--stop-timeout
-		--subgidname
-		--subuidname
-		--sysctl
-		--systemd
-		--tmpfs
-		--tz
-		--uidmap
-		--ulimit
-		--umask
-		--user -u
-		--userns
-		--uts
-		--volume -v
-		--volumes-from
-		--workdir -w
-	"
-
-	local boolean_options="
-	    --disable-content-trust=false
-	    --help -h
-	    --init
-	    --interactive -i
-	    --oom-kill-disable
-	    --privileged
-	    --publish-all -P
-	    --quiet
-	    --read-only
-	    --read-only-tmpfs
-	    --tty -t
-	"
-
-	if [ "$command" = "run" -o "$subcommand" = "run" ] ; then
-		options_with_args="$options_with_args
-			--detach-keys
-			--health-cmd
-			--health-interval
-			--health-retries
-			--health-start-period
-			--health-timeout
-		"
-		boolean_options="$boolean_options
-			--detach -d
-			--rm
-			--rmi
-			--sig-proxy=false
-		"
-		__podman_complete_detach_keys && return
-		__podman_complete_restart && return
-	fi
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    return
-	    ;;
-	*)
-	    __podman_complete_images --id
-	    ;;
-    esac
-
-
-	__podman_complete_log_driver_options && return
-
-	local key=$(__podman_map_key_of_current_option '--security-opt')
-	case "$key" in
-		label)
-			[[ $cur == *: ]] && return
-			COMPREPLY=( $( compgen -W "user: role: type: level: disable" -- "${cur##*=}") )
-			if [ "${COMPREPLY[*]}" != "disable" ] ; then
-				__podman_nospace
-			fi
-			return
-			;;
-		seccomp)
-			local cur=${cur##*=}
-			_filedir
-			COMPREPLY+=( $( compgen -W "unconfined" -- "$cur" ) )
-			return
-			;;
-	esac
-
-	case "$prev" in
-		--add-host)
-			case "$cur" in
-				*:)
-					__podman_complete_resolved_hostname
-					return
-					;;
-			esac
-			;;
-		--attach|-a)
-			COMPREPLY=( $( compgen -W 'stdin stdout stderr' -- "$cur" ) )
-			return
-			;;
-		--cap-add|--cap-drop)
-			__podman_complete_capabilities
-			return
-			;;
-		--cidfile|--env-file|--init-path|--label-file|--pod-id-file)
-			_filedir
-			return
-			;;
-		--device|--tmpfs|--volume|-v)
-			case "$cur" in
-				*:*)
-					# TODO somehow do _filedir for stuff inside the image, if it's already specified (which is also somewhat difficult to determine)
-					;;
-				'')
-					COMPREPLY=( $( compgen -W '/' -- "$cur" ) )
-					__podman_nospace
-					;;
-				/*)
-					_filedir
-					__podman_nospace
-					;;
-			esac
-			return
-			;;
-		--env|-e)
-			# we do not append a "=" here because "-e VARNAME" is legal syntax, too
-			COMPREPLY=( $( compgen -e -- "$cur" ) )
-			__podman_nospace
-			return
-			;;
-		--ipc)
-			case "$cur" in
-				*:*)
-					cur="${cur#*:}"
-					__podman_complete_containers_running
-					;;
-				*)
-					COMPREPLY=( $( compgen -W 'host private container:' -- "$cur" ) )
-					if [ "$COMPREPLY" = "container:" ]; then
-						__podman_nospace
-					fi
-					;;
-			esac
-			return
-			;;
-		--log-driver)
-			__podman_complete_log_drivers
-			return
-			;;
-		--log-opt)
-			__podman_complete_log_options
-			return
-			;;
-		--network)
-			case "$cur" in
-				container:*)
-					__podman_complete_containers_all --cur "${cur#*:}"
-					;;
-				*)
-					COMPREPLY=( $(compgen -W "bridge none host ns: private slirp4netns $(__podman_networks) container:" -- "$cur"))
-					if [ "${COMPREPLY[*]}" = "container:" ] ; then
-						__podman_nospace
-					fi
-					;;
-			esac
-			return
-			;;
-		--pod)
-			__podman_complete_pod_names
-			return
-			;;
-		--pid)
-			case "$cur" in
-				*:*)
-					__podman_complete_containers_running --cur "${cur#*:}"
-					;;
-				*)
-					COMPREPLY=( $( compgen -W 'host container: private' -- "$cur" ) )
-					if [ "$COMPREPLY" = "container:" ]; then
-						__podman_nospace
-					fi
-					;;
-			esac
-			return
-			;;
-		--runtime)
-			__podman_complete_runtimes
-			return
-			;;
-		--security-opt)
-			COMPREPLY=( $( compgen -W "apparmor= label= no-new-privileges seccomp=" -- "$cur") )
-			if [ "${COMPREPLY[*]}" != "no-new-privileges" ] ; then
-				__podman_nospace
-			fi
-			return
-			;;
-		--storage-opt)
-			COMPREPLY=( $( compgen -W "size" -S = -- "$cur") )
-			__podman_nospace
-			return
-			;;
-		--user|-u)
-			__podman_complete_user_group
-			return
-			;;
-		--userns)
-			COMPREPLY=( $( compgen -W "auto container: host keep-id ns: private" -- "$cur" ) )
-			return
-			;;
-		--volumes-from)
-			__podman_complete_containers_all
-			return
-			;;
-		$(__podman_to_extglob "$options_with_args") )
-			return
-			;;
-	esac
-
-	case "$cur" in
-		-*)
-			COMPREPLY=( $( compgen -W "$all_options" -- "$cur" ) )
-			;;
-		*)
-			local counter=$( __podman_pos_first_nonflag $( __podman_to_alternatives "$options_with_args" ) )
-			if [ $cword -eq $counter ]; then
-				__podman_complete_images
-			fi
-			;;
-	esac
-}
-
-
-_podman_create() {
-	_podman_container_run
-}
-
-
-_podman_run() {
-	_podman_container_run
-}
-
-_podman_restart() {
-     local options_with_args="
-     --time -t
-     "
-     local boolean_options="
-	  --all -a
-	  --help -h
-	  --latest -l
-	  --running
-     "
-     case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-}
-
-_podman_rm() {
-    local boolean_options="
-	--all -a
-	--cidfile
-	--force	-f
-	--help -h
-	--ignore -i
-	--latest -l
-	--volumes -v
-    "
-
-    local options_with_args="
-    "
-
-    local all_options="$options_with_args $boolean_options"
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_podman_rmi() {
-    local boolean_options="
-	 --all -a
-	 --force -f
-	 --help -h
-  "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --id
-	    ;;
-    esac
-}
-
-_podman_stats() {
-    local boolean_options="
-	 --all -a
-	 --format
-	 --help -h
-	 --no-reset
-	 --no-stream
-    "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-}
-
-_podman_tag() {
-    local options_with_args="
-    "
-    local boolean_options="
-	--help
-	-h
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images
-	    ;;
-    esac
-}
-
-_podman_untag() {
-    local options_with_args="
-    "
-    local boolean_options="
-	--help
-	-h
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images
-	    ;;
-    esac
-}
-
-__podman_top_descriptors() {
-	podman top --list-descriptors
-}
-
-__podman_complete_top_descriptors() {
-	COMPREPLY=($(compgen -W "$(__podman_top_descriptors)" -- "$cur"))
-}
-
-_podman_top() {
-    local options_with_args="
-    "
-    local boolean_options="
-	--help
-	-h
-	--latest
-	-l
-    "
-
-    # podman-top works on only *one* container, which means that when we have
-    # three or more arguments, we can complete with top descriptors.
-    if [[ "${COMP_CWORD}" -ge 3 ]]; then
-	    __podman_complete_top_descriptors
-	    return
+__podman_debug()
+{
+    if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then
+        echo "$*" >> "${BASH_COMP_DEBUG_FILE}"
     fi
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-}
-
-_podman_version() {
-    local boolean_options="
-     --help
-     -h
-    "
-    local options_with_args="
-     --format
-     -f
-    "
-    local all_options="$options_with_args $boolean_options"
-
-    _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_save() {
-     local options_with_args="
-     --output -o
-     --format
-     "
-     local boolean_options="
-	--compress
-	--help -h
-	--quiet	-q
-     "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --id
-	    ;;
-    esac
-}
-
-_podman_pause() {
-    local boolean_options="
-	--all
-	-a
-	--help
-	-h
-    "
-     local options_with_args="
-     "
-     local boolean_options=""
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-}
-
-_podman_port() {
-     local options_with_args="
-     "
-     local boolean_options="
-	--all -a
-	--help -h
-	--latest -l
-     "
-     case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_podman_ls() {
-	     _podman_ps
-}
-
-_podman_ps() {
-     local options_with_args="
-     --filter -f
-     --format
-     --last -n
-     --sort
-     --watch -w
-     "
-     local boolean_options="
-	  --all -a
-	  --external
-	  --help -h
-	  --latest -l
-	  --namespace --ns
-	  --no-trunc
-	  --pod -p
-	  --quiet -q
-	  --size -s
-	  --sync
-     "
-     _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_init() {
-    local boolean_options="
-        --all
-        -a
-        --help
-        -h
-        --latest
-        -l
-    "
-    local options_with_args="
-    "
-    case "$cur" in
-        -*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-            ;;
-        *)
-            __podman_complete_containers_unpauseable
-	    ;;
-    esac
 }
 
-_podman_start() {
-     local options_with_args="
-     --detach-keys
-     "
-
-     local boolean_options="
-	  --attach -a
-	  --help -h
-	  --interactive	-i
-	  --latest -l
-	  --sig-proxy
-     "
-     case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_stopped
-	    ;;
-    esac
-}
-_podman_stop() {
-     local options_with_args="
-     --time -t
-     "
-     local boolean_options="
-	  --all -a
-	  --cidfile
-	  --help -h
-	  --ignore -i
-	  --latest -l
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_running
-	    ;;
-    esac
-}
-
-_podman_unpause() {
-    local boolean_options="
-	--all
-	-a
-	--help
-	-h
-    "
-     local options_with_args="
-     "
-     case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_containers_unpauseable
-	    ;;
-    esac
-}
-
-_podman_varlink() {
-     local options_with_args="
-     --timeout -t
-     "
-     local boolean_options="
-	  --help
-	  -h
-     "
-     _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_wait() {
-     local options_with_args=""
-     local boolean_options="
-	--help -h
-	--interval -i
-	--latest -l
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_container_names
-	    ;;
-    esac
-}
-
-_complete_() {
-    local options_with_args=$1
-    local boolean_options="$2 -h --help"
-
-    case "$prev" in
-	$options_with_args)
-	    return
-	    ;;
-    esac
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
-	    ;;
-    esac
-}
-
-_podman_load() {
-    local options_with_args="
-    --input -i
-    "
-    local boolean_options="
-	 --help -h
-	 --quiet -q
-    "
-    _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_cp() {
-	local boolean_options="
-	  --extract
-	  --help -h
-	  --pause
-     "
-	_complete_ "$boolean_options"
-}
-
-_podman_login() {
-     local options_with_args="
-     --authfile
-     --get-login
-     --password -p
-     --username -u
-     "
-     local boolean_options="
-	  --help
-	  -h
-	  --password-stdin
-     "
-     _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_logout() {
-     local options_with_args="
-     --authfile
-     "
-     local boolean_options="
-	  --all
-	  -a
-	  --help
-	  -h
-     "
-     _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_healthcheck_run() {
-    local options_with_args=""
-
-    local boolean_options="
-    -h
-    --help
-    "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    COMPREPLY=( $( compgen -W "
-			  $(__podman_containers --all)
-			  " -- "$cur" ) )
-	    __ltrim_colon_completions "$cur"
-	    ;;
-    esac
-}
-
-_podman_generate_kube() {
-     local options_with_args="
-     --filename -f
-     "
-
-    local boolean_options="
-    -h
-    --help
-    -s
-    --service
-    "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    COMPREPLY=( $( compgen -W "
-			  $(__podman_containers --all)
-			  $(__podman_pods)
-			  " -- "$cur" ) )
-	    __ltrim_colon_completions "$cur"
-	    ;;
-    esac
-}
-
-_podman_generate_systemd() {
-    local options_with_args="
-    --restart-policy
-    -t
-    --time
-	--container-prefix
-	--pod-prefix
-	--separator"
-
-    local boolean_options="
-    -h
-    --help
-    -n
-    --name
-    "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    COMPREPLY=( $( compgen -W "
-			  $(__podman_containers --all)
-			  " -- "$cur" ) )
-	    __ltrim_colon_completions "$cur"
-	    ;;
-    esac
-}
-
-_podman_play_kube() {
-    local options_with_args="
-    --authfile
-    --cert-dir
-    --creds
-    --network
-    "
-
-    local boolean_options="
-    --help -h
-    --quiet -q
-    --seccomp-profile-root
-    --tls-verify
-    "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    _filedir
-	    ;;
-    esac
-}
-
-_podman_events() {
-    local options_with_args="
-     --filter
-     --format
-     --help -h
-     --since
-     --until
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_container_runlabel() {
-    local options_with_args="
-     --authfile
-     --cert-dir
-     --creds
-     --name
-    "
-
-    local boolean_options="
-	 --display
-	 --help -h
-	 --quiet -q
-	 --replace
-	 --tls-verify
-  "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images --id
-	    ;;
-    esac
-}
-
-_podman_image_sign() {
-    local options_with_args="
-	--cert-dir
-	--directory -d
-	--sign-by
-    "
-    local boolean_options="
-	--help
-	-h
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images
-	    ;;
-    esac
-}
-
-_podman_image_trust_set() {
-    echo hello
-    local options_with_args="
-	--pubkeysfile -f
-	--type -t
-    "
-    local boolean_options="
-	--help
-	-h
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    COMPREPLY=($(compgen -W "default $( __podman_list_registries )" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_image_trust_show() {
-    local options_with_args="
-    "
-    local boolean_options="
-	--help -h
-	--json -j
-	--raw
-    "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images
-	    ;;
-    esac
-}
-
-_podman_image_trust() {
-    local boolean_options="
-	--help
-	-h
-     "
-     subcommands="
-	 set
-	 show
-     "
-     local aliases="
-	 list
-     "
-     command=image_trust
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-	-*)
-		COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-		;;
-	*)
-		COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-		;;
-     esac
-}
-
-_podman_images_prune() {
-    local options_with_args="
-    "
-
-    local boolean_options="
-        --all -a
-	--help -h
-  "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_container_prune() {
-    local options_with_args="
-	 --filter
-    "
-
-    local boolean_options="
-	 --force -f
-	 --help -h
-  "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_container_exists() {
-    local options_with_args="
-    "
-
-    local boolean_options="
-	  --external
-	  --help -h
-    "
-
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_images
-	    ;;
-    esac
-
-}
-
-_podman_pod_exists() {
-    local options_with_args="
-    "
-
-    local boolean_options="
-  "
-}
-
-_podman_image_exists() {
-    local options_with_args="
-    "
-
-    local boolean_options="
-  "
-}
-
-_podman_pod_create() {
-  local options_with_args="
-      --add-host
-      --cgroup-parent
-      --dns
-      --dns-opt
-      --dns-search
-      --infra-command
-      --infra-conmon-pidfile
-      --infra-image
-      --ip
-      --label-file
-      --label
-      -l
-      --mac-address
-      --name
-      --network
-      --no-hosts
-      --podidfile
-      --publish
-      -p
-      --share
-  "
-
-  local boolean_options="
-      --help -h
-      --infra
-      --replace
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_pod_kill() {
-  local options_with_args="
-  "
-
-  local boolean_options="
-      --all -a
-      --help -h
-      --latest -l
-      --signal -s
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_pod_names
-	    ;;
-    esac
-}
-
-__podman_pod_ps() {
-  local options_with_args="
-   --filter -f
-   --format
-   --sort
-  "
-
-  local boolean_options="
-	 --cgroup
-	 --ctr-ids
-	 --ctr-names
-	 --ctr-status
-	 --help	-h
-	 --labels
-	 --latest -l
-	 --no-trunc
-	 --quiet -q
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_pod_ls() {
-  __podman_pod_ps
-}
-
-_podman_pod_list() {
-  __podman_pod_ps
-}
-
-_podman_pod_ps() {
-  __podman_pod_ps
-}
-
-_podman_pod_prune() {
-    local options_with_args="
-    "
-
-    local boolean_options="
-     -f
-     -h
-	 --help
-  "
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-    esac
-}
-
-_podman_pod_restart() {
-  local options_with_args="
-  "
-
-  local boolean_options="
-      --all -a
-      --help -h
-      --latest -l
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_pod_names
-	    ;;
-    esac
-}
-
-_podman_pod_rm() {
-  local options_with_args="
-      --pod-id-file
-  "
-
-  local boolean_options="
-      --all -a
-      --force -f
-      --help -h
-      --ignore -i
-      --latest -l
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_pod_names
-	    ;;
-    esac
-}
-
-_podman_pod_start() {
-  local options_with_args="
-      --pod-id-file
-  "
-
-  local boolean_options="
-      --all -a
-      --help -h
-      --latest -l
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_pod_names
-	    ;;
-    esac
-}
-
-_podman_pod_stop() {
-  local options_with_args="
-      --pod-id-file
-      --time -t
-  "
-
-  local boolean_options="
-      --all -a
-      --cleanup
-      --help -h
-      --ignore -i
-      --latest -l
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_pod_names
-	    ;;
-    esac
-}
-
-_podman_pod_pause() {
-  local options_with_args="
-  "
-
-  local boolean_options="
-      --all -a
-      --help -h
-      --latest -l
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_pod_names
-	    ;;
-    esac
-}
-
-_podman_pod_unpause() {
-  local options_with_args="
-  "
-
-  local boolean_options="
-      --all -a
-      --help -h
-      --latest -l
-  "
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-	-*)
-	    COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-	    ;;
-	*)
-	    __podman_complete_pod_names
-	    ;;
-    esac
-}
-
-_podman_pod_inspect() {
-  local options_with_args="
-   --format -f
-   --latest -l
-  "
-
-  _complete_ "$options_with_args"
-}
-
-
-_podman_pod() {
-    local boolean_options="
-	--help
-	-h
-    "
-    subcommands="
-     create
-     inspect
-     kill
-     pause
-     ps
-     restart
-     rm
-     start
-     stats
-     stop
-     top
-     unpause
-    "
-    local aliases="
-     list
-     ls
-    "
-     __podman_subcommands "$subcommands $aliases" && return
-
-     case "$cur" in
-    -*)
-	COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-	;;
-    *)
-	COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-	;;
-     esac
-}
-
-_podman_volume_create() {
-  local options_with_args="
-      --driver
-      --label -l
-      --opt -o
-  "
-
-  local boolean_options="
-    --help
-    -h
-  "
-
-  _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_volume_ls() {
-  local options_with_args="
-      --filter
-      --format -f
-  "
-
-  local boolean_options="
-    --help -h
-    --quiet -q
-  "
-
-  _complete_ "$options_with_args" "$boolean_options"
-}
-
-_podman_volume_inspect() {
-  local options_with_args="
-      --format
-      -f
-  "
-
-  local boolean_options="
-    --all -a
-    --help -h
-  "
+__podman_perform_completion()
+{
+    __podman_debug
+    __podman_debug "========= starting completion logic =========="
+    __podman_debug "cur is ${cur}, words[*] is ${words[*]}, #words[@] is ${#words[@]}, cword is $cword"
+
+    # The user could have moved the cursor backwards on the command-line.
+    # We need to trigger completion from the $cword location, so we need
+    # to truncate the command-line ($words) up to the $cword location.
+    words=("${words[@]:0:$cword+1}")
+    __podman_debug "Truncated words[*]: ${words[*]},"
+
+    local shellCompDirectiveError=1
+    local shellCompDirectiveNoSpace=2
+    local shellCompDirectiveNoFileComp=4
+    local shellCompDirectiveFilterFileExt=8
+    local shellCompDirectiveFilterDirs=16
+    local shellCompDirectiveLegacyCustomComp=32
+    local shellCompDirectiveLegacyCustomArgsComp=64
+
+    local out requestComp lastParam lastChar comp directive args flagPrefix
+
+    # Prepare the command to request completions for the program.
+    # Calling ${words[0]} instead of directly podman allows to handle aliases
+    args=("${words[@]:1}")
+    requestComp="${words[0]} __completeNoDesc ${args[*]}"
+
+    lastParam=${words[$((${#words[@]}-1))]}
+    lastChar=${lastParam:$((${#lastParam}-1)):1}
+    __podman_debug "lastParam ${lastParam}, lastChar ${lastChar}"
+
+    if [ -z "${cur}" ] && [ "${lastChar}" != "=" ]; then
+        # If the last parameter is complete (there is a space following it)
+        # We add an extra empty parameter so we can indicate this to the go method.
+        __podman_debug "Adding extra empty parameter"
+        requestComp="${requestComp} \"\""
+    fi
 
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-        -*)
-            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-            ;;
-        *)
-            __podman_complete_volume_names
-            ;;
-    esac
-}
+    # When completing a flag with an = (e.g., podman -n=<TAB>)
+    # bash focuses on the part after the =, so we need to remove
+    # the flag part from $cur
+    if [[ "${cur}" == -*=* ]]; then
+        flagPrefix="${cur%%=*}="
+        cur="${cur#*=}"
+    fi
 
-_podman_volume_rm() {
-  local options_with_args=""
+    __podman_debug "Calling ${requestComp}"
+    # Use eval to handle any environment variables and such
+    out=$(eval "${requestComp}" 2>/dev/null)
+
+    # Extract the directive integer at the very end of the output following a colon (:)
+    directive=${out##*:}
+    # Remove the directive
+    out=${out%:*}
+    if [ "${directive}" = "${out}" ]; then
+        # There is not directive specified
+        directive=0
+    fi
+    __podman_debug "The completion directive is: ${directive}"
+    __podman_debug "The completions are: ${out[*]}"
+
+    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+        # Error code.  No completion.
+        __podman_debug "Received error from custom completion go code"
+        return
+    else
+        if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+            if [[ $(type -t compopt) = "builtin" ]]; then
+                __podman_debug "Activating no space"
+                compopt -o nospace
+            fi
+        fi
+        if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+            if [[ $(type -t compopt) = "builtin" ]]; then
+                __podman_debug "Activating no file completion"
+                compopt +o default
+            fi
+        fi
+    fi
 
-  local boolean_options="
-    --all -a
-    --force -f
-    --help -h
-  "
+    if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
+        # File extension filtering
+        local fullFilter filter filteringCmd
+
+        # Do not use quotes around the $out variable or else newline
+        # characters will be kept.
+        for filter in ${out[*]}; do
+            fullFilter+="$filter|"
+        done
+
+        filteringCmd="_filedir $fullFilter"
+        __podman_debug "File filtering command: $filteringCmd"
+        $filteringCmd
+    elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
+        # File completion for directories only
+
+        # Use printf to strip any trailing newline
+        local subdir
+        subdir=$(printf "%s" "${out[0]}")
+        if [ -n "$subdir" ]; then
+            __podman_debug "Listing directories in $subdir"
+            pushd "$subdir" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1 || return
+        else
+            __podman_debug "Listing directories in ."
+            _filedir -d
+        fi
+    elif [ $((directive & shellCompDirectiveLegacyCustomComp)) -ne 0 ]; then
+        local cmd
+        __podman_debug "Legacy custom completion. Directive: $directive, cmds: ${out[*]}"
+
+        # The following variables should get their value through the commands
+        # we have received as completions and are parsing below.
+        local last_command
+        local nouns
+
+        # Execute every command received
+        while IFS='' read -r cmd; do
+            __podman_debug "About to execute: $cmd"
+            eval "$cmd"
+        done < <(printf "%s\n" "${out[@]}")
+
+        __podman_debug "last_command: $last_command"
+        __podman_debug "nouns[0]: ${nouns[0]}, nouns[1]: ${nouns[1]}"
+
+        if [ $((directive & shellCompDirectiveLegacyCustomArgsComp)) -ne 0 ]; then
+            # We should call the global legacy custom completion function, if it is defined
+            if declare -F __podman_custom_func >/dev/null; then
+                # Use command name qualified legacy custom func
+                __podman_debug "About to call: __podman_custom_func"
+                __podman_custom_func
+            elif declare -F __custom_func >/dev/null; then
+                # Otherwise fall back to unqualified legacy custom func for compatibility
+                __podman_debug "About to call: __custom_func"
+                 __custom_func
+            fi
+        fi
+    else
+        local tab
+        tab=$(printf '\t')
+        local longest=0
+        # Look for the longest completion so that we can format things nicely
+        while IFS='' read -r comp; do
+            comp=${comp%%$tab*}
+            if ((${#comp}>longest)); then
+                longest=${#comp}
+            fi
+        done < <(printf "%s\n" "${out[@]}")
+
+        local completions=()
+        while IFS='' read -r comp; do
+            if [ -z "$comp" ]; then
+                continue
+            fi
+
+            __podman_debug "Original comp: $comp"
+            comp="$(__podman_format_comp_descriptions "$comp" "$longest")"
+            __podman_debug "Final comp: $comp"
+            completions+=("$comp")
+        done < <(printf "%s\n" "${out[@]}")
+
+        while IFS='' read -r comp; do
+            # Although this script should only be used for bash
+            # there may be programs that still convert the bash
+            # script into a zsh one.  To continue supporting those
+            # programs, we do this single adaptation for zsh
+            if [ -n "${ZSH_VERSION}" ]; then
+                # zsh completion needs --flag= prefix
+                COMPREPLY+=("$flagPrefix$comp")
+            else
+                COMPREPLY+=("$comp")
+            fi
+        done < <(compgen -W "${completions[*]}" -- "$cur")
+
+        # If there is a single completion left, remove the description text
+        if [ ${#COMPREPLY[*]} -eq 1 ]; then
+            __podman_debug "COMPREPLY[0]: ${COMPREPLY[0]}"
+            comp="${COMPREPLY[0]%% *}"
+            __podman_debug "Removed description from single completion, which is now: ${comp}"
+            COMPREPLY=()
+            COMPREPLY+=("$comp")
+        fi
+    fi
 
-  _complete_ "$options_with_args" "$boolean_options"
-    case "$cur" in
-        -*)
-            COMPREPLY=($(compgen -W "$boolean_options $options_with_args" -- "$cur"))
-            ;;
-        *)
-            __podman_complete_volume_names
-            ;;
-    esac
+    __podman_handle_special_char "$cur" :
+    __podman_handle_special_char "$cur" =
 }
 
-_podman_volume_prune() {
-  local options_with_args=""
-
-  local boolean_options="
-    --force -f
-    --help -h
-  "
-
-  _complete_ "$options_with_args" "$boolean_options"
+__podman_handle_special_char()
+{
+    local comp="$1"
+    local char=$2
+    if [[ "$comp" == *${char}* && "$COMP_WORDBREAKS" == *${char}* ]]; then
+        local word=${comp%"${comp##*${char}}"}
+        local idx=${#COMPREPLY[*]}
+        while [[ $((--idx)) -ge 0 ]]; do
+            COMPREPLY[$idx]=${COMPREPLY[$idx]#"$word"}
+        done
+    fi
 }
 
-_podman_volume() {
-    local boolean_options="
-    --help -h
-    "
-    subcommands="
-     create
-     inspect
-     ls
-     prune
-     rm
-    "
-    local aliases="
-     list
-     remove
-    "
-     __podman_subcommands "$subcommands $aliases" && return
+__podman_format_comp_descriptions()
+{
+    local tab
+    tab=$(printf '\t')
+    local comp="$1"
+    local longest=$2
+
+    # Properly format the description string which follows a tab character if there is one
+    if [[ "$comp" == *$tab* ]]; then
+        desc=${comp#*$tab}
+        comp=${comp%%$tab*}
+
+        # $COLUMNS stores the current shell width.
+        # Remove an extra 4 because we add 2 spaces and 2 parentheses.
+        maxdesclength=$(( COLUMNS - longest - 4 ))
+
+        # Make sure we can fit a description of at least 8 characters
+        # if we are to align the descriptions.
+        if [[ $maxdesclength -gt 8 ]]; then
+            # Add the proper number of spaces to align the descriptions
+            for ((i = ${#comp} ; i < longest ; i++)); do
+                comp+=" "
+            done
+        else
+            # Don't pad the descriptions so we can fit more text after the completion
+            maxdesclength=$(( COLUMNS - ${#comp} - 4 ))
+        fi
+
+        # If there is enough space for any description text,
+        # truncate the descriptions that are too long for the shell width
+        if [ $maxdesclength -gt 0 ]; then
+            if [ ${#desc} -gt $maxdesclength ]; then
+                desc=${desc:0:$(( maxdesclength - 1 ))}
+                desc+="…"
+            fi
+            comp+="  ($desc)"
+        fi
+    fi
 
-     case "$cur" in
-    -*)
-        COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
-        ;;
-    *)
-        COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
-        ;;
-     esac
+    # Must use printf to escape all special characters
+    printf "%q" "${comp}"
 }
 
-_podman_podman() {
-     local options_with_args="
-	   --cni-config-dir
-	   --conmon
-	   --connection -c
-	   --events-backend
-	   --hooks-dir
-	   --identity
-	   --log-level
-	   --namespace
-	   --network-cmd-path
-	   --root
-	   --runroot
-	   --runtime
-	   --storage-driver
-	   --storage-opt
-	   --tmpdir
-	   --url
-     "
-     local boolean_options="
-	   --help -h
-	   --remote -r
-	   --syslog
-	   --version -v
-     "
-    commands="
-    attach
-    auto-update
-    build
-    commit
-    container
-    cp
-    create
-    diff
-    events
-    exec
-    export
-    generate
-    healthcheck
-    history
-    image
-    images
-    import
-    info
-    inspect
-    kill
-    load
-    login
-    logout
-    logs
-    manifest
-    mount
-    network
-    pause
-    play
-    pod
-    port
-    ps
-    pull
-    push
-    restart
-    rm
-    rmi
-    run
-    save
-    search
-    start
-    stats
-    stop
-    system
-    tag
-    top
-    umount
-    unmount
-    unpause
-    untag
-    varlink
-    version
-    volume
-    wait
-     "
+__start_podman()
+{
+    local cur prev words cword
 
-     case "$prev" in
-	 $main_options_with_args_glob )
-	     return
-	     ;;
-     esac
+    COMPREPLY=()
+    _get_comp_words_by_ref -n "=:" cur prev words cword
 
-     case "$cur" in
-	 -*)
-	     COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
-	     ;;
-	 *)
-	     COMPREPLY=( $( compgen -W "${commands[*]} help" -- "$cur" ) )
-	     ;;
-     esac
+    __podman_perform_completion
 }
 
-_cli_bash_autocomplete() {
-     local cur opts base
-
-     COMPREPLY=()
-     cur="${COMP_WORDS[COMP_CWORD]}"
-     COMPREPLY=()
-     local cur prev words cword
+if [[ $(type -t compopt) = "builtin" ]]; then
+    complete -o default -F __start_podman podman
+else
+    complete -o default -o nospace -F __start_podman podman
+fi
 
-     _get_comp_words_by_ref -n : cur prev words cword
-
-     local command=${PROG} cpos=0
-     local counter=1
-     counter=1
-     while [ $counter -lt $cword ]; do
-	 case "!${words[$counter]}" in
-	     *)
-		 command=$(echo "${words[$counter]}" | sed 's/-/_/g')
-		 cpos=$counter
-		 (( cpos++ ))
-		 break
-		 ;;
-	 esac
-	 (( counter++ ))
-     done
-
-     local completions_func=_podman_${command}
-     declare -F $completions_func >/dev/null && $completions_func
-
-     eval "$previous_extglob_setting"
-     return 0
-}
+# ex: ts=4 sw=4 et filetype=sh
 
-complete -F _cli_bash_autocomplete podman
+# This file is generated with "podman completion"; see: podman-completion(1)