cmds

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

type Command struct {
	Options   []cmdsutil.Option
	Arguments []cmdsutil.Argument
	PreRun    func(req Request) 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 map[EncodingType]func(Request) func(io.Writer) Encoder
	Helptext cmdsutil.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
	OldSubcommands map[string]*oldcmds.Command
}

type CommandVisitor func(*Command)

type Context struct {
	Online     bool
	ConfigRoot string
	ReqLog     *ReqLog

	LoadConfig func(path string) (*config.Config, error)

	ConstructNode func() (*core.IpfsNode, error)
	// contains filtered or unexported fields
}

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

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

type EncodingEmitter interface {
	ResponseEmitter

	SetEncoder(func(io.Writer) Encoder)
}

type EncodingType string

type Flusher interface {
	Flush() error
}

type Function func(Request, ResponseEmitter)

type Head struct {
	Len uint64
	Err *cmdsutil.Error
}

type Header interface {
	Head() Head
}

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

type OptMap map[string]interface{}

type PostRunMap map[EncodingType]func(Request, ResponseEmitter) ResponseEmitter

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 interface {
	Path() []string
	Option(name string) *cmdsutil.OptionValue
	Options() cmdsutil.OptMap
	SetOption(name string, val interface{})
	SetOptions(opts cmdsutil.OptMap) error
	Arguments() []string
	StringArguments() []string
	SetArguments([]string)
	Files() files.File
	SetFiles(files.File)
	Context() context.Context
	SetRootContext(context.Context) error
	InvocContext() *Context
	SetInvocContext(Context)
	Command() *Command
	Values() map[string]interface{}
	Stdin() io.Reader
	VarArgs(func(string) error) error

	ConvertOptions() error
}

type Response interface {
	Request() Request

	Error() *cmdsutil.Error
	Length() uint64

	// Next returns the next emitted value.
	// The returned error can be a network or decoding error.
	// The error can also be ErrRcvdError if an error has been emitted.
	// In this case the emitted error can be accessed using the Error() method.
	Next() (interface{}, error)
}

type ResponseEmitter interface {
	// closes http conn or channel
	io.Closer

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

	// SetError sets the response error
	// err is an interface{} so we don't have to manually convert to error.
	SetError(err interface{}, code cmdsutil.ErrorType) error

	// 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 TeeError struct {
	// contains filtered or unexported fields
}

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

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