github.com/urfave/cli/v3

type ActionFunc func(context.Context, *Command) error

type ActionableFlag interface {
	RunAction(context.Context, *Command) error
}

type AfterFunc func(context.Context, *Command) error

type Args interface {
	// Get returns the nth argument, or else a blank string
	Get(n int) string
	// First returns the first argument, or else a blank string
	First() string
	// Tail returns the rest of the arguments (not the first one)
	// or else an empty string slice
	Tail() []string
	// Len returns the length of the wrapped slice
	Len() int
	// Present checks if there are any arguments present
	Present() bool
	// Slice returns a copy of the internal slice
	Slice() []string
}

type Argument interface {
	// which this argument can be accessed using the given name
	HasName(string) bool

	// Parse the given args and return unparsed args and/or error
	Parse([]string) ([]string, error)

	// The usage template for this argument to use in help
	Usage() string

	// The Value of this Arg
	Get() any
}

type ArgumentBase[T any, C any, VC ValueCreator[T, C]] struct {
	Name        string `json:"name"`      // the name of this argument
	Value       T      `json:"value"`     // the default value of this argument
	Destination *T     `json:"-"`         // the destination point for this argument
	UsageText   string `json:"usageText"` // the usage text to show
	Config      C      `json:"config"`    // config for this argument similar to Flag Config
	// contains filtered or unexported fields
}

type ArgumentsBase[T any, C any, VC ValueCreator[T, C]] struct {
	Name        string `json:"name"`      // the name of this argument
	Value       T      `json:"value"`     // the default value of this argument
	Destination *[]T   `json:"-"`         // the destination point for this argument
	UsageText   string `json:"usageText"` // the usage text to show
	Min         int    `json:"minTimes"`  // the min num of occurrences of this argument
	Max         int    `json:"maxTimes"`  // the max num of occurrences of this argument, set to -1 for unlimited
	Config      C      `json:"config"`    // config for this argument similar to Flag Config
	// contains filtered or unexported fields
}

type BeforeFunc func(context.Context, *Command) (context.Context, error)

type BoolConfig struct {
	Count *int
}

type BoolFlag = FlagBase[bool, BoolConfig, boolValue]

type BoolWithInverseFlag struct {
	Name             string                                      `json:"name"`             // name of the flag
	Category         string                                      `json:"category"`         // category of the flag, if any
	DefaultText      string                                      `json:"defaultText"`      // default text of the flag for usage purposes
	HideDefault      bool                                        `json:"hideDefault"`      // whether to hide the default value in output
	Usage            string                                      `json:"usage"`            // usage string for help output
	Sources          ValueSourceChain                            `json:"-"`                // sources to load flag value from
	Required         bool                                        `json:"required"`         // whether the flag is required or not
	Hidden           bool                                        `json:"hidden"`           // whether to hide the flag in help output
	Local            bool                                        `json:"local"`            // whether the flag needs to be applied to subcommands as well
	Value            bool                                        `json:"defaultValue"`     // default value for this flag if not set by from any source
	Destination      *bool                                       `json:"-"`                // destination pointer for value when set
	Aliases          []string                                    `json:"aliases"`          // Aliases that are allowed for this flag
	TakesFile        bool                                        `json:"takesFileArg"`     // whether this flag takes a file argument, mainly for shell completion purposes
	Action           func(context.Context, *Command, bool) error `json:"-"`                // Action callback to be called when flag is set
	OnlyOnce         bool                                        `json:"onlyOnce"`         // whether this flag can be duplicated on the command line
	Validator        func(bool) error                            `json:"-"`                // custom function to validate this flag value
	ValidateDefaults bool                                        `json:"validateDefaults"` // whether to validate defaults or not
	Config           BoolConfig                                  `json:"config"`           // Additional/Custom configuration associated with this flag type
	InversePrefix    string                                      `json:"invPrefix"`        // The prefix used to indicate a negative value. Default: `env` becomes `no-env`
	// contains filtered or unexported fields
}

type CategorizableFlag interface {
	// Returns the category of the flag
	GetCategory() string

	// Sets the category of the flag
	SetCategory(string)
}

