track-cli 3.0.0-rc

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/completions/_bash_completions_generator.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from "../command.js";
+/** Generates bash completions script. */
+export declare class BashCompletionsGenerator {
+    protected cmd: Command;
+    /** Generates bash completions script for given command. */
+    static generate(cmd: Command): string;
+    private constructor();
+    /** Generates bash completions code. */
+    private generate;
+    /** Generates bash completions method for given command and child commands. */
+    private generateCompletions;
+    private generateCommandCompletions;
+    private getFlags;
+    private generateOptionArguments;
+    private generateCommandCompletionsCommand;
+    private generateOptionCompletionsCommand;
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/completions/_bash_completions_generator.js

@@ -0,0 +1,201 @@
+import { FileType } from "../types/file.js";
+/** Generates bash completions script. */
+export class BashCompletionsGenerator {
+    /** Generates bash completions script for given command. */
+    static generate(cmd) {
+        return new BashCompletionsGenerator(cmd).generate();
+    }
+    constructor(cmd) {
+        Object.defineProperty(this, "cmd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cmd
+        });
+    }
+    /** Generates bash completions code. */
+    generate() {
+        const path = this.cmd.getPath();
+        const version = this.cmd.getVersion()
+            ? ` v${this.cmd.getVersion()}`
+            : "";
+        return `#!/usr/bin/env bash
+# bash completion support for ${path}${version}
+
+_${replaceSpecialChars(path)}() {
+  local word cur prev listFiles
+  local -a opts
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  cmd="_"
+  opts=()
+  listFiles=0
+
+  _${replaceSpecialChars(this.cmd.getName())}_complete() {
+    local action="$1"; shift
+    mapfile -t values < <( ${this.cmd.getName()} completions complete "\${action}" "\${@}" )
+    for i in "\${values[@]}"; do
+      opts+=("$i")
+    done
+  }
+
+  _${replaceSpecialChars(this.cmd.getName())}_expand() {
+    [ "$cur" != "\${cur%\\\\}" ] && cur="$cur\\\\"
+  
+    # expand ~username type directory specifications
+    if [[ "$cur" == \\~*/* ]]; then
+      # shellcheck disable=SC2086
+      eval cur=$cur
+      
+    elif [[ "$cur" == \\~* ]]; then
+      cur=\${cur#\\~}
+      # shellcheck disable=SC2086,SC2207
+      COMPREPLY=( $( compgen -P '~' -u $cur ) )
+      return \${#COMPREPLY[@]}
+    fi
+  }
+
+  # shellcheck disable=SC2120
+  _${replaceSpecialChars(this.cmd.getName())}_file_dir() {
+    listFiles=1
+    local IFS=$'\\t\\n' xspec #glob
+    _${replaceSpecialChars(this.cmd.getName())}_expand || return 0
+  
+    if [ "\${1:-}" = -d ]; then
+      # shellcheck disable=SC2206,SC2207,SC2086
+      COMPREPLY=( \${COMPREPLY[@]:-} $( compgen -d -- $cur ) )
+      #eval "$glob"    # restore glob setting.
+      return 0
+    fi
+  
+    xspec=\${1:+"!*.$1"}	# set only if glob passed in as $1
+    # shellcheck disable=SC2206,SC2207
+    COMPREPLY=( \${COMPREPLY[@]:-} $( compgen -f -X "$xspec" -- "$cur" ) \
+          $( compgen -d -- "$cur" ) )
+  }
+
+  ${this.generateCompletions(this.cmd).trim()}
+
+  for word in "\${COMP_WORDS[@]}"; do
+    case "\${word}" in
+      -*) ;;
+      *)
+        cmd_tmp="\${cmd}_\${word//[^[:alnum:]]/_}"
+        if type "\${cmd_tmp}" &>/dev/null; then
+          cmd="\${cmd_tmp}"
+        fi
+    esac
+  done
+
+  \${cmd}
+
+  if [[ listFiles -eq 1 ]]; then
+    return 0
+  fi
+
+  if [[ \${#opts[@]} -eq 0 ]]; then
+    # shellcheck disable=SC2207
+    COMPREPLY=($(compgen -f "\${cur}"))
+    return 0
+  fi
+
+  local values
+  values="$( printf "\\n%s" "\${opts[@]}" )"
+  local IFS=$'\\n'
+  # shellcheck disable=SC2207
+  local result=($(compgen -W "\${values[@]}" -- "\${cur}"))
+  if [[ \${#result[@]} -eq 0 ]]; then
+    # shellcheck disable=SC2207
+    COMPREPLY=($(compgen -f "\${cur}"))
+  else
+    # shellcheck disable=SC2207
+    COMPREPLY=($(printf '%q\\n' "\${result[@]}"))
+  fi
+
+  return 0
+}
+
+complete -F _${replaceSpecialChars(path)} -o bashdefault -o default ${path}`;
+    }
+    /** Generates bash completions method for given command and child commands. */
+    generateCompletions(command, path = "", index = 1) {
+        path = (path ? path + " " : "") + command.getName();
+        const commandCompletions = this.generateCommandCompletions(command, path, index);
+        const childCommandCompletions = command.getCommands(false)
+            .filter((subCommand) => subCommand !== command)
+            .map((subCommand) => this.generateCompletions(subCommand, path, index + 1))
+            .join("");
+        return `${commandCompletions}
+
+${childCommandCompletions}`;
+    }
+    generateCommandCompletions(command, path, index) {
+        const flags = this.getFlags(command);
+        const childCommandNames = command.getCommands(false)
+            .map((childCommand) => childCommand.getName());
+        const completionsPath = ~path.indexOf(" ")
+            ? " " + path.split(" ").slice(1).join(" ")
+            : "";
+        const optionArguments = this.generateOptionArguments(command, completionsPath);
+        const completionsCmd = this.generateCommandCompletionsCommand(command, completionsPath);
+        return `  __${replaceSpecialChars(path)}() {
+    opts=(${[...flags, ...childCommandNames].join(" ")})
+    ${completionsCmd}
+    if [[ \${cur} == -* || \${COMP_CWORD} -eq ${index} ]] ; then
+      return 0
+    fi
+    ${optionArguments}
+  }`;
+    }
+    getFlags(command) {
+        return command.getOptions(false)
+            .map((option) => option.flags)
+            .flat();
+    }
+    generateOptionArguments(command, completionsPath) {
+        let opts = "";
+        const options = command.getOptions(false);
+        if (options.length) {
+            opts += 'case "${prev}" in';
+            for (const option of options) {
+                const flags = option.flags
+                    .map((flag) => flag.trim())
+                    .join("|");
+                const completionsCmd = this.generateOptionCompletionsCommand(command, option.args, completionsPath, { standalone: option.standalone });
+                opts += `\n      ${flags}) ${completionsCmd} ;;`;
+            }
+            opts += "\n    esac";
+        }
+        return opts;
+    }
+    generateCommandCompletionsCommand(command, path) {
+        const args = command.getArguments();
+        if (args.length) {
+            const type = command.getType(args[0].type);
+            if (type && type.handler instanceof FileType) {
+                return `_${replaceSpecialChars(this.cmd.getName())}_file_dir`;
+            }
+            // @TODO: add support for multiple arguments
+            return `_${replaceSpecialChars(this.cmd.getName())}_complete ${args[0].action}${path}`;
+        }
+        return "";
+    }
+    generateOptionCompletionsCommand(command, args, path, opts) {
+        if (args.length) {
+            const type = command.getType(args[0].type);
+            if (type && type.handler instanceof FileType) {
+                return `opts=(); _${replaceSpecialChars(this.cmd.getName())}_file_dir`;
+            }
+            // @TODO: add support for multiple arguments
+            return `opts=(); _${replaceSpecialChars(this.cmd.getName())}_complete ${args[0].action}${path}`;
+        }
+        if (opts?.standalone) {
+            return "opts=()";
+        }
+        return "";
+    }
+}
+function replaceSpecialChars(str) {
+    return str.replace(/[^a-zA-Z0-9]/g, "_");
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/completions/_fish_completions_generator.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "../command.js";
+/** Fish completions generator. */
+export declare class FishCompletionsGenerator {
+    protected cmd: Command;
+    /** Generates fish completions script for given command. */
+    static generate(cmd: Command): string;
+    private constructor();
+    /** Generates fish completions script. */
+    private generate;
+    private generateCompletions;
+    private completeOption;
+    private complete;
+    private getCompletionCommand;
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/completions/_fish_completions_generator.js

@@ -0,0 +1,141 @@
+import { getDescription } from "../_utils.js";
+import { FileType } from "../types/file.js";
+/** Fish completions generator. */
+export class FishCompletionsGenerator {
+    /** Generates fish completions script for given command. */
+    static generate(cmd) {
+        return new FishCompletionsGenerator(cmd).generate();
+    }
+    constructor(cmd) {
+        Object.defineProperty(this, "cmd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cmd
+        });
+    }
+    /** Generates fish completions script. */
+    generate() {
+        const path = this.cmd.getPath();
+        const version = this.cmd.getVersion()
+            ? ` v${this.cmd.getVersion()}`
+            : "";
+        return `#!/usr/bin/env fish
+# fish completion support for ${path}${version}
+
+function __fish_${replaceSpecialChars(this.cmd.getName())}_using_command
+  set -l cmds ${getCommandFnNames(this.cmd).join(" ")}
+  set -l words (commandline -opc)
+  set -l cmd "_"
+  for word in $words
+    switch $word
+      case '-*'
+        continue
+      case '*'
+        set word (string replace -r -a '\\W' '_' $word)
+        set -l cmd_tmp $cmd"_$word"
+        if contains $cmd_tmp $cmds
+          set cmd $cmd_tmp
+        end
+    end
+  end
+  if test "$cmd" = "$argv[1]"
+    return 0
+  end
+  return 1
+end
+
+${this.generateCompletions(this.cmd).trim()}`;
+    }
+    generateCompletions(command) {
+        const parent = command.getParent();
+        let result = ``;
+        if (parent) {
+            // command
+            result += "\n" + this.complete(parent, {
+                description: command.getShortDescription(),
+                arguments: command.getName(),
+            });
+        }
+        // arguments
+        const commandArgs = command.getArguments();
+        if (commandArgs.length) {
+            result += "\n" + this.complete(command, {
+                arguments: commandArgs.length
+                    ? this.getCompletionCommand(command, commandArgs[0])
+                    : undefined,
+            });
+        }
+        // options
+        for (const option of command.getOptions(false)) {
+            result += "\n" + this.completeOption(command, option);
+        }
+        for (const subCommand of command.getCommands(false)) {
+            result += this.generateCompletions(subCommand);
+        }
+        return result;
+    }
+    completeOption(command, option) {
+        const shortOption = option.flags
+            .find((flag) => flag.length === 2)
+            ?.replace(/^(-)+/, "");
+        const longOption = option.flags
+            .find((flag) => flag.length > 2)
+            ?.replace(/^(-)+/, "");
+        return this.complete(command, {
+            description: getDescription(option.description),
+            shortOption: shortOption,
+            longOption: longOption,
+            // required: option.requiredValue,
+            required: true,
+            standalone: option.standalone,
+            arguments: option.args.length
+                ? this.getCompletionCommand(command, option.args[0])
+                : undefined,
+        });
+    }
+    complete(command, options) {
+        const cmd = ["complete"];
+        cmd.push("-c", this.cmd.getName());
+        cmd.push("-n", `'__fish_${replaceSpecialChars(this.cmd.getName())}_using_command __${replaceSpecialChars(command.getPath())}'`);
+        options.shortOption && cmd.push("-s", options.shortOption);
+        options.longOption && cmd.push("-l", options.longOption);
+        options.standalone && cmd.push("-x");
+        cmd.push("-k");
+        cmd.push("-f");
+        if (options.arguments) {
+            options.required && cmd.push("-r");
+            cmd.push("-a", options.arguments);
+        }
+        if (options.description) {
+            const description = getDescription(options.description, true)
+                // escape single quotes
+                .replace(/'/g, "\\'");
+            cmd.push("-d", `'${description}'`);
+        }
+        return cmd.join(" ");
+    }
+    getCompletionCommand(cmd, arg) {
+        const type = cmd.getType(arg.type);
+        if (type && type.handler instanceof FileType) {
+            return `'(__fish_complete_path)'`;
+        }
+        return `'(${this.cmd.getName()} completions complete ${arg.action + " " + getCompletionsPath(cmd)})'`;
+    }
+}
+function getCommandFnNames(cmd, cmds = []) {
+    cmds.push(`__${replaceSpecialChars(cmd.getPath())}`);
+    cmd.getCommands(false).forEach((command) => {
+        getCommandFnNames(command, cmds);
+    });
+    return cmds;
+}
+function getCompletionsPath(command) {
+    return command.getPath()
+        .split(" ")
+        .slice(1)
+        .join(" ");
+}
+function replaceSpecialChars(str) {
+    return str.replace(/[^a-zA-Z0-9]/g, "_");
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/completions/_zsh_completions_generator.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "../command.js";
+/** Generates zsh completions script. */
+export declare class ZshCompletionsGenerator {
+    protected cmd: Command;
+    private actions;
+    /** Generates zsh completions script for given command. */
+    static generate(cmd: Command): string;
+    private constructor();
+    /** Generates zsh completions code. */
+    private generate;
+    /** Generates zsh completions method for given command and child commands. */
+    private generateCompletions;
+    private generateCommandCompletions;
+    private generateSubCommandCompletions;
+    private generateArgumentCompletions;
+    private generateOptions;
+    private generateOption;
+    private getFileCompletions;
+    private addAction;
+    private generateActions;
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/completions/_zsh_completions_generator.js

@@ -0,0 +1,285 @@
+import { getDescription } from "../_utils.js";
+import { FileType } from "../types/file.js";
+/** Generates zsh completions script. */
+export class ZshCompletionsGenerator {
+    /** Generates zsh completions script for given command. */
+    static generate(cmd) {
+        return new ZshCompletionsGenerator(cmd).generate();
+    }
+    constructor(cmd) {
+        Object.defineProperty(this, "cmd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cmd
+        });
+        Object.defineProperty(this, "actions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /** Generates zsh completions code. */
+    generate() {
+        const path = this.cmd.getPath();
+        const name = this.cmd.getName();
+        const version = this.cmd.getVersion()
+            ? ` v${this.cmd.getVersion()}`
+            : "";
+        return `#!/usr/bin/env zsh
+# zsh completion support for ${path}${version}
+
+autoload -U is-at-least
+
+# shellcheck disable=SC2154
+(( $+functions[__${replaceSpecialChars(name)}_complete] )) ||
+function __${replaceSpecialChars(name)}_complete {
+  local name="$1"; shift
+  local action="$1"; shift
+  integer ret=1
+  local -a values
+  local expl lines
+  _tags "$name"
+  while _tags; do
+    if _requested "$name"; then
+      # shellcheck disable=SC2034
+      lines="$(${name} completions complete "\${action}" "\${@}")"
+      values=("\${(ps:\\n:)lines}")
+      if (( \${#values[@]} )); then
+        while _next_label "$name" expl "$action"; do
+          compadd -S '' "\${expl[@]}" "\${values[@]}"
+        done
+      fi
+    fi
+  done
+}
+
+${this.generateCompletions(this.cmd).trim()}
+
+# _${replaceSpecialChars(path)} "\${@}"
+
+compdef _${replaceSpecialChars(path)} ${path}`;
+    }
+    /** Generates zsh completions method for given command and child commands. */
+    generateCompletions(command, path = "") {
+        if (!command.hasCommands(false) && !command.hasOptions(false) &&
+            !command.hasArguments()) {
+            return "";
+        }
+        path = (path ? path + " " : "") + command.getName();
+        return `# shellcheck disable=SC2154
+(( $+functions[_${replaceSpecialChars(path)}] )) ||
+function _${replaceSpecialChars(path)}() {` +
+            (!command.getParent()
+                ? `
+  local state`
+                : "") +
+            this.generateCommandCompletions(command, path) +
+            this.generateSubCommandCompletions(command, path) +
+            this.generateArgumentCompletions(command, path) +
+            this.generateActions(command) +
+            `\n}\n\n` +
+            command.getCommands(false)
+                .filter((subCommand) => subCommand !== command)
+                .map((subCommand) => this.generateCompletions(subCommand, path))
+                .join("");
+    }
+    generateCommandCompletions(command, path) {
+        const commands = command.getCommands(false);
+        let completions = commands
+            .map((subCommand) => `'${subCommand.getName()}:${subCommand.getShortDescription()
+            // escape single quotes
+            .replace(/'/g, "'\"'\"'")}'`)
+            .join("\n      ");
+        if (completions) {
+            completions = `
+    local -a commands
+    # shellcheck disable=SC2034
+    commands=(
+      ${completions}
+    )
+    _describe 'command' commands`;
+        }
+        // only complete first argument, rest arguments are completed with _arguments.
+        if (command.hasArguments()) {
+            const completionsPath = path.split(" ").slice(1).join(" ");
+            const arg = command.getArguments()[0];
+            const action = this.addAction(arg, completionsPath);
+            if (action && command.getCompletion(arg.action)) {
+                completions += `\n    __${replaceSpecialChars(this.cmd.getName())}_complete ${action.arg.name} ${action.arg.action} ${action.cmd}`;
+            }
+        }
+        if (completions) {
+            completions = `\n\n  function _commands() {${completions}\n  }`;
+        }
+        return completions;
+    }
+    generateSubCommandCompletions(command, path) {
+        if (command.hasCommands(false)) {
+            const actions = command
+                .getCommands(false)
+                .map((command) => `${command.getName()}) _${replaceSpecialChars(path + " " + command.getName())} ;;`)
+                .join("\n      ");
+            return `\n
+  function _command_args() {
+    case "\${words[1]}" in\n      ${actions}\n    esac
+  }`;
+        }
+        return "";
+    }
+    generateArgumentCompletions(command, path) {
+        /* clear actions from previously parsed command. */
+        this.actions.clear();
+        const options = this.generateOptions(command, path);
+        let argIndex = 0;
+        // @TODO: add stop early option: -A "-*"
+        // http://zsh.sourceforge.net/Doc/Release/Completion-System.html
+        let argsCommand = "\n\n  _arguments -w -s -S -C";
+        if (command.hasOptions()) {
+            argsCommand += ` \\\n    ${options.join(" \\\n    ")}`;
+        }
+        if (command.hasCommands(false) || (command.getArguments()
+            .filter((arg) => command.getCompletion(arg.action)).length)) {
+            argsCommand += ` \\\n    '${++argIndex}:command:_commands'`;
+        }
+        if (command.hasArguments() || command.hasCommands(false)) {
+            const args = [];
+            // first argument is completed together with commands.
+            for (const arg of command.getArguments().slice(1)) {
+                const type = command.getType(arg.type);
+                if (type && type.handler instanceof FileType) {
+                    const fileCompletions = this.getFileCompletions(type);
+                    if (arg.variadic) {
+                        argIndex++;
+                        for (let i = 0; i < 5; i++) {
+                            args.push(`${argIndex + i}${arg.optionalValue ? "::" : ":"}${arg.name}:${fileCompletions}`);
+                        }
+                    }
+                    else {
+                        args.push(`${++argIndex}${arg.optionalValue ? "::" : ":"}${arg.name}:${fileCompletions}`);
+                    }
+                }
+                else {
+                    const completionsPath = path.split(" ").slice(1).join(" ");
+                    const action = this.addAction(arg, completionsPath);
+                    args.push(`${++argIndex}${arg.optionalValue ? "::" : ":"}${arg.name}:->${action.name}`);
+                }
+            }
+            argsCommand += args.map((arg) => `\\\n    '${arg}'`).join("");
+            if (command.hasCommands(false)) {
+                argsCommand += ` \\\n    '*::sub command:->command_args'`;
+            }
+        }
+        return argsCommand;
+    }
+    generateOptions(command, path) {
+        const options = [];
+        const cmdArgs = path.split(" ");
+        const _baseName = cmdArgs.shift();
+        const completionsPath = cmdArgs.join(" ");
+        const excludedFlags = command.getOptions(false)
+            .map((option) => option.standalone ? option.flags : false)
+            .flat()
+            .filter((flag) => typeof flag === "string");
+        for (const option of command.getOptions(false)) {
+            options.push(this.generateOption(command, option, completionsPath, excludedFlags));
+        }
+        return options;
+    }
+    generateOption(command, option, completionsPath, excludedOptions) {
+        let args = "";
+        for (const arg of option.args) {
+            const type = command.getType(arg.type);
+            const optionalValue = arg.optionalValue ? "::" : ":";
+            if (type && type.handler instanceof FileType) {
+                const fileCompletions = this.getFileCompletions(type);
+                args += `${optionalValue}${arg.name}:${fileCompletions}`;
+            }
+            else {
+                const action = this.addAction(arg, completionsPath);
+                args += `${optionalValue}${arg.name}:->${action.name}`;
+            }
+        }
+        const description = getDescription(option.description, true)
+            // escape brackets and quotes
+            .replace(/\[/g, "\\[")
+            .replace(/]/g, "\\]")
+            .replace(/"/g, '\\"')
+            .replace(/'/g, "'\"'\"'");
+        const collect = option.collect ? "*" : "";
+        const equalsSign = option.equalsSign ? "=" : "";
+        const flags = option.flags.map((flag) => `${flag}${equalsSign}`);
+        let result = "";
+        if (option.standalone) {
+            result += "'(- *)'";
+        }
+        else {
+            const excludedFlags = [...excludedOptions];
+            if (option.conflicts?.length) {
+                excludedFlags.push(...option.conflicts.map((opt) => "--" + opt.replace(/^--/, "")));
+            }
+            if (!option.collect) {
+                excludedFlags.push(...option.flags);
+            }
+            if (excludedFlags.length) {
+                result += `'(${excludedFlags.join(" ")})'`;
+            }
+        }
+        if (collect || flags.length > 1) {
+            result += `{${collect}${flags.join(",")}}`;
+        }
+        else {
+            result += `${flags.join(",")}`;
+        }
+        return `${result}'[${description}]${args}'`;
+    }
+    getFileCompletions(type) {
+        if (!(type.handler instanceof FileType)) {
+            return "";
+        }
+        return "_files";
+        // const fileOpts = type.handler.getOptions();
+        // let fileCompletions = "_files";
+        // if (fileOpts.dirsOnly) {
+        //   fileCompletions += " -/";
+        // }
+        // if (fileOpts.pattern) {
+        //   fileCompletions += ' -g "' + fileOpts.pattern + '"';
+        // }
+        // if (fileOpts.ignore) {
+        //   fileCompletions += " -F " + fileOpts.ignore;
+        // }
+        // return fileCompletions;
+    }
+    addAction(arg, cmd) {
+        const action = `${arg.name}-${arg.action}`;
+        if (!this.actions.has(action)) {
+            this.actions.set(action, {
+                arg: arg,
+                label: `${arg.name}: ${arg.action}`,
+                name: action,
+                cmd,
+            });
+        }
+        return this.actions.get(action);
+    }
+    generateActions(command) {
+        let actions = [];
+        if (this.actions.size) {
+            actions = Array
+                .from(this.actions)
+                .map(([name, action]) => `${name}) __${replaceSpecialChars(this.cmd.getName())}_complete ${action.arg.name} ${action.arg.action} ${action.cmd} ;;`);
+        }
+        if (command.hasCommands(false)) {
+            actions.unshift(`command_args) _command_args ;;`);
+        }
+        if (actions.length) {
+            return `\n\n  case "$state" in\n    ${actions.join("\n    ")}\n  esac`;
+        }
+        return "";
+    }
+}
+function replaceSpecialChars(str) {
+    return str.replace(/[^a-zA-Z0-9]/g, "_");
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/completions/bash.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "../command.js";
+/** Generates bash completions script. */
+export declare class BashCompletionsCommand extends Command {
+    #private;
+    constructor(cmd?: Command);
+}