http

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

type Client interface {
	ExecuteRequest(request RequestBuilder) (response ResponseParser, err error)
	ExecuteRawRequest(request *http.Request) (response *http.Response, err error)
}

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

	// SetExtraParam sets the extra param.
	// example:
	//
	//	func handler(ctx Context[request, response]) {
	//		// do something
	//		ctx.SetExtraParam("key", "value")
	//		// do something with params
	//	}
	SetExtraParam(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 EndPointBuilder[request, 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 EndpointGroup struct {
	// contains filtered or unexported fields
}

type EndpointPreprocessor[request any, response any] func(endpoint *EndPoint[request, response], origin *gin.Context, dest PreprocessedContext[request, response])

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

type FrameworkErrorCode = int

type FrameworkResponse struct {
	ErrorCode    int    `json:"error_code"`
	ErrorMessage string `json:"error_message"`
	RequestID    string `json:"request_id"`
	Data         any    `json:"data,omitempty"`
}

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

type Method = string

type MethodCode = int32

type MethodNotAllowedError struct {
	Method string
}

type MockOptions struct {
	Trigger func(req *http.Request) bool
	Handler func(req *http.Request) *http.Response
}

type MultipartBodyBuilder interface {
	WithFile(fileKey, fileName string, payload io.Reader) MultipartBodyBuilder
	WithForm(key, value string) MultipartBodyBuilder
	Build() (body io.Reader, contentType string, err error)
}

type NecessaryCookieMissingError struct {
	Cookie string
}

type NecessaryHeaderMissingError struct {
	Header string
}

type NecessaryQueryMissingError struct {
	Query string
}

type Params map[string]string

type PreprocessedContext[request any, response any] interface {
	context.Context
	SetQueryParams(params Params)
	SetPathParams(params Params)
	SetHeaderParams(params Params)
	SetCookieParams(params Params)
	SetExtraParams(params Params)
	SetRawRequest(raw *http.Request)
	SetRequest(req request)
	SetRequestHeader(headers RequestHeader)
}

type RequestBuilder interface {
	WithContext(ctx context.Context) RequestBuilder
	WithMethod(method Method) RequestBuilder
	WithPath(path string) RequestBuilder
	WithPathFormat(format string, args ...any) RequestBuilder
	WithPathTemplate(template string, args map[string]string) RequestBuilder
	WithQuery(key, value string) RequestBuilder
	WithQueryIgnoreEmptyValue(key, value string) RequestBuilder
	WithHeader(key, value string) RequestBuilder
	WithCookie(key, value string) RequestBuilder
	WithBody(body io.Reader) RequestBuilder
	WithJsonBody(body any) RequestBuilder
	WithUserAgent(userAgent UserAgent) RequestBuilder
	WithBearerToken(token string) RequestBuilder
	WithAccept(accept ContentType) RequestBuilder
	WithContentType(contentType ContentType) RequestBuilder
	Clone() RequestBuilder
	Build() (request *http.Request, err error)
}

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

type RequestLoggingFields struct {
	Url         string `json:"url"`
	Method      string `json:"method"`
	ContentType string `json:"content_type"`
	Body        any    `json:"body"`
}

type ResponseLoggingFields struct {
	StatusCode  int    `json:"status_code"`
	ContentType string `json:"content_type"`
	Body        any    `json:"body"`
}

type ResponseParser interface {
	RawResponse() *http.Response
	RawRequest() *http.Request
	RawBody() []byte
	Context() context.Context
	Status() (code int, message string)
	BindJson(receiver any) (bindErr error)
	BindXml(receiver any) (bindErr error)
	BindCustom(receiver any, decoder func(reader io.Reader, receiver any) error) (bindErr error)
	BindHeader(fields ...string) (header map[string][]string)
	BindCookie(fields ...string) (cookies map[string]*http.Cookie)
}

type Router interface {
	// Group returns a new router with the given sub path. sub path must begin with a slash and end without a slash.
	//
	// example:
	//	router := NewRouter("/api")
	//	subRouter := router.Group("/v1") // subRouter.FullRouterPath() == "/api/v1"
	//	subRouter2 := subRouter.Group("user") // subRouter2.FullRouterPath() == "/api/v1/user"
	//	subRouter3 := subRouter2.Group("info/") // subRouter3.FullRouterPath() == "/api/v1/user/info"
	Group(sub string) Router

	// Extend returns a new router with the given father router.
	//
	// example:
	//	router := NewRouter("/api")
	//	subRouter := NewRouter("/v1")
	//	subRouter.Extend(router) // subRouter2.FullRouterPath() == "/api/v1"
	Extend(father Router) Router

	// FullRouterPath returns the full path of the router.
	//
	// example:
	//	router := NewRouter("/api")
	//	subRouter := router.Group("/v1") // subRouter.FullRouterPath() == "/api/v1"
	FullRouterPath() string

	// BaseRouterPath returns the base path of the router.
	//
	// example:
	//	router := NewRouter("/api")
	//	subRouter := router.Group("/v1") // subRouter.BaseRouterPath() == "/v1"
	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