type Command struct {
	// The name of the command
	Name string `json:"name"`
	// A list of aliases for the command
	Aliases []string `json:"aliases"`
	// A short description of the usage of this command
	Usage string `json:"usage"`
	// Text to override the USAGE section of help
	UsageText string `json:"usageText"`
	// A short description of the arguments of this command
	ArgsUsage string `json:"argsUsage"`
	// Version of the command
	Version string `json:"version"`
	// Longer explanation of how the command works
	Description string `json:"description"`
	// DefaultCommand is the (optional) name of a command
	// to run if no command names are passed as CLI arguments.
	DefaultCommand string `json:"defaultCommand"`
	// The category the command is part of
	Category string `json:"category"`
	// List of child commands
	Commands []*Command `json:"commands"`
	// List of flags to parse
	Flags []Flag `json:"flags"`
	// Boolean to hide built-in help command and help flag
	HideHelp bool `json:"hideHelp"`
	// Ignored if HideHelp is true.
	HideHelpCommand bool `json:"hideHelpCommand"`
	// Boolean to hide built-in version flag and the VERSION section of help
	HideVersion bool `json:"hideVersion"`
	// Boolean to enable shell completion commands
	EnableShellCompletion bool `json:"-"`
	// Shell Completion generation command name
	ShellCompletionCommandName string `json:"-"`
	// The function to call when checking for shell command completions
	ShellComplete ShellCompleteFunc `json:"-"`
	// The function to configure a shell completion command
	ConfigureShellCompletionCommand ConfigureShellCompletionCommand `json:"-"`
	// An action to execute before any subcommands are run, but after the context is ready
	// If a non-nil error is returned, no subcommands are run
	Before BeforeFunc `json:"-"`
	// An action to execute after any subcommands are run, but after the subcommand has finished
	// It is run even if Action() panics
	After AfterFunc `json:"-"`
	// The function to call when this command is invoked
	Action ActionFunc `json:"-"`
	// Execute this function if the proper command cannot be found
	CommandNotFound CommandNotFoundFunc `json:"-"`
	// Execute this function if a usage error occurs.
	OnUsageError OnUsageErrorFunc `json:"-"`
	// Execute this function when an invalid flag is accessed from the context
	InvalidFlagAccessHandler InvalidFlagAccessFunc `json:"-"`
	// Boolean to hide this command from help or completion
	Hidden bool `json:"hidden"`
	// List of all authors who contributed (string or fmt.Stringer)
	// TODO: ~string | fmt.Stringer when interface unions are available
	Authors []any `json:"authors"`
	// Copyright of the binary if any
	Copyright string `json:"copyright"`
	// Reader reader to write input to (useful for tests)
	Reader io.Reader `json:"-"`
	// Writer writer to write output to
	Writer io.Writer `json:"-"`
	// ErrWriter writes error output
	ErrWriter io.Writer `json:"-"`
	// ExitErrHandler processes any error encountered while running a Command before it is
	// returned to the caller. If no function is provided, HandleExitCoder is used as the
	// default behavior.
	ExitErrHandler ExitErrHandlerFunc `json:"-"`
	// Other custom info
	Metadata map[string]any `json:"metadata"`
	// Carries a function which returns app specific info.
	ExtraInfo func() map[string]string `json:"-"`
	// CustomRootCommandHelpTemplate the text template for app help topic.
	// cli.go uses text/template to render templates. You can
	// render custom help text by setting this variable.
	CustomRootCommandHelpTemplate string `json:"-"`
	// SliceFlagSeparator is used to customize the separator for SliceFlag, the default is ","
	SliceFlagSeparator string `json:"sliceFlagSeparator"`
	// DisableSliceFlagSeparator is used to disable SliceFlagSeparator, the default is false
	DisableSliceFlagSeparator bool `json:"disableSliceFlagSeparator"`
	// MapFlagKeyValueSeparator is used to customize the separator for MapFlag, the default is "="
	MapFlagKeyValueSeparator string `json:"mapFlagKeyValueSeparator"`
	// Boolean to enable short-option handling so user can combine several
	// single-character bool arguments into one
	// i.e. foobar -o -v -> foobar -ov
	UseShortOptionHandling bool `json:"useShortOptionHandling"`
	// Enable suggestions for commands and flags
	Suggest bool `json:"suggest"`
	// Allows global flags set by libraries which use flag.XXXVar(...) directly
	// to be parsed through this library
	AllowExtFlags bool `json:"allowExtFlags"`
	// Treat all flags as normal arguments if true
	SkipFlagParsing bool `json:"skipFlagParsing"`
	// CustomHelpTemplate the text template for the command help topic.
	// cli.go uses text/template to render templates. You can
	// render custom help text by setting this variable.
	CustomHelpTemplate string `json:"-"`
	// Use longest prefix match for commands
	PrefixMatchCommands bool `json:"prefixMatchCommands"`
	// Custom suggest command for matching
	SuggestCommandFunc SuggestCommandFunc `json:"-"`
	// Flag exclusion group
	MutuallyExclusiveFlags []MutuallyExclusiveFlags `json:"mutuallyExclusiveFlags"`
	// Arguments to parse for this command
	Arguments []Argument `json:"arguments"`
	// Whether to read arguments from stdin
	// applicable to root command only
	ReadArgsFromStdin bool `json:"readArgsFromStdin"`
	// StopOnNthArg provides v2-like behavior for specific commands by stopping
	// flag parsing after N positional arguments are encountered. When set to N,
	// all remaining arguments after the Nth positional argument will be treated
	// as arguments, not flags.
	//
	// A value of 0 means all arguments are treated as positional (no flag parsing).
	// A nil value means normal v3 flag parsing behavior (flags can appear anywhere).
	StopOnNthArg *int `json:"stopOnNthArg"`
	// contains filtered or unexported fields
}

