parser

type FieldContext struct {
	Value reflect.Value
	Field reflect.StructField
	Tag   *Tag
	Opts  *Opts
}

type Flag struct {
	Name          string        // name as it appears on command line
	Short         string        // optional short name
	EnvNames      []string      // OS Environment-based names
	Usage         string        // help message
	Placeholder   string        // placeholder for the flag's value
	Value         values.Value  // value as set
	RValue        reflect.Value // Type value to use for completions
	DefValue      []string      // default value (as text); for usage message
	Hidden        bool          // Flag hidden from descriptions/completions
	Deprecated    bool          // Not in use anymore
	Required      bool          // If true, the option _must_ be specified on the command line.
	Persistent    bool          // If true, the flag is persistent on its command.
	Choices       []string      // If non empty, only a certain set of values is allowed for an option.
	OptionalValue []string      // The optional value of the option.
	Negatable     *string       // If not nil, a negation flag is generated with the given prefix.
	Separator     *string       // Custom separator for slice values.
	MapSeparator  *string       // Custom separator for map values.
	XORGroup      []string      // Mutually exclusive flag groups.
	ANDGroup      []string      // "AND" flag groups.
	Tag           *Tag          // Field tag
}

type FlagFunc func(flag string, tag *Tag, val reflect.Value) error

type Handler func(val reflect.Value, field *reflect.StructField) (bool, error)

type OptFunc func(opt *Opts)

type Opts struct {
	// DescTag is the struct tag name for description.
	DescTag string

	// FlagTag is the struct tag name for flag.
	FlagTag string

	// Delimiter for flags.
	FlagDivider string

	// Delimiter for environment variables.
	EnvDivider string

	// Prefix for all flags.
	Prefix string

	// Prefix for all environment variables.
	EnvPrefix string

	// Flatten anonymous structures.
	Flatten bool

	// ParseAllFields specifies either to parse all fields or only tagged ones.
	ParseAll bool

	// Validator is the validation function for flags.
	Validator validation.ValidateFunc

	// FlagFunc is a generic function that can be applied to each flag.
	FlagFunc FlagFunc

	// Vars is a map of variables that can be used for expansion.
	Vars map[string]string

	// GlobalVars is a map of variables that are applied globally.
	GlobalVars map[string]string

	// Completers is a map of custom completer functions.
	Completers map[string]carapace.CompletionCallback
}

type Positional struct {
	Name        string
	Usage       string
	Value       reflect.Value
	PValue      values.Value
	Min         int
	Max         int
	Index       int // The position in the struct (n'th struct field used as a slot)
	StartMin    int
	StartMax    int
	Passthrough bool
	Tag         *Tag
	Validator   func(val string) error
}

type Tag map[string][]string