# Show the status of the waypoint in a specific namespace
  		 istioctl waypoint status --namespace default`,
		Args: func(cmd *cobra.Command, args []string) error {
			if len(args) != 0 {
				return fmt.Errorf("unknown subcommand %q", args[0])
			}
			return nil
		},
		RunE: func(cmd *cobra.Command, args []string) error {
			kubeClient, err := ctx.CLIClient()
			if err != nil {

        p.map(build_lang, langs)


@app.command()
def update_languages() -> None:
    """
    Update the mkdocs.yml file Languages section including all the available languages.
    """
    update_config()


@app.command()
def serve() -> None:
    """
    A quick server to preview a built site with translations.

    For development, prefer the command live (or just mkdocs serve).

    protected AndXServerMessageBlock ( Configuration config, byte command, String name, ServerMessageBlock andx ) {
        super(config, command, name);
        this.andx = andx;
        if ( andx != null ) {
            this.andxCommand = (byte) andx.getCommand();
        }
    }


    protected AndXServerMessageBlock ( Configuration config, byte command ) {
        this(config, command, null);
    }

    AndXServerMessageBlock() {
    }
    AndXServerMessageBlock( ServerMessageBlock andx ) {
        if (andx != null) {
            this.andx = andx;
            andxCommand = andx.command;
        }
    }

    int getBatchLimit( byte command ) {
        /* the default limit is 0 batched messages before this
         * one, meaning this message cannot be batched.
         */
        return 0;
    }

    /* 

  return 0
}

# runCommand ($@)
# Run custom mc command
runCommand() {
  ${MC} "$@"
  return $?
}

# Try connecting to MinIO instance
{{- if .Values.tls.enabled }}
scheme=https
{{- else }}
scheme=http
{{- end }}
connectToMinio $scheme

{{ if .Values.customCommands }}
# Run custom commands
{{- range .Values.customCommands }}
runCommand {{ .command }}
{{- end }}

    @Override
    protected <T> Callable<T> wrapTask(Callable<T> callable) {
      return new WrappedCallable<T>(callable);
    }

    @Override
    protected Runnable wrapTask(Runnable command) {
      return new WrappedRunnable(command);
    }
  }

  private static final class MockExecutor implements ScheduledExecutorService {
    String lastMethodCalled = "";
    long lastInitialDelay;
    long lastDelay;

}

func optionsCommand(rootCmd *cobra.Command) *cobra.Command {
	retval := &cobra.Command{
		Use:   "options",
		Short: "Displays istioctl global options",
		Args:  cobra.ExactArgs(0),
	}

	retval.SetHelpFunc(func(c *cobra.Command, args []string) {
		c.Printf("The following options can be passed to any command:\n")
		// (Currently the only global options we show are help options)

func Execute(cmd string, args ...string) error {
	log.Debugf("Running command: %s %s", cmd, strings.Join(args, " "))
	externalCommand := exec.Command(cmd, args...)
	stdout := &bytes.Buffer{}
	stderr := &bytes.Buffer{}
	externalCommand.Stdout = stdout
	externalCommand.Stderr = stderr

	err := externalCommand.Run()

	if len(stdout.String()) != 0 {
		log.Debugf("Command output: \n%v", stdout.String())
	}

      Runnable command, long initialDelay, long period, TimeUnit unit) {
    return delegate.scheduleAtFixedRate(wrapTask(command), initialDelay, period, unit);
  }

  @Override
  public final ScheduledFuture<?> scheduleWithFixedDelay(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    return delegate.scheduleWithFixedDelay(wrapTask(command), initialDelay, delay, unit);
  }

     * @return the async
     */
    public boolean isAsync () {
        return this.async;
    }


    /**
     * @param command
     *            the command to set
     */
    @Override
    public final void setCommand ( int command ) {
        this.command = command;
    }


    /**
     * @return the treeId
     */
    public final int getTreeId () {
        return this.treeId;