type CommandCategories interface {
	// AddCommand adds a command to a category, creating a new category if necessary.
	AddCommand(category string, command *Command)
	// Categories returns a slice of categories sorted by name
	Categories() []CommandCategory
}

type CommandCategory interface {
	// Name returns the category name string
	Name() string
	// VisibleCommands returns a slice of the Commands with Hidden=false
	VisibleCommands() []*Command
}

type CommandNotFoundFunc func(context.Context, *Command, string)

type ConfigureShellCompletionCommand func(*Command)

type Countable interface {
	Count() int
}

type DocGenerationFlag interface {
	// TakesValue returns true if the flag takes a value, otherwise false
	TakesValue() bool

	// GetUsage returns the usage string for the flag
	GetUsage() string

	// GetValue returns the flags value as string representation and an empty
	// string if the flag takes no value at all.
	GetValue() string

	// GetDefaultText returns the default text for this flag
	GetDefaultText() string

	// GetEnvVars returns the env vars for this flag
	GetEnvVars() []string

	// IsDefaultVisible returns whether the default value should be shown in
	// help text
	IsDefaultVisible() bool
	// TypeName to detect if a flag is a string, bool, etc.
	TypeName() string
}

type DocGenerationMultiValueFlag interface {
	DocGenerationFlag

	// IsMultiValueFlag returns true for flags that can be given multiple times.
	IsMultiValueFlag() bool
}

type DurationFlag = FlagBase[time.Duration, NoConfig, durationValue]

type EnvValueSource interface {
	IsFromEnv() bool
	Key() string
}

type ErrorFormatter interface {
	Format(s fmt.State, verb rune)
}

type ExitCoder interface {
	error
	ExitCode() int
}

type ExitErrHandlerFunc func(context.Context, *Command, error)

type Flag interface {
	fmt.Stringer

	// Retrieve the value of the Flag
	Get() any

	// Lifecycle methods.
	// flag callback prior to parsing
	PreParse() error

	// flag callback post parsing
	PostParse() error

	// Apply Flag settings to the given flag set
	Set(string, string) error

	// All possible names for this flag
	Names() []string

	// Whether the flag has been set or not
	IsSet() bool
}

