snake

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

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

type BoolInput = simpleValueInput[bool]

type Chan chan any

type CommandStrategy struct {
}

type DurationInput = simpleValueInput[time.Duration]

type Enum interface {
	Resolver
	Input
	SetCurrent(string) error
	CurrentPtr() *string
	RawTypeName() string
	Options() []string
	Ptr() any
	Usage() string
	DisplayName() string
	ApplyResolver(EnumResolverFunc) error
}

type EnumResolverFunc func(typeName string, options []string) (string, error)

type FMap func(string) Resolver

type FileOutput struct {
	Dir   string
	Mkdir bool
	Data  map[string]io.Reader
}

type Input interface {
	Name() string
	Shared() bool
	Ptr() any
	Parent() Resolver
	SetValue(any) error
	Type() InputType
}

type InputType string

type InputWithOptions interface {
	Options() []string
}

type IntArrayInput = simpleValueInput[[]int]

type IntInput = simpleValueInput[int]

type JSONOutput struct {
	Data json.RawMessage
}

type ListFunc func(Resolver) []reflect.Type

type LongRunningOutput struct {
	Start func(context.Context) error
}

type Method interface {
}

type MethodProvider interface {
	Method() reflect.Value
}

type Middleware interface {
	Wrap(MiddlewareFunc) MiddlewareFunc
}

type MiddlewareFunc func(ctx context.Context) error

type MiddlewareProvider interface {
	Middlewares() []Middleware
}

type NamedMethod interface {
	Name() string
}

type NewSnakeOpts struct {
	Resolvers            []Resolver
	OverrideEnumResolver EnumResolverFunc
}

type NilOutput struct{}

type Output interface {
	IsOutput()
}

type OutputHandler interface {
	Stdout() io.Writer
	Stderr() io.Writer
	Stdin() io.Reader
	HandleLongRunningOutput(ctx context.Context, cd Chan, out *LongRunningOutput) error
	HandleRawTextOutput(ctx context.Context, cd Chan, out *RawTextOutput) error
	HandleTableOutput(ctx context.Context, cd Chan, out *TableOutput) error
	HandleJSONOutput(ctx context.Context, cd Chan, out *JSONOutput) error
	HandleNilOutput(ctx context.Context, cd Chan, out *NilOutput) error
	HandleFileOutput(ctx context.Context, cd Chan, out *FileOutput) error
}

type RawTextOutput struct {
	Data string
}

type Refreshable interface {
	RefreshInterval() time.Duration
}

type Resolver interface {
	RunFunc() reflect.Value
	Ref() Method
	IsResolver()
}

type Snake interface {
	ResolverNames() []string
	Resolve(string) Resolver
	Enums() []Enum
	Resolvers() []Resolver
	DependantsOf(string) []string
}

type SnakeImplementation interface {
	ManagedResolvers(context.Context) []Resolver
	OnSnakeInit(context.Context, Snake) error
	ResolveEnum(string, []string) (string, error)
	ProvideContextResolver() Resolver
}

type SnakeImplementationTyped[X any] interface {
	Decorate(context.Context, X, Snake, []Input, []Middleware) error
	SnakeImplementation
}

type Stderr interface {
	io.Writer
}

type Stdin interface {
	io.Reader
}

type Stdout interface {
	io.Writer
}

type Strategy interface {
	ValidateResponseTypes([]reflect.Type) error
}

type StringArrayInput = simpleValueInput[[]string]

type StringEnumInput = enumInput

type StringInput = simpleValueInput[string]

type TableOutput struct {
	ColumnNames    []string
	RowValueData   [][]any
	RowValueColors [][]string
	RawData        any
}

type TypedResolver[M Method] interface {
	Resolver
	TypedRef() M
	WithMiddleware(...Middleware) TypedResolver[M]
}