ff

type Command struct {
	// Name of the command, which is used when producing the help output for the
	// command, as well as for subcommand matching.
	//
	// Required.
	Name string

	// Usage is a single line string which should describe the syntax of the
	// command, including flags and arguments. It's typically printed at the top
	// of the help output for the command. For example,
	//
	//    USAGE
	//      cmd [FLAGS] subcmd [FLAGS] <ARG> [<ARG>...]
	//
	// Here, the usage string begins with "cmd [FLAGS] ...".
	//
	// Recommended. If not provided, the help output for the command should not
	// include a usage section.
	Usage string

	// ShortHelp is a single line which should very briefly describe the purpose
	// of the command in prose. It's typically printed next to the command name
	// when it appears as a subcommand in help output. For example,
	//
	//    SUBCOMMANDS
	//      commandname   this is the short help string
	//
	// Recommended.
	ShortHelp string

	// LongHelp is a multi-line string, usually one or more paragraphs of prose,
	// which explain the command in detail. It's typically included in the help
	// output for the command, separate from other sections.
	//
	// Long help should be formatted for user readability. For example, if help
	// output is written to a terminal, long help should include newlines which
	// hard-wrap the string at an appropriate column width for that terminal.
	//
	// Optional.
	LongHelp string

	// Flags is the set of flags associated with, and parsed by, this command.
	//
	// When building a command tree, it's often useful to allow flags defined by
	// parent commands to be specified by any subcommand. The core flag set
	// supports this behavior via SetParent, see the documentation of that
	// method for details.
	//
	// Optional. If not provided, an empty flag set will be constructed and used
	// so that the -h, --help flag works as expected.
	Flags Flags

	// Subcommands which are available underneath (i.e. after) this command.
	// Selecting a subcommand is done via a case-insensitive comparison of the
	// first post-parse argument to this command, against the name of each
	// subcommand.
	//
	// Optional.
	Subcommands []*Command

	// Exec is invoked by Run (or ParseAndRun) if this command was selected as
	// the terminal command during the parse phase. The args passed to Exec are
	// the args left over after parsing.
	//
	// Optional. If not provided, running this command will result in ErrNoExec.
	Exec func(ctx context.Context, args []string) error
	// contains filtered or unexported fields
}

type ConfigFileParseFunc func(r io.Reader, set func(name, value string) error) error

type CoreFlagConfig struct {
	// ShortName is the short form name of the flag, which can be provided as a
	// commandline argument with a single dash - prefix. A rune value of 0 or
	// utf8.RuneError is considered an invalid short name and is ignored.
	//
	// At least one of ShortName and/or LongName is required.
	ShortName rune

	// LongName is the long form name of the flag, which can be provided as a
	// commandline argument with a double-dash -- prefix. An empty string is
	// considered an invalid long name and is ignored.
	//
	// At least one of ShortName and/or LongName is required.
	LongName string

	// Placeholder is typically used to represent an example value in the help
	// text for the flag. For example, a placeholder of `BAR` might result in
	// help text like
	//
	//      -f, --foo BAR   set the foo parameter
	//
	// The placeholder is determined by the following logic.
	//
	//  - If EmptyPlaceholder is true, use the empty string
	//  - If Placeholder is non-empty, use that string
	//  - If Usage contains a `backtick-quoted` substring, use that substring
	//  - If Value is a boolean with default value false, use the empty string
	//  - Otherwise, use a simple transformation of the concrete Value type name
	//
	// Optional.
	Placeholder string

	// NoPlaceholder forces the placeholder of the flag to the empty string.
	// This can be useful if you want to elide the placeholder from help text.
	NoPlaceholder bool

	// Usage is a short help message for the flag, typically printed after the
	// flag name(s) on a single line in the help output. For example, a foo flag
	// might have the usage string "set the foo parameter", which might be
	// rendered as follows.
	//
	//      -f, --foo BAR   set the foo parameter
	//
	// If the usage string contains a `backtick` quoted substring, that
	// substring will be treated as a placeholder, if a placeholder was not
	// otherwise explicitly provided.
	//
	// Recommended.
	Usage string

	// Value is used to parse and store the actual flag value. The MakeFlagValue
	// helper can be used to construct values for common primitive types.
	//
	// As a special case, if the value has an IsBoolFlag() bool method returning
	// true, then it will be treated as a boolean flag. Boolean flags are parsed
	// slightly differently than normal flags: they can be provided without an
	// explicit value, in which case the value is assumed to be true.
	//
	// Required.
	Value flag.Value

	// NoDefault forces the default value of the flag to the empty string. This
	// can be useful if you want to elide the default value from help text.
	NoDefault bool
}

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

type Flag interface {
	// GetFlags should return the set of flags in which this flag is defined.
	// It's primarily used for help output.
	GetFlags() Flags

	// GetShortName should return the short name for this flag, if one is
	// defined. A short name is always a single character (rune) which is
	// typically parsed with a single leading - hyphen.
	GetShortName() (rune, bool)

	// GetLongName should return the long name for this flag, if one is defined.
	// A long name is always a non-empty string which is typically parsed with
	// two leading -- hyphens.
	GetLongName() (string, bool)

	// GetPlaceholder should return a string that can be used as a placeholder
	// for the flag value in help output. For example, a placeholder for a
	// string flag might be STRING. An empty placeholder is valid.
	GetPlaceholder() string

	// GetUsage should return a short description of the flag, which can be
	// included in the help output on the same line as the flag name(s). For
	// example, the usage string for a timeout flag used in an HTTP client might
	// be "timeout for outgoing HTTP requests". An empty usage string is valid,
	// but not recommended.
	GetUsage() string

	// GetDefault should return the default value of the flag as a string.
	GetDefault() string

	// SetValue should parse the provided string into the appropriate type for
	// the flag, and set the flag to that parsed value.
	SetValue(string) error

	// GetValue should return the current value of the flag as a string. If no
	// value has been set, it should return the default value.
	GetValue() string

	// IsSet should return true if SetValue has been called successfully.
	IsSet() bool
}

type Flags interface {
	// GetName should return the name of the flag set.
	GetName() string

	// Parse should parse the provided args against the flag set, setting flags
	// as appropriate, and saving leftover args to be returned by GetArgs. The
	// provided args shouldn't include the program name: callers should pass
	// os.Args[1:], not os.Args.
	Parse(args []string) error

	// IsParsed should return true if the flag set was successfully parsed.
	IsParsed() bool

	// WalkFlags should call the given fn for each flag known to the flag set.
	// Note that this may include flags that are actually defined in different
	// "parent" flag sets. If fn returns an error, WalkFlags should immediately
	// return that error.
	WalkFlags(fn func(Flag) error) error

	// GetFlag should find and return the first flag known to the flag set with
	// the given name. The name should always be compared against valid flag
	// long names. If name is a single valid rune, it should also be compared
	// against valid flag short names. Note that this may return a flag that is
	// actually defined in a different "parent" flag set.
	GetFlag(name string) (Flag, bool)

	// GetArgs should return the args left over after a successful call to
	// parse. If parse has not yet been called successfully, it should return an
	// empty (or nil) slice.
	GetArgs() []string
}

type IsBoolFlagger interface{ IsBoolFlag() bool }

type Option func(*ParseContext)

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

type Resetter interface {
	// Reset should revert the flag set to its initial state, including all
	// flags defined in the flag set. If reset returns successfully, the flag
	// set should be as if it were newly constructed: IsParsed should return
	// false, GetArgs should return an empty slice, etc.
	Reset() error
}