type FlagBase[T any, C any, VC ValueCreator[T, C]] struct {
	Name             string                                   `json:"name"`             // name of the flag
	Category         string                                   `json:"category"`         // category of the flag, if any
	DefaultText      string                                   `json:"defaultText"`      // default text of the flag for usage purposes
	HideDefault      bool                                     `json:"hideDefault"`      // whether to hide the default value in output
	Usage            string                                   `json:"usage"`            // usage string for help output
	Sources          ValueSourceChain                         `json:"-"`                // sources to load flag value from
	Required         bool                                     `json:"required"`         // whether the flag is required or not
	Hidden           bool                                     `json:"hidden"`           // whether to hide the flag in help output
	Local            bool                                     `json:"local"`            // whether the flag needs to be applied to subcommands as well
	Value            T                                        `json:"defaultValue"`     // default value for this flag if not set by from any source
	Destination      *T                                       `json:"-"`                // destination pointer for value when set
	Aliases          []string                                 `json:"aliases"`          // Aliases that are allowed for this flag
	TakesFile        bool                                     `json:"takesFileArg"`     // whether this flag takes a file argument, mainly for shell completion purposes
	Action           func(context.Context, *Command, T) error `json:"-"`                // Action callback to be called when flag is set
	Config           C                                        `json:"config"`           // Additional/Custom configuration associated with this flag type
	OnlyOnce         bool                                     `json:"onlyOnce"`         // whether this flag can be duplicated on the command line
	Validator        func(T) error                            `json:"-"`                // custom function to validate this flag value
	ValidateDefaults bool                                     `json:"validateDefaults"` // whether to validate defaults or not
	// contains filtered or unexported fields
}

type FlagCategories interface {
	// AddFlags adds a flag to a category, creating a new category if necessary.
	AddFlag(category string, fl Flag)
	// VisibleCategories returns a slice of visible flag categories sorted by name
	VisibleCategories() []VisibleFlagCategory
}

type FlagEnvHintFunc func(envVars []string, str string) string

type FlagFileHintFunc func(filePath, str string) string

type FlagNamePrefixFunc func(fullName []string, placeholder string) string

type FlagStringFunc func(Flag) string

type FlagsByName []Flag

type Float32Arg = ArgumentBase[float32, NoConfig, floatValue[float32]]

type Float32Args = ArgumentsBase[float32, NoConfig, floatValue[float32]]

type Float32Flag = FlagBase[float32, NoConfig, floatValue[float32]]

type Float32Slice = SliceBase[float32, NoConfig, floatValue[float32]]

type Float32SliceFlag = FlagBase[[]float32, NoConfig, Float32Slice]

type Float64Arg = ArgumentBase[float64, NoConfig, floatValue[float64]]

type Float64Args = ArgumentsBase[float64, NoConfig, floatValue[float64]]

type Float64Flag = FlagBase[float64, NoConfig, floatValue[float64]]

type Float64Slice = SliceBase[float64, NoConfig, floatValue[float64]]

type Float64SliceFlag = FlagBase[[]float64, NoConfig, Float64Slice]

type FloatArg = ArgumentBase[float64, NoConfig, floatValue[float64]]

type FloatArgs = ArgumentsBase[float64, NoConfig, floatValue[float64]]

type FloatFlag = FlagBase[float64, NoConfig, floatValue[float64]]

type FloatSlice = SliceBase[float64, NoConfig, floatValue[float64]]

type FloatSliceFlag = FlagBase[[]float64, NoConfig, FloatSlice]

type GenericFlag = FlagBase[Value, NoConfig, genericValue]

type HelpPrinterCustomFunc func(w io.Writer, templ string, data any, customFunc map[string]any)

type HelpPrinterFunc func(w io.Writer, templ string, data any)

type Int16Arg = ArgumentBase[int16, IntegerConfig, intValue[int16]]

type Int16Args = ArgumentsBase[int16, IntegerConfig, intValue[int16]]

type Int16Flag = FlagBase[int16, IntegerConfig, intValue[int16]]

