commands

type Argument struct {
	Name        string
	Type        ArgumentType
	Required    bool
	Variadic    bool
	Description string
}

type ArgumentType int

type Command struct {
	Description string
	Help        string

	Options     []Option
	Arguments   []Argument
	Run         Function
	Marshallers map[EncodingType]Marshaller
	Type        interface{}
	Subcommands map[string]*Command
}

type Context struct {
	ConfigRoot string
	Config     *config.Config
	Node       *core.IpfsNode
}

type EncodingType string

type Error struct {
	Message string
	Code    ErrorType
}

type ErrorType uint

type Function func(Request) (interface{}, error)

type Marshaller func(Response) ([]byte, error)

type Option struct {
	Names       []string     // a list of unique names to
	Type        reflect.Kind // value must be this type
	Description string       // a short string to describe this option

}

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

type Request interface {
	Path() []string
	Option(name string) *OptionValue
	Options() optMap
	SetOption(name string, val interface{})
	Arguments() []interface{} // TODO: make argument value type instead of using interface{}
	Context() *Context
	SetContext(Context)
	Command() *Command

	ConvertOptions() error
}

type Response interface {
	Request() Request

	// Set/Return the response Error
	SetError(err error, code ErrorType)
	Error() *Error

	// Sets/Returns the response value
	SetOutput(interface{})
	Output() interface{}

	// Marshal marshals out the response into a buffer. It uses the EncodingType
	// on the Request to chose a Marshaller (Codec).
	Marshal() ([]byte, error)

	// Gets a io.Reader that reads the marshalled output
	Reader() (io.Reader, error)
}