router

type BadRequestErr struct {
	Err     error
	In      In
	Context *Context
}

type Behaviour utils.LogLevel

type BoundHandlerFunc func(*Context) (RawResponse, error)

type ContentType interface {
	Mime() string
	Encode(any) ([]byte, error)
	Decode([]byte, any) error
	ValidateTypeSchema(utils.Logger, utils.LogLevel, reflect.Type, openapi3.Schema) error
}

type ContentTypes map[string]ContentType

type Context struct {
	Operation   SpecOperation
	Writer      http.ResponseWriter
	Request     *http.Request
	Params      *httprouter.Params
	RawResponse *RawResponse
	NextFunc    BoundHandlerFunc
}

type Group interface {
	// Use middlewares on the root handler
	Use(...Handler) Group
	// WithGroup defines a virtual group that allow defining middlewares for group of routes more easily
	WithGroup(Group) Group
	// WithOperation attaches a MiddlewareHandler for an operation ID string on the OpenAPISpec
	WithOperation(string, Handler, ...Handler) Group
	// contains filtered or unexported methods
}

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

type HandlerFunc[B, P, Q, R any] func(*Context, Request[B, P, Q]) (Response[R], error)

type In int

type JSONContentType struct{}

type LogLevel = utils.LogLevel

type MultiType[T any] utils.MultiType[T]

type Nil = utils.Nil

type OctetStreamContentType struct{}

type OpenAPIRouter interface {
	// Use middlewares on the root handler
	Use(...Handler) OpenAPIRouter
	// WithGroup defines a virtual group that allow defining middlewares for group of routes more easily
	WithGroup(Group) OpenAPIRouter
	// WithOperation attaches an MiddlewareHandler for an operation ID string on the OpenAPISpec
	WithOperation(string, Handler, ...Handler) OpenAPIRouter

	// WithContentType add to the router implementation for encoding additional content types.
	//
	// By default, the OpenAPIRouter supports the ContentTypes defined by DefaultContentTypes.
	//
	// An implementation of ContentType add support for additional content types by implementing serialization and
	// deserialization.
	WithContentType(ContentType) OpenAPIRouter

	// AsHandler validates the validity of the specified implementation with the registered OpenAPISpec.
	//
	// Returns a http.Handler and nil error if all checks passed correctly
	//
	// The returned handler can be used easily with any go http web framework as it is implementing the builtin
	// http.Handler interface.
	AsHandler() (http.Handler, error)

	// Spec returns the OpenAPI spec used by the router.
	Spec() OpenAPISpec
}

type OpenAPISpec openapi3.T

type OperationValidationOptions struct {
	// ValidatePathParams determines validation of operation request body.
	ValidateRequestBody Behaviour `json:"validateRequestBody,omitempty"`

	// ValidatePathParams determines validation of operation path params.
	ValidatePathParams Behaviour `json:"validatePathParams,omitempty"`

	// HandleAllPathParams describes the behaviour when not every path params defined in the spec is handled at least once in the handlers chain
	HandleAllPathParams Behaviour `json:"handleAllPathParams,omitempty"`

	// ValidatePathParams determines validation of operation query params.
	ValidateQueryParams Behaviour `json:"validateQueryParams,omitempty"`

	// HandleAllQueryParams describes the behaviour when not every query params defined in the spec is handled at least once in the handlers chain
	HandleAllQueryParams Behaviour `json:"handleAllQueryParams,omitempty"`

	// ValidatePathParams determines validation of operation responses.
	ValidateResponses Behaviour `json:"validateResponses,omitempty"`

	// HandleAllOperationResponses describes the behaviour when not every response defined in the spec is handled at least once in the handlers chain
	HandleAllOperationResponses Behaviour `json:"handleAllOperationResponses,omitempty"`

	// ContentTypesToSkipRuntimeValidation defines a list of content types that are skipped when validating operation request body at runtime.
	ContentTypesToSkipRuntimeValidation []string `json:"contentTypesToSkipRuntimeValidation,omitempty"`

	// RuntimeValidateResponses defines the behaviour when validating operation response body at runtime. Printing a warning to
	// the log by default. It is recommended to turn this option to Ignore in production as it can impact performance for large
	// responses, and to be used in development and testing environments.
	RuntimeValidateResponses Behaviour `json:"runtimeValidateResponses,omitempty"`
}

