httpx

type CallOption func(*callInfo)

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

type ClientOption func(*Client)

type Context interface {
	context.Context
	Vars() url.Values
	Query() url.Values
	Form() url.Values
	Header() http.Header
	Request() *http.Request
	Response() http.ResponseWriter
	Bind(interface{}) error
	BindVars(interface{}) error
	BindQuery(interface{}) error
	BindForm(interface{}) error
	Returns(interface{}, error) error
	Result(int, interface{}) error
	JSON(int, interface{}) error
	XML(int, interface{}) error
	String(int, string) error
	Blob(int, string, []byte) error
	Stream(int, string, io.Reader) error
	Reset(http.ResponseWriter, *http.Request)
	ReturnError(error)
}

type DecodeResponseFunc func(ctx context.Context, res *http.Response, out interface{}) error

type EncodeRequestFunc func(ctx context.Context, contentType string, in interface{}) (body []byte, err error)

type ErrorEncoder func(http.ResponseWriter, *http.Request, error)

type IHttpRouter interface {
	ServeHTTP(res http.ResponseWriter, req *http.Request)
	Use(mws ...middleware.HttpMiddleware)
	Group(prefix string, middlewares ...middleware.HttpMiddleware) *Router
	Handle(path string, h http.Handler)
	HandlePrefix(prefix string, h http.Handler)
	HandleFunc(path string, h http.HandlerFunc)
	HandleHeader(h http.HandlerFunc, headerPairs ...string)
}

type IRedirect interface {
	Redirect() (string, int)
}

type IRouteMethod interface {
	GET(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	HEAD(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	POST(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	PUT(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	PATCH(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	DELETE(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	CONNECT(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	OPTIONS(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
	TRACE(path string, h http.HandlerFunc, m ...middleware.HttpMiddleware)
}

type IRouter interface {
	IHttpRouter
	IRouteMethod
	WalkRoute(fn WalkRouteFunc) error
}

type IRouterCoder interface {
	BindVars() RequestDecoder
	BindQuery() RequestDecoder
	BindForm() RequestDecoder
	BindBody() RequestDecoder
	ResponseEncoder() ResponseEncoder
	ErrorEncoder() ErrorEncoder
}

type IRouterSetting interface {
	UseEncodedPath() bool
	SetUseEncodedPath(bool)
	StrictSlash() bool
	SetStrictSlash(bool)
	SkipClean() bool
	SetSkipClean(bool)
	Prefix() string
	SetPrefix(string)
	NotFoundHandler() http.Handler
	SetNotFoundHandler(handler http.Handler)
	NotAllowedHandler() http.Handler
	SetNotAllowedHandler(handler http.Handler)
}

type RequestDecoder func(*http.Request, interface{}) error

type ResponseEncoder func(int, http.ResponseWriter, *http.Request, interface{}) error

type RouteInfo struct {
	Path   string
	Method string
}

type Router struct {
	*RouterCfg
	// contains filtered or unexported fields
}

type RouterCfg struct {
	// If true, "/path/foo%2Fbar/to" will match the path "/path/{var}/to"
	UseEncodedPath bool

	// If true, when the path pattern is "/path/", accessing "/path" will
	// redirect to the former and vice versa.
	StrictSlash bool

	// If true, when the path pattern is "/path//to", accessing "/path//to"
	// will not redirect
	SkipClean bool

	// Configurable Handler to be used when no route matches.
	NotFoundHandler http.Handler

	// Configurable Handler to be used when the request method does not match the route.
	MethodNotAllowedHandler http.Handler

	RootPrefix string

	Coder IRouterCoder
}

type Server struct {
	*http.Server
	// contains filtered or unexported fields
}

type ServerOption func(*Server)

type Target struct {
	Scheme    string
	Authority string
	Endpoint  string
}

type Transport struct {
	transport.BaseTransport
	Request *http.Request
}

type WalkRouteFunc func(RouteInfo) error