type Int16Slice = SliceBase[int16, IntegerConfig, intValue[int16]]

type Int16SliceFlag = FlagBase[[]int16, IntegerConfig, Int16Slice]

type Int32Arg = ArgumentBase[int32, IntegerConfig, intValue[int32]]

type Int32Args = ArgumentsBase[int32, IntegerConfig, intValue[int32]]

type Int32Flag = FlagBase[int32, IntegerConfig, intValue[int32]]

type Int32Slice = SliceBase[int32, IntegerConfig, intValue[int32]]

type Int32SliceFlag = FlagBase[[]int32, IntegerConfig, Int32Slice]

type Int64Arg = ArgumentBase[int64, IntegerConfig, intValue[int64]]

type Int64Args = ArgumentsBase[int64, IntegerConfig, intValue[int64]]

type Int64Flag = FlagBase[int64, IntegerConfig, intValue[int64]]

type Int64Slice = SliceBase[int64, IntegerConfig, intValue[int64]]

type Int64SliceFlag = FlagBase[[]int64, IntegerConfig, Int64Slice]

type Int8Arg = ArgumentBase[int8, IntegerConfig, intValue[int8]]

type Int8Args = ArgumentsBase[int8, IntegerConfig, intValue[int8]]

type Int8Flag = FlagBase[int8, IntegerConfig, intValue[int8]]

type Int8Slice = SliceBase[int8, IntegerConfig, intValue[int8]]

type Int8SliceFlag = FlagBase[[]int8, IntegerConfig, Int8Slice]

type IntArg = ArgumentBase[int, IntegerConfig, intValue[int]]

type IntArgs = ArgumentsBase[int, IntegerConfig, intValue[int]]

type IntFlag = FlagBase[int, IntegerConfig, intValue[int]]

type IntSlice = SliceBase[int, IntegerConfig, intValue[int]]

type IntSliceFlag = FlagBase[[]int, IntegerConfig, IntSlice]

type IntegerConfig struct {
	Base int
}

type InvalidFlagAccessFunc func(context.Context, *Command, string)

type LocalFlag interface {
	IsLocal() bool
}

type MapBase[T any, C any, VC ValueCreator[T, C]] struct {
	// contains filtered or unexported fields
}

type MapSource interface {
	fmt.Stringer
	fmt.GoStringer

	// Lookup returns the value from the source based on key
	// and if it was found
	// or returns an empty string and false
	Lookup(string) (any, bool)
}

type MultiError interface {
	error
	Errors() []error
}

type MutuallyExclusiveFlags struct {
	// Flag list
	Flags [][]Flag

	// whether this group is required
	Required bool

	// Category to apply to all flags within group
	Category string
}

type NoConfig struct{}

type OnUsageErrorFunc func(ctx context.Context, cmd *Command, err error, isSubcommand bool) error

type RequiredFlag interface {
	// whether the flag is a required flag or not
	IsRequired() bool
}

type SchemaItemsTyper interface {
	// SchemaItemsType returns the JSON Schema type of elements for
	// array-type flags. Returns "" for single-value or object flags.
	SchemaItemsType() string
}

type SchemaTyper interface {
	// SchemaType returns the JSON Schema type name for the value this
	// flag accepts: "boolean", "integer", "number", "string", "array",
	// "object". Returns "" if the flag does not map cleanly.
	SchemaType() string
}

type Serializer interface {
	Serialize() string
}

type ShellCompleteFunc func(context.Context, *Command)

type SliceBase[T any, C any, VC ValueCreator[T, C]] struct {
	// contains filtered or unexported fields
}

type StringArg = ArgumentBase[string, StringConfig, stringValue]

type StringArgs = ArgumentsBase[string, StringConfig, stringValue]

type StringConfig struct {
	// Whether to trim whitespace of parsed value
	TrimSpace bool
}

type StringFlag = FlagBase[string, StringConfig, stringValue]

type StringMap = MapBase[string, StringConfig, stringValue]

type StringMapArgs = ArgumentBase[map[string]string, StringConfig, StringMap]

type StringMapFlag = FlagBase[map[string]string, StringConfig, StringMap]

