middleware

type AuthServerConfig struct {
	Server string `json:"server"`
}

type BodyLimitConfig struct {
	MaxSize int64
}

type CacheControlConfig struct {
	Paths  []string
	MaxAge time.Duration
	//
	Items []*CacheControlItem
}

type CacheControlItem struct {
	Path   regexp.RegExp
	MaxAge time.Duration
}

type CorsConfig struct {
	IgnoreFunc       func(ctx *zoox.Context) bool
	AllowOrigins     []string
	AllowOriginFunc  func(origin string) bool
	AllowMethods     []string
	AllowHeaders     []string
	AllowCredentials bool
	MaxAge           int64
	ExposeHeaders    []string
}

type GzipConfig struct {
	Level int
	// Options  gzip.Options
	OptionFn gzip.Option
}

type HelmetConfig struct {
	// Next defines a function to skip this middleware when returned true.
	// Optional. Default: nil
	Next func(*zoox.Context) bool

	// XSSProtection adds some protection against cross site scripting (XSS) attacks
	// Optional. Default value "0"
	XSSProtection string

	// ContentTypeNosniff prevents the browser from doing MIME-type sniffing
	// Optional. Default value "nosniff"
	ContentTypeNosniff string

	// XFrameOptions can be used to indicate whether or not a browser should be allowed to render a page in a <frame>, <iframe> or <object> .
	// Optional. Default value "SAMEORIGIN"
	// Possible values: "SAMEORIGIN", "DENY", "ALLOW-FROM uri"
	XFrameOptions string

	// HSTSMaxAge sets the Strict-Transport-Security header to indicate how long (in seconds) browsers should remember that this site is only to be accessed using HTTPS
	// Optional. Default value 0
	HSTSMaxAge int

	// HSTSExcludeSubdomains excludes subdomains from the Strict-Transport-Security header
	HSTSExcludeSubdomains bool

	// ContentSecurityPolicy sets the Content-Security-Policy header to help prevent cross-site scripting attacks and other cross-site injections
	// Optional. Default value ""
	ContentSecurityPolicy string

	// CSPReportOnly sets the Content-Security-Policy-Report-Only header
	// Optional. Default value false
	CSPReportOnly bool

	// HSTSPreloadEnabled adds the preload directive to the Strict-Transport-Security header
	// Optional. Default value false
	HSTSPreloadEnabled bool

	// ReferrerPolicy sets the Referrer-Policy header to indicate which referrer information should be included with requests made
	// Optional. Default value "ReferrerPolicy"
	ReferrerPolicy string

	// Permissions-Policy sets the Permissions-Policy header to indicate which features are allowed to be used
	// Optional. Default value ""
	PermissionsPolicy string

	// Cross-Origin-Embedder-Policy sets the Cross-Origin-Embedder-Policy header to indicate whether a resource should be loaded as part of a document
	// Optional. Default value ""require-corp"
	CrossOriginEmbedderPolicy string

	// Cross-Origin-Opener-Policy sets the Cross-Origin-Opener-Policy header to indicate whether a resource should be opened in the same browsing context as the document
	// Optional. Default value "same-origin"
	CrossOriginOpenerPolicy string

	// Cross-Origin-Resource-Policy sets the Cross-Origin-Resource-Policy header to indicate whether a resource should be shared cross-origin
	// Optional. Default value "same-origin"
	CrossOriginResourcePolicy string

	// Origin-Agent-Cluster sets the Origin-Agent-Cluster header to indicate whether a resource should be shared cross-origin
	// Optional. Default value "?1"
	OriginAgentCluster string

	// X-DNS-Prefetch-Control sets the X-DNS-Prefetch-Control header to control DNS prefetching
	// Optional. Default value "off"
	XDNSPrefetchControl string

	// X-Download-Options sets the X-Download-Options header to prevent Internet Explorer from executing downloads in your site’s context
	// Optional. Default value "noopen"
	XDownloadOptions string

	// X-Permitted-Cross-Domain-Policies sets the X-Permitted-Cross-Domain-Policies header to indicate whether a resource should be shared cross-origin
	// Optional. Default value "none"
	XPermittedCrossDomainPolicies string
}

type InitSentryOption = sentry.ClientOptions

type PrometheusOption struct {
	Path string
}

type ProxyConfig struct {
	proxy.Config

	ErrorPages ProxyErrorPages
}

type ProxyErrorPages struct {
	NotFound             string
	InternalServiceError string
	BadGateway           string
	ServiceUnavailable   string
	GatewayTimeout       string
}

type ProxyGroupRewrite struct {
	Name    string       `yaml:"name" json:"name"`
	RegExp  string       `yaml:"regexp" json:"regexp"`
	Rewrite ProxyRewrite `yaml:"rewrite" json:"rewrite"`
}

type ProxyGroupRewrites []ProxyGroupRewrite

type ProxyGroupsConfig struct {
	// Rewrites map[string]ProxyRewrite
	Rewrites ProxyGroupRewrites `yaml:"rewrites" json:"rewrites"`
}

type ProxyRewrite struct {
	Target   string            `yaml:"target" json:"target"`
	Rewrites ProxyRewriteRules `yaml:"rewrites" json:"rewrites"`
}

type ProxyRewriteRules = rewriter.Rewriters

type ProxySingleTargetConfig struct {
	// internal proxy config
	proxy.SingleHostConfig

	// target url
	Target string
}

type RateLimitConfig struct {
	Period time.Duration
	Limit  int64
	//
	Namespace string
	//
	RedisHost     string
	RedisPort     int
	RedisDB       int
	RedisPassword string
}

type RewriteConfig struct {
	Rewrites rewriter.Rewriters
}

type SentryOption struct {
	// Repanic configures whether Sentry should repanic after recovery, in most cases it should be set to true,
	// as zoox includes it's own Recover middleware what handles http responses.
	Repanic bool
	// WaitForDelivery configures whether you want to block the request before moving forward with the response.
	// Because Zoox's Recover handler doesn't restart the application,
	// it's safe to either skip this option or set it to false.
	WaitForDelivery bool
	// Timeout for the event delivery requests.
	Timeout time.Duration
}

type StaticCacheConfig struct {
	// MaxAge is the duration that client caches the static file.
	// Default is 365 days.
	MaxAge time.Duration

	// RegExp is the regular expression that matches the static file.
	// Default is "\\.(css|js|ico|jpg|png|jpeg|webp|gif|socket|ws|map|webmanifest)$"
	RegExp string
}