package console

Import Path
	github.com/reeflective/console (on go.dev)

Dependency Relation
	imports 24 packages, and imported by one package



Package-Level Type Names (total 10)


	/* sort by:  |  */
	
		Commands is a simple function a root cobra command containing an arbitrary tree
		of subcommands, along with any behavior parameters normally found in cobra.
		This function is used by each menu to produce a new, blank command tree after
		each execution run, as well as each command completion invocation.

		
			func (*Menu).SetCommands(cmds Commands)


	
		Console is an integrated console application instance.

		
			
				Characters that are used to determine whether an input line was empty. If a line is not entirely
				made up by any of these characters, then it is not considered empty. The default characters
				are ' ' and '\t'.

			
				Leave an empty line after executing the command.
				Note that if you also want this newline to be used when logging messages
				with TransientPrintf(), Printf() calls, you should leave this to false,
				and add a leading newline to your prompt instead: the readline shell will
				know how to handle it in all situations.

			
				Leave an empty line before executing the command.

			
				Leave empty lines with NewlineBefore and NewlineAfter, even if the provided input was empty.
				Empty characters are defined as any number of spaces and tabs. The 'empty' character set
				can be changed by modifying Console.EmptyChars
				This field is false by default.

			
				PostCmdRunHooks are run after the target cobra command has been executed.
				These hooks are distinct from the cobra.PreRun() or OnFinalize hooks,
				and might be used in combination with them.

			
				PreCmdRunHooks - Once the user has entered a command, but before executing
				the target command, the console will execute every function in this list.
				These hooks are distinct from the cobra.PreRun() or OnInitialize hooks,
				and might be used in combination with them.

			
				PreCmdRunLineHooks - Same as PreCmdRunHooks, but will have an effect on the
				input line being ultimately provided to the command parser. This might
				be used by people who want to apply supplemental, specific processing
				on the command input line.

			
				PreReadlineHooks - All the functions in this list will be executed,
				in their respective orders, before the console starts reading
				any user input (ie, before redrawing the prompt).

		
			
				ActiveMenu - Return the currently used console menu.

			
				HideCommands - Commands, in addition to their menus, can be shown/hidden based
				on a filter string. For example, some commands applying to a Windows host might
				be scattered around different groups, but, having all the filter "windows".
				If "windows" is used as the argument here, all windows commands for the current
				menu are subsequently hidden, until ShowCommands("windows") is called.

			
				Menu returns one of the console menus by name, or nil if no menu is found.

			
				NewMenu - Create a new command menu, to which the user
				can attach any number of commands (with any nesting), as
				well as some specific items like history sources, prompt
				configurations, sets of expanded variables, and others.

			
				Printf prints a string message (a log, or more broadly, an asynchronous event)
				below the current prompt. The message is printed regardless of the current menu.
				
				If this function is called while a command is running, the console will simply print the log
				below the line, and will not print the prompt. In any other case this function works normally.

			
				SetDefaultCommandHighlight allows the user to change the highlight color for a command in the default syntax
				highlighter using an ansi code.
				This action has no effect if a custom syntax highlighter for the shell is set.
				By default, the highlight code is green ("\x1b[32m").

			
				SetDefaultFlagHighlight allows the user to change the highlight color for a flag in the default syntax
				highlighter using an ansi color code.
				This action has no effect if a custom syntax highlighter for the shell is set.
				By default, the highlight code is grey ("\x1b[38;05;244m").

			
				SetPrintLogo - Sets the function that will be called to print the logo.

			
				Shell returns the console readline shell instance, so that the user can
				further configure it or use some of its API for lower-level stuff.

			
				ShowCommands - Commands, in addition to their menus, can be shown/hidden based
				on a filter string. For example, some commands applying to a Windows host might
				be scattered around different groups, but, having all the filter "windows".
				Use this function if you have previously called HideCommands("filter") and want
				these commands to be available back under their respective menu.

			
				Start - Start the console application (readline loop). Blocking.
				The error returned will always be an error that the console
				application does not understand or cannot handle.

			
				StartContext is like console.Start(). with a user-provided context.

			
				SwitchMenu - Given a name, the console switches its command menu:
				The next time the console rebinds all of its commands, it will only bind those
				that belong to this new menu. If the menu is invalid, i.e that no commands
				are bound to this menu name, the current menu is kept.

			
				SystemEditor - This function is a renamed-reexport of the underlying readline.StartEditorWithBuffer
				function, which enables you to conveniently edit files/buffers from within the console application.
				Naturally, the function will block until the editor is exited, and the updated buffer is returned.
				The filename parameter can be used to pass a specific filename.ext pattern, which might be useful
				if the editor has builtin filetype plugin functionality.

			
				TransientPrintf prints a string message (a log, or more broadly, an asynchronous event)
				without bothering the user, displaying the message and "pushing" the prompt below it.
				The message is printed regardless of the current menu.
				
				If this function is called while a command is running, the console will simply print the log
				below the line, and will not print the prompt. In any other case this function works normally.

		
			func New(app string) *Console


	
		Err is the Console base error type.
		
		All errors that bubble up to the error handler should be
		wrapped in this error type.
		
		There are more concrete error types that wrap this one defined below
		this allow for easy use of errors.As.

		
			
				Error returns the error message with an optional
				message prefix.

			
				Unwrap implements the errors Unwrap interface.

		
			 Err : error
			 Err : golang.org/x/xerrors.Wrapper


	
		ErrorHandler is a function that handles errors.
		
		The handler can choose not to bubble up the error by returning nil.


	
		ExecutionError is an error that occurs during the execution phase.

		
			Err Err
		
			
				Error returns the error message with an optional
				message prefix.

			
				Unwrap implements the errors Unwrap interface.

		
			 ExecutionError : error
			 ExecutionError : golang.org/x/xerrors.Wrapper


	
		LineHookError is an error that occurs during the line hook phase.

		
			Err Err
		
			
				Error returns the error message with an optional
				message prefix.

			
				Unwrap implements the errors Unwrap interface.

		
			 LineHookError : error
			 LineHookError : golang.org/x/xerrors.Wrapper


	
		Menu - A menu is a simple way to seggregate commands based on
		the environment to which they belong. For instance, when using a menu
		specific to some host/user, or domain of activity, commands will vary.

		
			
				The root cobra command/parser is the one returned by the handler provided
				through the `menu.SetCommands()` function. This command is thus renewed after
				each command invocation/execution.
				You can still use it as you want, for instance to introspect the current command
				state of your menu.

			
				Aliases is an array of aliases that can be used instead of the first word in Use.

			
				Annotations are key/value pairs that can be used by applications to identify or
				group commands or set special options.

			
				ArgAliases is List of aliases for ValidArgs.
				These are not suggested to the user in the shell completion,
				but accepted if entered manually.

			
				Expected arguments

			
				BashCompletionFunction is custom bash functions used by the legacy bash autocompletion generator.
				For portability with other shells, it is recommended to instead use ValidArgsFunction

			
				CompletionOptions is a set of options to control the handling of shell completion

			
				Deprecated defines, if this command is deprecated and should print this string when used.

			
				DisableAutoGenTag defines, if gen tag ("Auto generated by spf13/cobra...")
				will be printed by generating docs for this command.

			
				DisableFlagParsing disables the flag parsing.
				If this is true all flags will be passed to the command as arguments.

			
				DisableFlagsInUseLine will disable the addition of [flags] to the usage
				line of a command when printing help or generating docs

			
				DisableSuggestions disables the suggestions based on Levenshtein distance
				that go along with 'unknown command' messages.

			
				Example is examples of how to use the command.

			
				FParseErrWhitelist flag parse errors to be ignored

			
				The group id under which this subcommand is grouped in the 'help' output of its parent.

			
				Hidden defines, if this command is hidden and should NOT show up in the list of available commands.

			
				Long is the long message shown in the 'help <this-command>' output.

			
				PersistentPostRun: children of this command will inherit and execute after PostRun.

			
				PersistentPostRunE: PersistentPostRun but returns an error.

			
				The *Run functions are executed in the following order:
				  * PersistentPreRun()
				  * PreRun()
				  * Run()
				  * PostRun()
				  * PersistentPostRun()
				All functions get the same args, the arguments after the command name.
				The *PreRun and *PostRun functions will only be executed if the Run function of the current
				command has been declared.
				
				PersistentPreRun: children of this command will inherit and execute.

			
				PersistentPreRunE: PersistentPreRun but returns an error.

			
				PostRun: run after the Run command.

			
				PostRunE: PostRun but returns an error.

			
				PreRun: children of this command will not inherit.

			
				PreRunE: PreRun but returns an error.

			
				Run: Typically the actual work function. Most commands will only implement this.

			
				RunE: Run but returns an error.

			
				Short is the short description shown in the 'help' output.

			
				SilenceErrors is an option to quiet errors down stream.

			
				SilenceUsage is an option to silence usage when an error occurs.

			
				SuggestFor is an array of command names for which this command will be suggested -
				similar to aliases but only suggests.

			
				SuggestionsMinimumDistance defines minimum levenshtein distance to display suggestions.
				Must be > 0.

			
				TraverseChildren parses flags on all parents before executing child command.

			
				Use is the one-line usage message.
				Recommended syntax is as follows:
				  [ ] identifies an optional argument. Arguments that are not enclosed in brackets are required.
				  ... indicates that you can specify multiple values for the previous argument.
				  |   indicates mutually exclusive information. You can use the argument to the left of the separator or the
				      argument to the right of the separator. You cannot use both arguments in a single use of the command.
				  { } delimits a set of mutually exclusive arguments when one of the arguments is required. If the arguments are
				      optional, they are enclosed in brackets ([ ]).
				Example: add [-F file | -D dir]... [-f format] profile

			
				ValidArgs is list of all valid non-flag arguments that are accepted in shell completions

			
				ValidArgsFunction is an optional function that provides valid non-flag arguments for shell completion.
				It is a dynamic version of using ValidArgs.
				Only one of ValidArgs and ValidArgsFunction can be used for a command.

			
				Version defines the version for this command. If this value is non-empty and the command does not
				define a "version" flag, a "version" boolean flag will be added to the command and, if specified,
				will print content of the "Version" variable. A shorthand "v" flag will also be added if the
				command does not define one.

			
				ErrorHandler is called when an error is encountered.
				
				If not set, the error is printed to the console on os.Stderr.

		
			
				ActiveFiltersFor returns all the active menu filters that a given command
				does not declare as compliant with (added with console.Hide/ShowCommand()).

			
				AddCommand adds one or more commands to this parent command.

			
				AddGroup adds one or more command groups to this parent command.

			
				AddHistorySource adds a source of history commands that will
				be accessible to the shell when the menu is active.

			
				AddHistorySourceFile adds a new source of history populated from and writing
				to the specified "filepath" parameter. On the first call to this function,
				the default in-memory history source is removed.

			
				AddInterrupt registers a handler to run when the console receives
				a given interrupt error from the underlying readline shell.
				
				On most systems, the following errors will be returned with keypresses:
				- Linux/MacOS/Windows : Ctrl-C will return os.Interrupt.
				
				Many will want to use this to switch menus. Note that these interrupt errors only
				work when the console is NOT currently executing a command, only when reading input.

			
				AllChildCommandsHaveGroup returns if all subcommands are assigned to a group

			
				ArgsLenAtDash will return the length of c.Flags().Args at the moment
				when a -- was found during args parsing.

			
				CalledAs returns the command name or alias that was used to invoke
				this command or an empty string if the command has not been called.

			
				CheckIsAvailable checks if a target command is marked as filtered
				by the console application registered/and or active filters (added
				with console.Hide/ShowCommand()).
				If filtered, returns a template-formatted error message showing the
				list of incompatible filters. If not filtered, no error is returned.

			
				CommandPath returns the full path to this command.

			
				CommandPathPadding return padding for the command path.

			
				Commands returns a sorted slice of child commands.

			
				ContainsGroup return if groupID exists in the list of command groups.

			
				Context returns underlying command context. If command was executed
				with ExecuteContext or the context was set with SetContext, the
				previously set context will be returned. Otherwise, nil is returned.
				
				Notice that a call to Execute and ExecuteC will replace a nil context of
				a command with a context.Background, so a background context will be
				returned by Context after one of these functions has been called.

			
				DebugFlags used to determine which flags have been assigned to which commands
				and which persist.

			
				DelInterrupt removes one or more interrupt handlers from the menu registered ones.
				If no error is passed as argument, all handlers are removed.

			
				DeleteHistorySource removes a history source from the menu.
				This normally should only be used in two cases:
				- You want to replace the default in-memory history with another one.
				- You want to replace one of your history sources for some reason.

			
				ErrOrStderr returns output to stderr

			
				ErrPrefix return error message prefix for the command

			
				Execute uses the args (os.Args[1:] by default)
				and run through the command tree finding appropriate matches
				for commands and then corresponding flags.

			
				ExecuteC executes the command.

			
				ExecuteContext is the same as Execute(), but sets the ctx on the command.
				Retrieve ctx by calling cmd.Context() inside your *Run lifecycle or ValidArgs
				functions.

			
				ExecuteContextC is the same as ExecuteC(), but sets the ctx on the command.
				Retrieve ctx by calling cmd.Context() inside your *Run lifecycle or ValidArgs
				functions.

			
				Find the target command given the args and command tree
				Meant to be run on the highest node. Only searches down.

			
				Flag climbs up the command tree looking for matching flag.

			
				FlagErrorFunc returns either the function set by SetFlagErrorFunc for this
				command or a parent, or it returns a function which returns the original
				error.

			
				Flags returns the complete FlagSet that applies
				to this command (local and persistent declared here and by all parents).

			
				GenBashCompletion generates bash completion file and writes to the passed writer.

			
				GenBashCompletionFile generates bash completion file.

			
				GenBashCompletionFileV2 generates Bash completion version 2.

			
				GenBashCompletionV2 generates Bash completion file version 2
				and writes it to the passed writer.

			
				GenFishCompletion generates fish completion file and writes to the passed writer.

			
				GenFishCompletionFile generates fish completion file.

			
				GenPowerShellCompletion generates powershell completion file without descriptions
				and writes it to the passed writer.

			
				GenPowerShellCompletionFile generates powershell completion file without descriptions.

			
				GenPowerShellCompletionFileWithDesc generates powershell completion file with descriptions.

			
				GenPowerShellCompletionWithDesc generates powershell completion file with descriptions
				and writes it to the passed writer.

			
				GenZshCompletion generates zsh completion file including descriptions
				and writes it to the passed writer.

			
				GenZshCompletionFile generates zsh completion file including descriptions.

			
				GenZshCompletionFileNoDesc generates zsh completion file without descriptions.

			
				GenZshCompletionNoDesc generates zsh completion file without descriptions
				and writes it to the passed writer.

			
				GetFlagCompletionFunc returns the completion function for the given flag of the command, if available.

			
				GlobalNormalizationFunc returns the global normalization function or nil if it doesn't exist.

			
				Groups returns a slice of child command groups.

			
				HasAlias determines if a given string is an alias of the command.

			
				HasAvailableFlags checks if the command contains any flags (local plus persistent from the entire
				structure) which are not hidden or deprecated.

			
				HasAvailableInheritedFlags checks if the command has flags inherited from its parent command which are
				not hidden or deprecated.

			
				HasAvailableLocalFlags checks if the command has flags specifically declared locally which are not hidden
				or deprecated.

			
				HasAvailablePersistentFlags checks if the command contains persistent flags which are not hidden or deprecated.

			
				HasAvailableSubCommands determines if a command has available sub commands that
				need to be shown in the usage/help default template under 'available commands'.

			
				HasExample determines if the command has example.

			
				HasFlags checks if the command contains any flags (local plus persistent from the entire structure).

			
				HasHelpSubCommands determines if a command has any available 'help' sub commands
				that need to be shown in the usage/help default template under 'additional help
				topics'.

			
				HasInheritedFlags checks if the command has flags inherited from its parent command.

			
				HasLocalFlags checks if the command has flags specifically declared locally.

			
				HasParent determines if the command is a child command.

			
				HasPersistentFlags checks if the command contains persistent flags.

			
				HasSubCommands determines if the command has children commands.

			
				Help puts out the help for the command.
				Used when a user calls help [command].
				Can be defined by user by overriding HelpFunc.

			
				HelpFunc returns either the function set by SetHelpFunc for this command
				or a parent, or it returns a function with default help behavior.

			
				HelpTemplate return help template for the command.

			
				InOrStdin returns input to stdin

			
				InheritedFlags returns all flags which were inherited from parent commands.
				This function does not modify the flags of the current command, it's purpose is to return the current state.

			
				InitDefaultCompletionCmd adds a default 'completion' command to c.
				This function will do nothing if any of the following is true:
				1- the feature has been explicitly disabled by the program,
				2- c has no subcommands (to avoid creating one),
				3- c already has a 'completion' command provided by the program.

			
				InitDefaultHelpCmd adds default help command to c.
				It is called automatically by executing the c or by calling help and usage.
				If c already has help command or c has no subcommands, it will do nothing.

			
				InitDefaultHelpFlag adds default help flag to c.
				It is called automatically by executing the c or by calling help and usage.
				If c already has help flag, it will do nothing.

			
				InitDefaultVersionFlag adds default version flag to c.
				It is called automatically by executing the c.
				If c already has a version flag, it will do nothing.
				If c.Version is empty, it will do nothing.

			
				IsAdditionalHelpTopicCommand determines if a command is an additional
				help topic command; additional help topic command is determined by the
				fact that it is NOT runnable/hidden/deprecated, and has no sub commands that
				are runnable/hidden/deprecated.
				Concrete example: https://github.com/spf13/cobra/issues/393#issuecomment-282741924.

			
				IsAvailableCommand determines if a command is available as a non-help command
				(this includes all non deprecated/hidden commands).

			
				LocalFlags returns the local FlagSet specifically set in the current command.
				This function does not modify the flags of the current command, it's purpose is to return the current state.

			
				LocalNonPersistentFlags are flags specific to this command which will NOT persist to subcommands.
				This function does not modify the flags of the current command, it's purpose is to return the current state.

			
				MarkFlagCustom adds the BashCompCustom annotation to the named flag, if it exists.
				The bash completion script will call the bash function f for the flag.
				
				This will only work for bash completion.
				It is recommended to instead use c.RegisterFlagCompletionFunc(...) which allows
				to register a Go function which will work across all shells.

			
				MarkFlagDirname instructs the various shell completion implementations to
				limit completions for the named flag to directory names.

			
				MarkFlagFilename instructs the various shell completion implementations to
				limit completions for the named flag to the specified file extensions.

			
				MarkFlagRequired instructs the various shell completion implementations to
				prioritize the named flag when performing completion,
				and causes your command to report an error if invoked without the flag.

			
				MarkFlagsMutuallyExclusive marks the given flags with annotations so that Cobra errors
				if the command is invoked with more than one flag from the given set of flags.

			
				MarkFlagsOneRequired marks the given flags with annotations so that Cobra errors
				if the command is invoked without at least one flag from the given set of flags.

			
				MarkFlagsRequiredTogether marks the given flags with annotations so that Cobra errors
				if the command is invoked with a subset (but not all) of the given flags.

			
				MarkPersistentFlagDirname instructs the various shell completion
				implementations to limit completions for the named persistent flag to
				directory names.

			
				MarkPersistentFlagFilename instructs the various shell completion
				implementations to limit completions for the named persistent flag to the
				specified file extensions.

			
				MarkPersistentFlagRequired instructs the various shell completion implementations to
				prioritize the named persistent flag when performing completion,
				and causes your command to report an error if invoked without the flag.

			
				MarkZshCompPositionalArgumentFile only worked for zsh and its behavior was
				not consistent with Bash completion. It has therefore been disabled.
				Instead, when no other completion is specified, file completion is done by
				default for every argument. One can disable file completion on a per-argument
				basis by using ValidArgsFunction and ShellCompDirectiveNoFileComp.
				To achieve file extension filtering, one can use ValidArgsFunction and
				ShellCompDirectiveFilterFileExt.
				
				Deprecated

			
				MarkZshCompPositionalArgumentWords only worked for zsh. It has therefore
				been disabled.
				To achieve the same behavior across all shells, one can use
				ValidArgs (for the first argument only) or ValidArgsFunction for
				any argument (can include the first one also).
				
				Deprecated

			
				Name returns the name of this menu.

			
				NameAndAliases returns a list of the command name and all aliases

			
				NamePadding returns padding for the name.

			
				NonInheritedFlags returns all flags which were not inherited from parent commands.
				This function does not modify the flags of the current command, it's purpose is to return the current state.

			
				OutOrStderr returns output to stderr

			
				OutOrStdout returns output to stdout.

			
				Parent returns a commands parent command.

			
				ParseFlags parses persistent flag tree and local flags.

			
				PersistentFlags returns the persistent FlagSet specifically set in the current command.

			
				Print is a convenience method to Print to the defined output, fallback to Stderr if not set.

			
				PrintErr is a convenience method to Print to the defined Err output, fallback to Stderr if not set.

			
				PrintErrf is a convenience method to Printf to the defined Err output, fallback to Stderr if not set.

			
				PrintErrln is a convenience method to Println to the defined Err output, fallback to Stderr if not set.

			
				Printf prints a message to the console, but only if the current menu
				is active. If the menu is not active, the message is buffered and will
				be printed the next time the menu is active.
				
				Unlike TransientPrintf, this function will not print the message above
				the current prompt, but will instead print it below it.
				
				If this function is called while a command is running, the console
				will simply print the log below the current line, and will not print
				the prompt. In any other case this function will work normally.

			
				Println is a convenience method to Println to the defined output, fallback to Stderr if not set.

			
				Prompt returns the prompt object for this menu.

			
				RegisterFlagCompletionFunc should be called to register a function to provide completion for a flag.

			
				RemoveCommand removes one or more commands from a parent command.

			
				ResetCommands delete parent, subcommand and help command from c.

			
				ResetFlags deletes all flags from command.

			
				Root finds root command.

			
				RunCommandArgs is a convenience function to run a command line in a given menu.
				After running, the menu's commands are reset, and the prompts reloaded, therefore
				mostly mimicking the behavior that is the one of the normal readline/run/readline
				workflow.
				Although state segregation is a priority for this library to be ensured as much
				as possible, you should be cautious when using this function to run commands.

			
				RunCommandLine is the equivalent of menu.RunCommandArgs(), but accepts
				an unsplit command line to execute. This line is split and processed in
				*sh-compliant form, identically to how lines are in normal console usage.

			
				Runnable determines if the command is itself runnable.

			
				SetArgs sets arguments for the command. It is set to os.Args[1:] by default, if desired, can be overridden
				particularly useful when testing.

			
				SetCommands requires a function returning a tree of cobra commands to be used.

			
				SetCompletionCommandGroupID sets the group id of the completion command.

			
				SetContext sets context for the command. This context will be overwritten by
				Command.ExecuteContext or Command.ExecuteContextC.

			
				SetErr sets the destination for error messages.
				If newErr is nil, os.Stderr is used.

			
				SetErrFilteredCommandTemplate sets the error template to be used
				when a called command can't be executed because it's mark filtered.

			
				SetErrPrefix sets error message prefix to be used. Application can use it to set custom prefix.

			
				SetFlagErrorFunc sets a function to generate an error when flag parsing
				fails.

			
				SetGlobalNormalizationFunc sets a normalization function to all flag sets and also to child commands.
				The user should not have a cyclic dependency on commands.

			
				SetHelpCommand sets help command.

			
				SetHelpCommandGroupID sets the group id of the help command.

			
				SetHelpFunc sets help function. Can be defined by Application.

			
				SetHelpTemplate sets help template to be used. Application can use it to set custom template.

			
				SetIn sets the source for input data
				If newIn is nil, os.Stdin is used.

			
				SetOut sets the destination for usage messages.
				If newOut is nil, os.Stdout is used.

			
				SetOutput sets the destination for usage and error messages.
				If output is nil, os.Stderr is used.
				Deprecated: Use SetOut and/or SetErr instead

			
				SetUsageFunc sets usage function. Usage can be defined by application.

			
				SetUsageTemplate sets usage template. Can be defined by Application.

			
				SetVersionTemplate sets version template to be used. Application can use it to set custom template.

			
				SuggestionsFor provides suggestions for the typedName.

			
				TransientPrintf prints a message to the console, but only if the current
				menu is active. If the menu is not active, the message is buffered and will
				be printed the next time the menu is active.
				
				The message is printed as a transient message, meaning that it will be
				printed above the current prompt, effectively "pushing" the prompt down.
				
				If this function is called while a command is running, the console
				will simply print the log below the current line, and will not print
				the prompt. In any other case this function will work normally.

			
				Traverse the command tree to find the command, and parse args for
				each parent.

			
				Usage puts out the usage for the command.
				Used when a user provides invalid input.
				Can be defined by user by overriding UsageFunc.

			
				UsageFunc returns either the function set by SetUsageFunc for this command
				or a parent, or it returns a default usage function.

			
				UsagePadding return padding for the usage.

			
				UsageString returns usage string.

			
				UsageTemplate returns usage template for the command.

			
				UseLine puts out the full usage for a given command (including parents).

			( Menu) ValidateArgs(args []string) error
			
				ValidateFlagGroups validates the mutuallyExclusive/oneRequired/requiredAsGroup logic and returns the
				first error encountered.

			
				ValidateRequiredFlags validates all required flags are present and returns an error otherwise

			
				VersionTemplate return version template for the command.

			
				VisitParents visits all parents of the command and invokes fn on each parent.

		
			 Menu : github.com/go-sql-driver/mysql.Logger
			*Menu : github.com/polarsignals/frostdb/query/logicalplan.Named
		
			func (*Console).ActiveMenu() *Menu
			func (*Console).Menu(name string) *Menu
			func (*Console).NewMenu(name string) *Menu


	
		ParseError is an error that occurs during the parsing phase.

		
			Err Err
		
			
				Error returns the error message with an optional
				message prefix.

			
				Unwrap implements the errors Unwrap interface.

		
			 ParseError : error
			 ParseError : golang.org/x/xerrors.Wrapper


	
		PreReadError is an error that occurs during the pre-read phase.

		
			Err Err
		
			
				Error returns the error message with an optional
				message prefix.

			
				Unwrap implements the errors Unwrap interface.

		
			 PreReadError : error
			 PreReadError : golang.org/x/xerrors.Wrapper


	
		Prompt - A prompt is a set of functions that return the strings to print
		for each prompt type. The console will call these functions to retrieve
		the prompt strings to print. Each menu has its own prompt.

		
			
				// Primary is the main prompt.

			
				// Right is the prompt printed on the right side of the screen.

			
				// Secondary is the prompt used when the user is typing a multi-line command.

			
				// Tooltip is used to hint on the root command, replacing right prompts if not empty.

			
				// Transient is used if the console shell is configured to be transient.

		
			func (*Menu).Prompt() *Prompt




Package-Level Functions (only one)


	
		New - Instantiates a new console application, with sane but powerful defaults.
		This instance can then be passed around and used to bind commands, setup additional
		things, print asynchronous messages, or modify various operating parameters on the fly.
		The app parameter is an optional name of the application using this console.




Package-Level Constants (only one)


	
		CommandFilterKey should be used as a key to in a cobra.Annotation map.
		The value will be used as a filter to disable commands when the console
		calls the Filter("name") method on the console.
		The string value will be comma-splitted, with each split being a filter.