http

type Chain[request any, response any] []Handler[request, response]

type Client interface {
	ExecuteRequest(req Request) Response
}

type ContentType = string

type ContentTypeMismatchError struct {
	Expected string
	Actual   string
}

type Context[request any, response any] interface {
	context.Context

	// Next calls the following handlers until abort or the end of the chain.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.Next()
	//		// do something after returned from the following handlers
	//	}
	Next()

	// Abort aborts the following handlers.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.Abort()
	//		// do something after aborted
	//	}
	Abort()

	// IsAborted returns true if the following handlers are aborted.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		if ctx.IsAborted() {
	//			// do something if aborted
	//		}
	//		// do something after aborted
	//	}
	IsAborted() bool

	// RawRequest returns the raw request.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		raw := ctx.RawRequest()
	//		// do something with raw
	//	}
	RawRequest() *http.Request

	// QueryParams returns the query params.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		params := ctx.QueryParams()
	//		// do something with params
	//	}
	QueryParams() Params

	// PathParams returns the path params.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		params := ctx.PathParams()
	//		// do something with params
	//	}
	PathParams() Params

	// HeaderParams returns the header params.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		params := ctx.HeaderParams()
	//		// do something with params
	//	}
	HeaderParams() Params

	// NormalHeaders returns the normal headers.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		headers := ctx.NormalHeaders()
	//		// do something with headers
	//	}
	NormalHeaders() RequestHeader

	// ExtraParams returns the extra params.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		params := ctx.ExtraParams()
	//		// do something with params
	//	}
	ExtraParams() Params

	// SetExtraParams sets the extra params.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.SetExtraParams("key", "value")
	//		// do something with params
	//	}
	SetExtraParams(key string, value string)

	// Request returns the processed request.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		req := ctx.Request()
	//		// do something with req
	//	}
	Request() request

	// Response returns the response.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		resp := ctx.Response()
	//		// do something with resp
	//	}
	Response() response

	// SetResponse sets the response.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.SetResponse(resp)
	//		// do something with resp
	//	}
	SetResponse(resp response)

	// ResponseHeaders returns the response headers.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		headers := ctx.ResponseHeaders()
	//		// do something with headers
	//	}
	ResponseHeaders() Params

	// SetResponseHeader sets the response header.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.SetResponseHeader("key", "value")
	//		// do something with resp
	//	}
	SetResponseHeader(key string, value string)

	// ResponseSetCookies returns the response cookies.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		cookies := ctx.ResponseSetCookies()
	//		// do something with cookies
	//	}
	ResponseSetCookies() []Cookie

	// SetResponseSetCookie sets the response cookie.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.SetResponseSetCookie(cookie)
	//		// do something with resp
	//	}
	SetResponseSetCookie(cookie Cookie)

	// StatusCode returns the status code.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		status := ctx.StatusCode()
	//		// do something with status
	//	}
	StatusCode() int

	// SetStatusCode sets the status code.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.SetStatusCode(StatusOK)
	//		// do something with status
	//	}
	SetStatusCode(status int)

	// Error returns the error.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		err := ctx.Error()
	//		// do something with err
	//	}
	Error() error

	// SetError sets the error.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.SetError(err)
	//		// do something with err
	//	}
	SetError(err error)
	// contains filtered or unexported methods
}

type ContextOpts[request any, response any] func(ctx *acContext[request, response])

type Cookie struct {
	Name     string
	Value    string
	Path     string
	Domain   string
	Expires  string
	MaxAge   int
	Secure   bool
	HttpOnly bool
}

type EndPoint[request any, response any] struct {
	// contains filtered or unexported fields
}

type EndPointInterface interface {
	// contains filtered or unexported methods
}

type EndPointOptions[request any, response any] func(ep *EndPoint[request, response])

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

type Handler[request any, response any] func(ctx Context[request, response])

type Method = string

type MethodCode = int32

type MethodNotAllowedError struct {
	Method string
}

type NecessaryCookieMissingError struct {
	Cookie string
}

type NecessaryHeaderMissingError struct {
	Header string
}

type NecessaryQueryMissingError struct {
	Query string
}

type Params map[string]string

type Request interface {
	SetUrl(path string) Request
	SetMethod(method string) Request
	SetBearerToken(token string) Request
	SetUserAgent(userAgent string) Request
	SetAccept(accept string) Request
	SetHeader(key, value string) Request
	SetJsonBody(ptr any) Request
	SetMultiPartBodyWithErrorHandler(multipartField, multipartName string, multiWriter io.Reader, others map[string]string, handler func(err error) (ignore bool)) Request
	SetMultiPartBody(multipartField, multipartName string, multiWriter io.Reader, others map[string]string) Request
	SetCookie(cookieKey, cookieValue string) Request
	// contains filtered or unexported methods
}

type RequestHeader struct {
	Accept         string
	AcceptEncoding string
	AcceptLanguage string
	UserAgent      string
	ContentType    string
	ContentLength  int
	Origin         string
	Referer        string
	Authorization  string
	ApiKey         string
}

type RequestProcessor[request any] func(raw *http.Request) (request, error)

type Response interface {
	Error() error
	Result() (status int, body []byte, err error)
	StringResult() (status int, body string, err error)
	BindJsonResult(receiver any) (status int, err error)
	BindXmlResult(receiver any) (status int, err error)
	GetHeader(key string, defaultVal ...string) (val string)
	GetBearerToken() (token string)
	GetCookie(cookieName string) (ck *http.Cookie)
	GetStatusCode() int
	GetBody() (body []byte)
	BindJsonBody(receiver any) (err error)
	BindXmlBody(receiver any) (err error)
}

type ResponseProcessor[response any] func(resp response, status int, err error) (response, int, error)

type Router interface {
	Group(sub string) Router
	FullRouterPath() string
	BaseRouterPath() string
}

type ServerAlreadyServingError struct {
	Address string
}

type Status = int

type UnsupportedAcceptError struct {
	Accept string
}

type UnsupportedContentTypeError struct {
	ContentType string
}

type UnsupportedMethodError struct {
	Method string
}

type UserAgent = string