type Options struct {

	// When RecoverOnPanic is set to true the handlers chain provide a default recover behaviour that return status 500.
	// This feature is available and turned on by default to prevent the server from crashing when an internal panic
	// occurs in the handler chain.
	// This is a fundamental requirement of a web server to support availability.
	// While being fundamental, the default behaviour can't conform to your spec out of the box.
	// To be able to better control the behaviour during panic and the structure of the response returned to be
	// compatible with the spec it's recommended to implement it as a handler and in this case the default recover
	// behaviour can be turned off.
	RecoverOnPanic bool `json:"recoverOnPanic,omitempty"`

	// LogLevel defines what log levels should be printed to LogOutput.
	// By default, LogLevel is set to utils.Info to print all info to the log.
	// The router prints to the log only during initialization to show validation errors, warnings and useful info.
	// No printing is done after initialization.
	LogLevel LogLevel `json:"logLevel,omitempty"`

	// LogOutput defines where to write the outputs too.
	// By default, it is set to write to os.Stderr.
	// You can provide your own writer to be able to read the validation errors programmatically or to write them to
	// different destination.
	// The router prints to the log only during initialization to show validation errors, warnings and useful info.
	// No printing is done after initialization.
	LogOutput io.Writer `json:"-"`

	// OperationValidations allow defining validation for specific operations using a map of operation id to an
	// operationValidationOptions structure.
	// This option is used only to override the default operation validations options defined ny the
	// DefaultOperationValidation option.
	OperationValidations map[string]OperationValidationOptions `json:"operationValidations,omitempty"`

	// DefaultOperationValidation defines the default validations run for every operation.
	// By default, if not set the default behaviour is strict and consider any validation error to fail the entire
	// router validations.
	DefaultOperationValidation OperationValidationOptions `json:"defaultOperationValidation,omitempty"`

	// The router validates that every operation defined in the spec has an implementation.
	// MustHandleAllOperations defines the behaviour when this validation fails.
	// By default, it is set to utils.Error to propagate the error.
	// If your implementation is still in progress, and you would like to ignore unimplemented operations you can set
	// this option to utils.Warn or turn it off with utils.Off.
	MustHandleAllOperations Behaviour `json:"mustHandleAllOperations,omitempty"`

	// The router validates that every content type define in the spec has an implementation.
	// HandleAllContentTypes defines the behaviour when this validation fails.
	// By default, it is set to utils.Error to propagate the error.
	// Content types defined in the spec in operation request body and responses.
	// If your spec defines some content types that are not supported by the default router content types you can add
	// your own implementation.
	// Content type implementation is basically an implementation of ContentType interface add with
	// OpenAPIRouter.WithContentType to define serialization and deserialization behaviour.
	HandleAllContentTypes Behaviour `json:"handleAllContentTypes,omitempty"`

	// ExcludeOperations defined an array of operations that are defined in the spec but are excluded from the implementation.
	// One use for this option is when your spec defines the entire API of your app but the implementation is spread to multiple microservices.
	// With this option you can define list of operations that are to be implemented by other microservices.
	ExcludeOperations []string

	// OptionsHandler defines a handler that is called for every OPTIONS request of any path that is defined in the spec.
	// This handler allows you to define a response for OPTIONS preflight requests and control the allowed methods or set CORS headers.
	// The handler will receive the allowed methods in the `Allow` header based on the spec.
	// Set to nil to disable the automatic handling of OPTIONS requests.
	OptionsHandler http.Handler `json:"-"`
}

type PlainTextContentType struct{}

type RawResponse struct {
	// Status written with WriteHeader
	Status int
	// ContentType is the content type used to write the response
	ContentType string
	// buffered Body bytes written by calls to Write
	Body []byte
	// response Headers
	Headers http.Header
}

type Request[B, P, Q any] struct {
	Body        B
	PathParams  P
	QueryParams Q
	Headers     http.Header
}

type Response[R any] struct {
	// contains filtered or unexported fields
}

type SchemaValidationOptions struct {
	// NoEmptyInterface defines the behaviour when a schema is validated with an empty interface (any) type.
	NoEmptyInterface Behaviour `json:"noEmptyInterface,omitempty"`

	// NoStringAnyMapForObjectsSchema defines the behaviour when an object schema is validated with a string to empty interface map type (map[string]any).
	NoStringAnyMapForObjectsSchema Behaviour `json:"noStringAnyMapForObjectsSchema,omitempty"`
}

type SpecOperation struct {
	Path   string
	Method string
	*openapi3.Operation
}