web

type Context struct {
	// A ResponseWriter interface is used by an HTTP handler to
	// construct an HTTP response.
	Writer http.ResponseWriter

	// A Request represents an HTTP request received by a server
	// or to be sent by a client.
	Request *http.Request
	// contains filtered or unexported fields
}

type HttpError struct {
	Code    int
	Message string
}

type MiddlewareFunc = mux.MiddlewareFunc

type Options struct {
	// Addr optionally specifies the TCP address for the server to listen on,
	// in the form "host:port". If empty, ":http" (port 8080) is used.
	// The service names are defined in RFC 6335 and assigned by IANA.
	// See net.Dial for details of the address format.
	Addr string `value:"${addr:=}"`

	// CertFile containing a certificate and matching private key for the
	// server must be provided if neither the Server's
	// TLSConfig.Certificates nor TLSConfig.GetCertificate are populated.
	// If the certificate is signed by a certificate authority, the
	// certFile should be the concatenation of the server's certificate,
	// any intermediates, and the CA's certificate.
	CertFile string `value:"${cert-file:=}"`

	// KeyFile containing a private key file.
	KeyFile string `value:"${key-file:=}"`

	// ReadTimeout is the maximum duration for reading the entire
	// request, including the body. A zero or negative value means
	// there will be no timeout.
	//
	// Because ReadTimeout does not let Handlers make per-request
	// decisions on each request body's acceptable deadline or
	// upload rate, most users will prefer to use
	// ReadHeaderTimeout. It is valid to use them both.
	ReadTimeout time.Duration `value:"${read-timeout:=0s}"`

	// ReadHeaderTimeout is the amount of time allowed to read
	// request headers. The connection's read deadline is reset
	// after reading the headers and the Handler can decide what
	// is considered too slow for the body. If ReadHeaderTimeout
	// is zero, the value of ReadTimeout is used. If both are
	// zero, there is no timeout.
	ReadHeaderTimeout time.Duration `value:"${read-header-timeout:=0s}"`

	// WriteTimeout is the maximum duration before timing out
	// writes of the response. It is reset whenever a new
	// request's header is read. Like ReadTimeout, it does not
	// let Handlers make decisions on a per-request basis.
	// A zero or negative value means there will be no timeout.
	WriteTimeout time.Duration `value:"${write-timeout:=0s}"`

	// IdleTimeout is the maximum amount of time to wait for the
	// next request when keep-alives are enabled. If IdleTimeout
	// is zero, the value of ReadTimeout is used. If both are
	// zero, there is no timeout.
	IdleTimeout time.Duration `value:"${idle-timeout:=0s}"`

	// MaxHeaderBytes controls the maximum number of bytes the
	// server will read parsing the request header's keys and
	// values, including the request line. It does not limit the
	// size of the request body.
	// If zero, DefaultMaxHeaderBytes is used.
	MaxHeaderBytes int `value:"${max-header-bytes:=0}"`
}

type Renderer interface {
	Render(ctx *Context, err error, result interface{})
}

type RendererFunc func(ctx *Context, err error, result interface{})

type RouterGroup interface {
	// Handler dispatches the handler registered in the matched route.
	http.Handler

	// BasePath returns the base path of router group.
	BasePath() string

	// Use appends a MiddlewareFunc to the chain.
	Use(mwf ...MiddlewareFunc)
	// Renderer to be used Response renderer in default.
	Renderer(renderer Renderer)

	// NotFound to be used when no route matches.
	NotFound(handler http.Handler)
	// MethodNotAllowed to be used when the request method does not match the route.
	MethodNotAllowed(handler http.Handler)

	// StrictSlash defines the trailing slash behavior for new routes. The initial
	// value is false.
	StrictSlash(value bool)
	// SkipClean defines the path cleaning behaviour for new routes. The initial
	// value is false. Users should be careful about which routes are not cleaned
	//
	// When true, if the route path is "/path//to", it will remain with the double
	// slash. This is helpful if you have a route like: /fetch/http://xkcd.com/534/
	//
	// When false, the path will be cleaned, so /fetch/http://xkcd.com/534/ will
	// become /fetch/http/xkcd.com/534
	SkipClean(value bool)
	// UseEncodedPath tells the router to match the encoded original path
	// to the routes.
	// For eg. "/path/foo%2Fbar/to" will match the path "/path/{var}/to".
	//
	// If not called, the router will match the unencoded path to the routes.
	// For eg. "/path/foo%2Fbar/to" will match the path "/path/foo/bar/to"
	UseEncodedPath()

	// Group creates a new router group.
	Group(path string) RouterGroup

	// Any registers a route that matches all the HTTP methods.
	// GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE.
	Any(path string, handler interface{}, r ...Renderer)
	// Get registers a new GET route with a matcher for the URL path of the get method.
	Get(path string, handler interface{}, r ...Renderer)
	// Head registers a new HEAD route with a matcher for the URL path of the get method.
	Head(path string, handler interface{}, r ...Renderer)
	// Post registers a new POST route with a matcher for the URL path of the get method.
	Post(path string, handler interface{}, r ...Renderer)
	// Put registers a new PUT route with a matcher for the URL path of the get method.
	Put(path string, handler interface{}, r ...Renderer)
	// Patch registers a new PATCH route with a matcher for the URL path of the get method.
	Patch(path string, handler interface{}, r ...Renderer)
	// Delete registers a new DELETE route with a matcher for the URL path of the get method.
	Delete(path string, handler interface{}, r ...Renderer)
	// Connect registers a new CONNECT route with a matcher for the URL path of the get method.
	Connect(path string, handler interface{}, r ...Renderer)
	// Options registers a new OPTIONS route with a matcher for the URL path of the get method.
	Options(path string, handler interface{}, r ...Renderer)
	// Trace registers a new TRACE route with a matcher for the URL path of the get method.
	Trace(path string, handler interface{}, r ...Renderer)
}

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