type StringSlice = SliceBase[string, StringConfig, stringValue]

type StringSliceFlag = FlagBase[[]string, StringConfig, StringSlice]

type SuggestCommandFunc func(commands []*Command, provided string) string

type SuggestFlagFunc func(flags []Flag, provided string, hideHelp bool) string

type TimestampArg = ArgumentBase[time.Time, TimestampConfig, timestampValue]

type TimestampArgs = ArgumentsBase[time.Time, TimestampConfig, timestampValue]

type TimestampConfig struct {
	Timezone *time.Location
	// Available layouts for flag value.
	//
	// Note that value for formats with missing year/date will be interpreted as current year/date respectively.
	//
	// Read more about time layouts: https://pkg.go.dev/time#pkg-constants
	Layouts []string
}

type TimestampFlag = FlagBase[time.Time, TimestampConfig, timestampValue]

type Uint16Arg = ArgumentBase[uint16, IntegerConfig, uintValue[uint16]]

type Uint16Args = ArgumentsBase[uint16, IntegerConfig, uintValue[uint16]]

type Uint16Flag = FlagBase[uint16, IntegerConfig, uintValue[uint16]]

type Uint16Slice = SliceBase[uint16, IntegerConfig, uintValue[uint16]]

type Uint16SliceFlag = FlagBase[[]uint16, IntegerConfig, Uint16Slice]

type Uint32Arg = ArgumentBase[uint32, IntegerConfig, uintValue[uint32]]

type Uint32Args = ArgumentsBase[uint32, IntegerConfig, uintValue[uint32]]

type Uint32Flag = FlagBase[uint32, IntegerConfig, uintValue[uint32]]

type Uint32Slice = SliceBase[uint32, IntegerConfig, uintValue[uint32]]

type Uint32SliceFlag = FlagBase[[]uint32, IntegerConfig, Uint32Slice]

type Uint64Arg = ArgumentBase[uint64, IntegerConfig, uintValue[uint64]]

type Uint64Args = ArgumentsBase[uint64, IntegerConfig, uintValue[uint64]]

type Uint64Flag = FlagBase[uint64, IntegerConfig, uintValue[uint64]]

type Uint64Slice = SliceBase[uint64, IntegerConfig, uintValue[uint64]]

type Uint64SliceFlag = FlagBase[[]uint64, IntegerConfig, Uint64Slice]

type Uint8Arg = ArgumentBase[uint8, IntegerConfig, uintValue[uint8]]

type Uint8Args = ArgumentsBase[uint8, IntegerConfig, uintValue[uint8]]

type Uint8Flag = FlagBase[uint8, IntegerConfig, uintValue[uint8]]

type Uint8Slice = SliceBase[uint8, IntegerConfig, uintValue[uint8]]

type Uint8SliceFlag = FlagBase[[]uint8, IntegerConfig, Uint8Slice]

type UintArg = ArgumentBase[uint, IntegerConfig, uintValue[uint]]

type UintArgs = ArgumentsBase[uint, IntegerConfig, uintValue[uint]]

type UintFlag = FlagBase[uint, IntegerConfig, uintValue[uint]]

type UintSlice = SliceBase[uint, IntegerConfig, uintValue[uint]]

type UintSliceFlag = FlagBase[[]uint, IntegerConfig, UintSlice]

type Value interface {
	flag.Value
	flag.Getter
}

type ValueCreator[T any, C any] interface {
	Create(T, *T, C) Value
	ToString(T) string
}

type ValueSource interface {
	fmt.Stringer
	fmt.GoStringer

	// Lookup returns the value from the source and if it was found
	// or returns an empty string and false
	Lookup() (string, bool)
}

type ValueSourceChain struct {
	Chain []ValueSource
}

type VisibleFlag interface {
	// IsVisible returns true if the flag is not hidden, otherwise false
	IsVisible() bool
}

type VisibleFlagCategory interface {
	// Name returns the category name string
	Name() string
	// Flags returns a slice of VisibleFlag sorted by name
	Flags() []Flag
}