httpserver

type CompressionExcludeSettings struct {
	Extension []string `cfg:"extension"`
	Path      []string `cfg:"path"`
	PathRegex []string `cfg:"path_regex"`
}

type CompressionSettings struct {
	Level         string `cfg:"level"         default:"default" validate:"oneof=none default best fast 0 1 2 3 4 5 6 7 8 9"`
	Decompression bool   `cfg:"decompression" default:"true"`
	// Exclude files by path, extension, or regular expression from being considered for compression.
	// Useful if you are serving a format unknown to Gosoline.
	Exclude CompressionExcludeSettings `cfg:"exclude"`
}

type ConnectionLifeCycleAdvisor interface {
	// ShouldCloseConnection checks whether the connection to the remote address should be closed.
	ShouldCloseConnection(remoteAddr string, headers http.Header) bool
}

type ConnectionLifeCycleAdvisorSettings struct {
	Enabled                   bool          `cfg:"enabled"           default:"true"`
	MaxConnectionAge          time.Duration `cfg:"max_age"           default:"1m"`
	MaxConnectionRequestCount int           `cfg:"max_request_count" default:"0"`
}

type CustomTypeFunc struct {
	Func  validator.CustomTypeFunc
	Types []any
}

type CustomValidator struct {
	Name      string
	Validator validator.Func
}

type Definer func(ctx context.Context, config cfg.Config, logger log.Logger) (*Definitions, error)

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

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

type ErrorHandler func(statusCode int, err error) *Response

type HandlerMetadata struct {
	// Method is the route method of this Handler.
	Method string `json:"method"`
	// Path is the route path ot this handler.
	Path string `json:"path"`
}

type HandlerWithInput interface {
	HandlerWithoutInput
	GetInput() any
}

type HandlerWithMultipleBindings interface {
	HandlerWithInput
	GetBindings() []binding.Binding
}

type HandlerWithStream interface {
	GetInput() any
	Handle(ginContext *gin.Context, requestContext context.Context, request *Request) (err error)
}

type HandlerWithoutInput interface {
	Handle(requestContext context.Context, request *Request) (response *Response, err error)
}

type HealthCheckSettings struct {
	Port    int             `cfg:"port"    default:"8090"`
	Path    string          `cfg:"path"    default:"/health"`
	Timeout TimeoutSettings `cfg:"timeout"`
}

type HttpBody interface {
	string | []byte
}

type HttpServer struct {
	kernel.EssentialModule
	kernel.ApplicationStage
	// contains filtered or unexported fields
}

type HttpServerHealthCheck struct {
	kernel.BackgroundModule
	kernel.EssentialStage
	// contains filtered or unexported fields
}

type LoggingSettings struct {
	RequestBody       bool     `cfg:"request_body"`
	RequestBodyBase64 bool     `cfg:"request_body_base64"`
	RequestHeaders    []string `cfg:"request_headers"`
}

type Modifier interface {
	Struct(ctx context.Context, v any) error
}

type Profiling struct {
	kernel.BackgroundModule
	kernel.ApplicationStage
	// contains filtered or unexported fields
}

type ProfilingApiSettings struct {
	Port int `cfg:"port" default:"8091"`
}

type ProfilingSettings struct {
	Enabled bool                 `cfg:"enabled" default:"false"`
	Api     ProfilingApiSettings `cfg:"api"`
}

type ProtobufDecodable interface {
	// EmptyMessage should provide an empty instance of the message format to decode from.
	EmptyMessage() proto.Message
	// FromMessage should extract the data from the message and write it to the receiver.
	FromMessage(message proto.Message) error
}

type ProtobufEncodable interface {
	// ToMessage turns the response value into a protobuf message representation
	ToMessage() (proto.Message, error)
}

type Request struct {
	Body     any
	ClientIp string
	Cookies  map[string]string
	Header   http.Header
	Method   string
	Params   gin.Params
	Url      *url.URL
}

type Response struct {
	Body        any
	ContentType *string // might be nil
	Header      http.Header
	StatusCode  int
}

type ResponseBodyWriterError struct {
	Err error
}

type ResponseOption func(resp *Response)

type RouterSettings struct {
	UseRawPath bool `cfg:"use_raw_path" default:"false"`
}

type ServerMetadata struct {
	Name     string            `json:"name"`
	Handlers []HandlerMetadata `json:"handlers"`
}

type Settings struct {
	// Port the API listens to.
	Port string `cfg:"port"        default:"8080"`
	// Mode is either debug, release, test.
	Mode string `cfg:"mode"        default:"release" validate:"oneof=release debug test"`
	// Compression settings.
	Compression CompressionSettings `cfg:"compression"`
	// Gin Router settings.
	Router RouterSettings `cfg:"router"`
	// Timeout settings.
	Timeout TimeoutSettings `cfg:"timeout"`
	// Logging settings
	Logging LoggingSettings `cfg:"logging"`
}

type StructValidator struct {
	Struct    any
	Validator validator.StructLevelFunc
}

type TimeoutSettings struct {
	// You need to give at least 1s as timeout.
	// Read timeout is the maximum duration for reading the entire request, including the body.
	Read time.Duration `cfg:"read"     default:"60s" validate:"min=1000000000"`
	// Write timeout is the maximum duration before timing out writes of the response.
	Write time.Duration `cfg:"write"    default:"60s" validate:"min=1000000000"`
	// Idle timeout is the maximum amount of time to wait for the next request when keep-alives are enabled
	Idle time.Duration `cfg:"idle"     default:"60s" validate:"min=1000000000"`
	// Drain timeout is the maximum amount of time to wait after receiving the kernel stop signal and actually shutting down the server
	Drain time.Duration `cfg:"drain"    default:"0"   validate:"min=0"`
	// Shutdown timeout is the maximum amount of time to wait for serving active requests before stopping the server
	Shutdown time.Duration `cfg:"shutdown" default:"60s" validate:"min=1000000000"`
}

type ValidateAlias struct {
	Alias string
	Tags  string
}