command

type Autocompletion struct {
	// Suggestions is the set of autocomplete suggestions.
	Suggestions []string
	// SpacelessCompletion indicates that a space should *not* be added (which happens
	// automatically if there is only one completion suggestion).
	SpacelessCompletion bool
}

type BranchUsage struct {
	// Usage is the usage object for the branched node.
	Usage *Usage
}

type Completion struct {
	// Suggestions is the set of autocomplete suggestions.
	Suggestions []string
	// IgnoreFilter indicates whether prefixes that don't match should be filtered out or not.
	IgnoreFilter bool
	// DontComplete indicates whether or not we should fill in partial completions.
	// This is achieved by adding a " " suggestion.
	DontComplete bool
	// CaseInsensitiveSort returns whether or not we should sort irrespective of case.
	CaseInsensitiveSort bool
	// CaseInsensitve is whether or not case should be considered when filtering out suggestions.
	CaseInsensitive bool
	// Distinct is whether or not we should return only distinct suggestions (specifically to prevent duplicates in list arguments).
	// Note: this is only applied for built-in types like `Argument` and `Flag`. To ensure
	// distinctness for custom argument processors, you will need to implement
	// logic in those custom objects yourself.
	Distinct bool
	// SpacelessCompletion indicates that a space should *not* be added (which happens
	// automatically if there is only one completion suggestion).
	SpacelessCompletion bool
	// DeferredCompletion will *execute* another graph before generating the actual
	// completion object.
	DeferredCompletion *DeferredCompletion
}

type Data struct {
	// Values is a map from argument name to the data for that argument.
	Values map[string]interface{}
	// Complexecute indictes whether we are running complexecute logic.
	Complexecute bool
	// OS is the current operating system. It is primarily used to execute
	// run logic in the parent shell (e.g. setting/unsetting environment variables)
	OS OS
}

type DeferredCompletion struct {
	// Graph is the root of a command `Node` graph that will be *execute* (i.e.
	// not completed) before the respective function, `F`, is run. However, the
	// `ExecuteData` generated by executing this graph will be ignored.
	Graph Node
	// F is the function to run after `Graph` has been executed.
	F func(*Completion, *Data) (*Completion, error)
}

type Edge interface {
	// Next fetches the next node in the command graph based on
	// the provided `Input` and `Data`.
	Next(*Input, *Data) (Node, error)
	// UsageNext fetches the next node in the command graph when
	// command graph usage is being constructed. This is separate from
	// the `Next` function because `Next` is input-dependent whereas `UsageNext`
	// receives no input arguments.
	UsageNext(*Input, *Data) (Node, error)
}

type ExecuteData struct {
	// Executable is a list of bash commands to run after all nodes have been processed.
	Executable []string
	// Executor is a set of functions to run after all nodes have been processed.
	Executor []func(Output, *Data) error
	// FunctionWrap is whether or not to wrap the Executable contents
	// in a function. This allows Executable to use things like "return" and "local".
	FunctionWrap bool
}

type Input struct {
	// contains filtered or unexported fields
}

type InputBreaker interface {
	// Break returns whether the input processing should stop.
	Break(string, *Data) bool
	// DiscardBreak returns whether the value responsible for breaking the input shoud be popped or not.
	DiscardBreak(string, *Data) bool
}

type InputTransformer struct {
	// F is the function that will be run on each element in Input.
	F func(Output, *Data, string) ([]string, error)
	// UpToIndexInclusive is the input argument index that F will be run through.
	// This is zero-indexed so default behavior (UpToIndexInclusive: 0) will run
	// on the first argument only. If UpToIndexInclusive is less than zero
	// (or command.UnboundedList), then this will run on all remaining arguments.
	UpToIndexInclusive int
}

type Node interface {
	Processor
	Edge
}

type OS interface {
	// SetEnvVar returns a shell command that sets the environment variable
	// `envVar` to `value`. Environment variable modifications can't and shouldn't
	// be done by os.Setenv because the go CLI executable is run in a sub-shell.
	SetEnvVar(envVar, value string) string

	// UnsetEnvVar returns a shell command that unsets the environment variable
	// `envVar`. Environment variable changes can't and shouldn't be done by
	// os.Unsetenv because the go CLI executable is run in a sub-shell.
	UnsetEnvVar(envVar string) string
}

type Output interface {
	// Writes the provided text to stdout.
	Stdout(string)
	// Writes the provided text to stderr and returns an error with the same message.
	Stderr(string) error
	// Writes a formatted string to stdout.
	Stdoutf(string, ...interface{})
	// Writes a formatted string to stderr and returns an error with the same message.
	Stderrf(string, ...interface{}) error
	// Writes interfaces to stdout and appends a newline.
	Stdoutln(...interface{})
	// Writes interfaces to stderr and appends a newline.
	Stderrln(...interface{}) error
	// Writes the provided error to stderr and returns the provided error.
	Err(err error) error
	// Annotate prepends the message to the error
	Annotate(error, string) error
	// Annotatef prepends the message to the error
	Annotatef(error, string, ...interface{}) error
	// Terminate terminates the execution with the provided error (if it's not nil).
	Terminate(error)
	// Terminatef terminates the execution with a formatted error.
	Terminatef(string, ...interface{})
	// Tannotate terminates the execution with the an annotation of provided error (if it's not nil).
	Tannotate(error, string)
	// Tannotatef terminates the execution with an annotation of the provided error (if it's not nil).
	Tannotatef(error, string, ...interface{})
	// Close informs the os that no more data will be written.
	Close()
	// Color changes the format of stdout to the provided formats.
	Color(fs ...color.Format)
	// Colerr (color + err hehe) changes the format of stderr to the provided formats.
	Colerr(fs ...color.Format)
}

type Processor interface {
	// Execute is the function called when a command graph is
	// being executed.
	Execute(*Input, Output, *Data, *ExecuteData) error
	// Complete is the function called when a command graph is
	// being autocompleted. If it returns a non-nil `Completion` object,
	// then the graph traversal stops and uses the returned object
	// to construct the command completion suggestions.
	Complete(*Input, *Data) (*Completion, error)
	// Usage is the function called when the usage data for a command
	// graph is being constructed. A
	// The input `Usage` object should be
	// updated for each `Node`.
	Usage(*Input, *Data, *Usage) error
}

type Usage struct {
	// contains filtered or unexported fields
}

type UsageSection string