http

type Client struct {
	// HTTP is the standard net/http client
	HTTP http.Client
	// PropagateContext tells whether the context should be propagated upstream
	//
	// This should be activated when the upstream endpoint is a SPINE service
	// or another SPINE-compatible service. The context can potentially leak
	// sensitive information, so do not activate it for services that you don't trust.
	PropagateContext bool
}

type Endpoint interface {
	Path() string
	Method() string
	Attach(*mux.Router, func(http.ResponseWriter, *http.Request))
	Serve(ctx context.Context, w ResponseWriter, r *Request)
}

type Middleware func(ServeFunc) ServeFunc

type Option func(*Server)

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

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

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

type Parser interface {
	Type() string
	Parse(v interface{}) error
}

type RenderConditional struct {
	Req          *http.Request
	ETag         string
	LastModified time.Time
	Next         Renderer
}

type RenderContent struct {
	Req     *http.Request
	Modtime time.Time
	Content io.ReadSeeker
}

type RenderData struct {
	Code        int
	ContentType string
	Reader      io.ReadCloser
}

type RenderGob struct {
	Code int
	V    interface{}
}

type RenderHead struct {
	Code int
}

type RenderJSON struct {
	Code int
	V    interface{}
}

type RenderRedirect struct {
	Req *http.Request
	URL string
}

type Renderer interface {
	// Render writes a response to the response writer
	Render(ResponseWriter) error
}

type Request struct {
	HTTP   *http.Request
	Params map[string]string
	// contains filtered or unexported fields
}

type ResponseWriter interface {
	// Header returns the header map that will be sent by
	// WriteHeader. The Header map also is the mechanism with which
	// Handlers can set HTTP trailers.
	//
	// Changing the header map after a call to WriteHeader (or
	// Write) has no effect unless the modified headers are
	// trailers.
	//
	// There are two ways to set Trailers. The preferred way is to
	// predeclare in the headers which trailers you will later
	// send by setting the "Trailer" header to the names of the
	// trailer keys which will come later. In this case, those
	// keys of the Header map are treated as if they were
	// trailers. See the example. The second way, for trailer
	// keys not known to the Handler until after the first Write,
	// is to prefix the Header map keys with the TrailerPrefix
	// constant value. See TrailerPrefix.
	//
	// To suppress implicit response headers (such as "Date"), set
	// their value to nil.
	Header() http.Header

	// Write writes the data to the connection as part of an HTTP reply.
	//
	// If WriteHeader has not yet been called, Write calls
	// WriteHeader(http.StatusOK) before writing the data. If the Header
	// does not contain a Content-Type line, Write adds a Content-Type set
	// to the result of passing the initial 512 bytes of written data to
	// DetectContentType.
	//
	// Depending on the HTTP protocol version and the client, calling
	// Write or WriteHeader may prevent future reads on the
	// Request.Body. For HTTP/1.x requests, handlers should read any
	// needed request body data before writing the response. Once the
	// headers have been flushed (due to either an explicit Flusher.Flush
	// call or writing enough data to trigger a flush), the request body
	// may be unavailable. For HTTP/2 requests, the Go HTTP server permits
	// handlers to continue to read the request body while concurrently
	// writing the response. However, such behavior may not be supported
	// by all HTTP/2 clients. Handlers should read before writing if
	// possible to maximize compatibility.
	Write([]byte) (int, error)

	// WriteHeader sends an HTTP response header with status code.
	// If WriteHeader is not called explicitly, the first call to Write
	// will trigger an implicit WriteHeader(http.StatusOK).
	// Thus explicit calls to WriteHeader are mainly used to
	// send error codes.
	WriteHeader(int)

	// Code returns the written status code.
	// If it has not been set yet, it will return 0
	Code() int

	// HasCode returns whether the status code has been set
	HasCode() bool

	// Head replies to the request using the provided data. It encodes the
	// response in JSON
	JSON(code int, data interface{}) error

	// Head replies to the request using the provided data. It encodes the
	// response in gob.
	// Since gob does not have an official mime type, Content-Type will be set
	// to `application/octet-stream`
	Gob(code int, data interface{}) error

	// Head replies to the request only with a header
	Head(code int) error

	// Redirect replies to the request with an http.StatusTemporaryRedirect to
	// url, which may be a path relative to the request path.
	Redirect(req *http.Request, url string) error

	// Content replies to the request using the content in the provided
	// ReadSeeker.
	// The main benefit of Content over Data is that it handles Range requests
	// properly, sets the MIME type, and handles If-Match, If-Unmodified-Since,
	// If-None-Match, If-Modified-Since, and If-Range requests.
	//
	// If modtime is not the zero time or Unix epoch, Content includes it in a
	// Last-Modified header in the response.
	// If the request includes an If-Modified-Since header, Content uses modtime
	// to decide whether the content needs to be sent at all.
	//
	// Using Conditional with Content is redundant.
	Content(req *http.Request, content io.ReadSeeker, modtime ...time.Time) error

	// Data encodes an arbitrary type of data
	Data(code int, contentType string, data io.ReadCloser) error

	// Conditional checks whether the request conditions are fresh.
	// If the request is fresh, it returns a 304, otherwise it calls the next
	// renderer
	Conditional(
		req *http.Request, etag string, lastModified time.Time, next func() error,
	) error
}

type ServeFunc func(ctx context.Context, w ResponseWriter, r *Request)

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