cmds

type Command struct {
	Options   []cmdkit.Option
	Arguments []cmdkit.Argument
	PreRun    func(req *Request, env Environment) error

	// Run is the function that processes the request to generate a response.
	// Note that when executing the command over the HTTP API you can only read
	// after writing when using multipart requests. The request body will not be
	// available for reading after the HTTP connection has been written to.
	Run      Function
	PostRun  PostRunMap
	Encoders EncoderMap
	Helptext cmdkit.HelpText

	// External denotes that a command is actually an external binary.
	// fewer checks and validations will be performed on such commands.
	External bool

	// Type describes the type of the output of the Command's Run Function.
	// In precise terms, the value of Type is an instance of the return type of
	// the Run Function.
	//
	// ie. If command Run returns &Block{}, then Command.Type == &Block{}
	Type        interface{}
	Subcommands map[string]*Command
}

type CommandVisitor func(*Command)

type Decoder interface {
	Decode(value interface{}) error
}

type Encoder interface {
	Encode(value interface{}) error
}

type EncoderFunc func(req *Request) func(w io.Writer) Encoder

type EncoderMap map[EncodingType]EncoderFunc

type EncodingEmitter interface {
	ResponseEmitter

	SetEncoder(func(io.Writer) Encoder)
}

type EncodingType string

type Environment interface {
	// Context returns the environment's context.
	Context() context.Context
}

type Executor interface {
	Execute(req *Request, re ResponseEmitter, env Environment) error
}

type Flusher interface {
	Flush() error
}

type Function func(*Request, ResponseEmitter, Environment) error

type MakeEnvironment func(context.Context, *Request) (Environment, error)

type MakeExecutor func(*Request, interface{}) (Executor, error)

type MaybeError struct {
	Value interface{} // needs to be a pointer
	Error *cmdkit.Error
	// contains filtered or unexported fields
}

type PostRunMap map[PostRunType]func(Response, ResponseEmitter) error

type PostRunType string

type ReqLog struct {
	Requests []*ReqLogEntry
	// contains filtered or unexported fields
}

type ReqLogEntry struct {
	StartTime time.Time
	EndTime   time.Time
	Active    bool
	Command   string
	Options   map[string]interface{}
	Args      []string
	ID        int
}

type Request struct {
	Context       context.Context
	Root, Command *Command

	Path      []string
	Arguments []string
	Options   cmdkit.OptMap

	Files files.File
	// contains filtered or unexported fields
}

type Response interface {
	Request() *Request

	Error() *cmdkit.Error
	Length() uint64

	// Next returns the next emitted value.
	// The returned error can be a network or decoding error.
	Next() (interface{}, error)
}

type ResponseEmitter interface {
	// Close closes the underlying transport.
	Close() error

	// CloseWithError closes the underlying transport and makes subsequent read
	// calls return the passed error.
	CloseWithError(error) error

	// SetLength sets the length of the output
	// err is an interface{} so we don't have to manually convert to error.
	SetLength(length uint64)

	// Emit sends a value.
	// If value is io.Reader we just copy that to the connection
	// other values are marshalled.
	Emit(value interface{}) error
}

type Single struct {
	Value interface{}
}

type StdinArguments interface {
	io.ReadCloser

	// Scan reads in the next argument and returns true if there is an
	// argument to read.
	Scan() bool

	// Argument returns the next argument.
	Argument() string

	// Err returns any errors encountered when reading in arguments.
	Err() error
}

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