webserver

type Csver interface {
	AsCsv() []byte
}

type Error struct {
	Code  uint
	Error error
}

type EventStreamHandler func(req *Request) <-chan EventStreamer

type EventStreamer interface {
	AsEventStream() string
}

type FormDataParser interface {
	ParseFormData(io.Reader) *Error
}

type Htmler interface {
	AsHtml() []byte
}

type InMemorySessionStore[T any] struct {
	Sessions map[string]T
	// contains filtered or unexported fields
}

type Jsoner interface {
	AsJson() []byte
}

type Logger interface {
	LogRequest(req *Request)
	LogMessage(req *Request, msg any)
	LogPanic(req *Request, p any)
	LogError(req *Request, err error)
}

type Middleware func(req *Request) *Error

type MultipartFormDataParser interface {
	ParseMultipartFormData(io.Reader, string) *Error
}

type PlainTextParser interface {
	ParsePlainText(io.Reader) *Error
}

type Request struct {
	Session interface{}
	Verb    Verb
	Path    string
	Headers http.Header
	Cookies []*http.Cookie

	Body            interface{} // TODO: generic without breaking Request logic?
	Context         context.Context
	ResponseHeaders http.Header
	ResponseCode    int
	// contains filtered or unexported fields
}

type RequestBody struct {
	url.Values
	Files map[string][]multipart.File
}

type Route[B any, T any] struct {
	// contains filtered or unexported fields
}

type Server[S any] struct {
	Logger       defaultLogger
	SecureConfig *tls.Config
	MaxPostSize  uint
	// contains filtered or unexported fields
}

type Session[T any] struct {
	Token string
	Data  *T
	// contains filtered or unexported fields
}

type SessionStore interface {
	ParseToken(http.Header) string
	Get(token string) (interface{}, error)
	Save(token string, data interface{}) error
	Delete(token string) error
}

type SessionStoreContext interface {
	GetCtx(token string, ctx context.Context) (interface{}, error)
	SaveCtx(token string, data interface{}, ctx context.Context) error
	DeleteCtx(token string, ctx context.Context) error
}

type Sessionless struct{}

type Verb byte

type WebsocketHandler func(req *Request, inFeed <-chan []byte) <-chan []byte