const (
    AlgorithmHS256 = "HS256"
)

const GZIPEncoding string = "gzip"

const (
    // SameSiteNoneMode required to be redefined for Go 1.12 support (see #1524)
    SameSiteNoneMode http.SameSite = http.SameSiteNoneMode
)

var (
    ErrJWTMissing = echo.NewHTTPError(http.StatusBadRequest, "missing or malformed jwt")
    ErrJWTInvalid = echo.NewHTTPError(http.StatusUnauthorized, "invalid or expired jwt")
)

var (
    // ErrRateLimitExceeded denotes an error raised when rate limit is exceeded
    ErrRateLimitExceeded = echo.NewHTTPError(http.StatusTooManyRequests, "rate limit exceeded")
    // ErrExtractorError denotes an error raised when extractor function is unsuccessful
    ErrExtractorError = echo.NewHTTPError(http.StatusForbidden, "error while extracting identifier")
)

var (
    // DefaultBasicAuthConfig is the default BasicAuth middleware config.
    DefaultBasicAuthConfig = BasicAuthConfig{
        Skipper: DefaultSkipper,
        Realm:   defaultRealm,
    }
)

var (
    // DefaultBodyDumpConfig is the default BodyDump middleware config.
    DefaultBodyDumpConfig = BodyDumpConfig{
        Skipper: DefaultSkipper,
    }
)

var (
    // DefaultBodyLimitConfig is the default BodyLimit middleware config.
    DefaultBodyLimitConfig = BodyLimitConfig{
        Skipper: DefaultSkipper,
    }
)

var (
    // DefaultCORSConfig is the default CORS middleware config.
    DefaultCORSConfig = CORSConfig{
        Skipper:      DefaultSkipper,
        AllowOrigins: []string{"*"},
        AllowMethods: []string{http.MethodGet, http.MethodHead, http.MethodPut, http.MethodPatch, http.MethodPost, http.MethodDelete},
    }
)

var (
    // DefaultCSRFConfig is the default CSRF middleware config.
    DefaultCSRFConfig = CSRFConfig{
        Skipper:        DefaultSkipper,
        TokenLength:    32,
        TokenLookup:    "header:" + echo.HeaderXCSRFToken,
        ContextKey:     "csrf",
        CookieName:     "_csrf",
        CookieMaxAge:   86400,
        CookieSameSite: http.SameSiteDefaultMode,
    }
)

var (
    //DefaultDecompressConfig defines the config for decompress middleware
    DefaultDecompressConfig = DecompressConfig{
        Skipper:            DefaultSkipper,
        GzipDecompressPool: &DefaultGzipDecompressPool{},
    }
)

var (
    // DefaultGzipConfig is the default Gzip middleware config.
    DefaultGzipConfig = GzipConfig{
        Skipper: DefaultSkipper,
        Level:   -1,
    }
)

var (
    // DefaultJWTConfig is the default JWT auth middleware config.
    DefaultJWTConfig = JWTConfig{
        Skipper:       DefaultSkipper,
        SigningMethod: AlgorithmHS256,
        ContextKey:    "user",
        TokenLookup:   "header:" + echo.HeaderAuthorization,
        AuthScheme:    "Bearer",
        Claims:        jwt.MapClaims{},
    }
)

var (
    // DefaultKeyAuthConfig is the default KeyAuth middleware config.
    DefaultKeyAuthConfig = KeyAuthConfig{
        Skipper:    DefaultSkipper,
        KeyLookup:  "header:" + echo.HeaderAuthorization,
        AuthScheme: "Bearer",
    }
)

var (
    // DefaultLoggerConfig is the default Logger middleware config.
    DefaultLoggerConfig = LoggerConfig{
        Skipper: DefaultSkipper,
        Format: `{"time":"${time_rfc3339_nano}","id":"${id}","remote_ip":"${remote_ip}",` +
            `"host":"${host}","method":"${method}","uri":"${uri}","user_agent":"${user_agent}",` +
            `"status":${status},"error":"${error}","latency":${latency},"latency_human":"${latency_human}"` +
            `,"bytes_in":${bytes_in},"bytes_out":${bytes_out}}` + "\n",
        CustomTimeFormat: "2006-01-02 15:04:05.00000",
        // contains filtered or unexported fields
    }
)

var (
    // DefaultMethodOverrideConfig is the default MethodOverride middleware config.
    DefaultMethodOverrideConfig = MethodOverrideConfig{
        Skipper: DefaultSkipper,
        Getter:  MethodFromHeader(echo.HeaderXHTTPMethodOverride),
    }
)

var (
    // DefaultProxyConfig is the default Proxy middleware config.
    DefaultProxyConfig = ProxyConfig{
        Skipper:    DefaultSkipper,
        ContextKey: "target",
    }
)

var DefaultRateLimiterConfig = RateLimiterConfig{
    Skipper: DefaultSkipper,
    IdentifierExtractor: func(ctx echo.Context) (string, error) {
        id := ctx.RealIP()
        return id, nil
    },
    ErrorHandler: func(context echo.Context, err error) error {
        return &echo.HTTPError{
            Code:     ErrExtractorError.Code,
            Message:  ErrExtractorError.Message,
            Internal: err,
        }
    },
    DenyHandler: func(context echo.Context, identifier string, err error) error {
        return &echo.HTTPError{
            Code:     ErrRateLimitExceeded.Code,
            Message:  ErrRateLimitExceeded.Message,
            Internal: err,
        }
    },
}

var DefaultRateLimiterMemoryStoreConfig = RateLimiterMemoryStoreConfig{
    ExpiresIn: 3 * time.Minute,
}

var (
    // DefaultRecoverConfig is the default Recover middleware config.
    DefaultRecoverConfig = RecoverConfig{
        Skipper:           DefaultSkipper,
        StackSize:         4 << 10,
        DisableStackAll:   false,
        DisablePrintStack: false,
        LogLevel:          0,
    }
)

var DefaultRedirectConfig = RedirectConfig{
    Skipper: DefaultSkipper,
    Code:    http.StatusMovedPermanently,
}

var (
    // DefaultRequestIDConfig is the default RequestID middleware config.
    DefaultRequestIDConfig = RequestIDConfig{
        Skipper:   DefaultSkipper,
        Generator: generator,
    }
)

var (
    // DefaultRewriteConfig is the default Rewrite middleware config.
    DefaultRewriteConfig = RewriteConfig{
        Skipper: DefaultSkipper,
    }
)

var (
    // DefaultSecureConfig is the default Secure middleware config.
    DefaultSecureConfig = SecureConfig{
        Skipper:            DefaultSkipper,
        XSSProtection:      "1; mode=block",
        ContentTypeNosniff: "nosniff",
        XFrameOptions:      "SAMEORIGIN",
        HSTSPreloadEnabled: false,
    }
)

var (
    // DefaultStaticConfig is the default Static middleware config.
    DefaultStaticConfig = StaticConfig{
        Skipper: DefaultSkipper,
        Index:   "index.html",
    }
)

var (
    // DefaultTimeoutConfig is the default Timeout middleware config.
    DefaultTimeoutConfig = TimeoutConfig{
        Skipper:      DefaultSkipper,
        Timeout:      0,
        ErrorHandler: nil,
    }
)

var (
    // DefaultTrailingSlashConfig is the default TrailingSlash middleware config.
    DefaultTrailingSlashConfig = TrailingSlashConfig{
        Skipper: DefaultSkipper,
    }
)

type BasicAuthConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Validator is a function to validate BasicAuth credentials.
    // Required.
    Validator BasicAuthValidator

    // Realm is a string to define realm attribute of BasicAuth.
    // Default value "Restricted".
    Realm string
}

type BasicAuthValidator func(string, string, echo.Context) (bool, error)

type BeforeFunc func(echo.Context)

type BodyDumpConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Handler receives request and response payload.
    // Required.
    Handler BodyDumpHandler
}

type BodyDumpHandler func(echo.Context, []byte, []byte)

type BodyLimitConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Maximum allowed size for a request body, it can be specified
    // as `4x` or `4xB`, where x is one of the multiple from K, M, G, T or P.
    Limit string `yaml:"limit"`
    // contains filtered or unexported fields
}

type CORSConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // AllowOrigin defines a list of origins that may access the resource.
    // Optional. Default value []string{"*"}.
    AllowOrigins []string `yaml:"allow_origins"`

    // AllowOriginFunc is a custom function to validate the origin. It takes the
    // origin as an argument and returns true if allowed or false otherwise. If
    // an error is returned, it is returned by the handler. If this option is
    // set, AllowOrigins is ignored.
    // Optional.
    AllowOriginFunc func(origin string) (bool, error) `yaml:"allow_origin_func"`

    // AllowMethods defines a list methods allowed when accessing the resource.
    // This is used in response to a preflight request.
    // Optional. Default value DefaultCORSConfig.AllowMethods.
    AllowMethods []string `yaml:"allow_methods"`

    // AllowHeaders defines a list of request headers that can be used when
    // making the actual request. This is in response to a preflight request.
    // Optional. Default value []string{}.
    AllowHeaders []string `yaml:"allow_headers"`

    // AllowCredentials indicates whether or not the response to the request
    // can be exposed when the credentials flag is true. When used as part of
    // a response to a preflight request, this indicates whether or not the
    // actual request can be made using credentials.
    // Optional. Default value false.
    AllowCredentials bool `yaml:"allow_credentials"`

    // ExposeHeaders defines a whitelist headers that clients are allowed to
    // access.
    // Optional. Default value []string{}.
    ExposeHeaders []string `yaml:"expose_headers"`

    // MaxAge indicates how long (in seconds) the results of a preflight request
    // can be cached.
    // Optional. Default value 0.
    MaxAge int `yaml:"max_age"`
}

type CSRFConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // TokenLength is the length of the generated token.
    TokenLength uint8 `yaml:"token_length"`

    // TokenLookup is a string in the form of "<source>:<key>" that is used
    // to extract token from the request.
    // Optional. Default value "header:X-CSRF-Token".
    // Possible values:
    // - "header:<name>"
    // - "form:<name>"
    // - "query:<name>"
    TokenLookup string `yaml:"token_lookup"`

    // Context key to store generated CSRF token into context.
    // Optional. Default value "csrf".
    ContextKey string `yaml:"context_key"`

    // Name of the CSRF cookie. This cookie will store CSRF token.
    // Optional. Default value "csrf".
    CookieName string `yaml:"cookie_name"`

    // Domain of the CSRF cookie.
    // Optional. Default value none.
    CookieDomain string `yaml:"cookie_domain"`

    // Path of the CSRF cookie.
    // Optional. Default value none.
    CookiePath string `yaml:"cookie_path"`

    // Max age (in seconds) of the CSRF cookie.
    // Optional. Default value 86400 (24hr).
    CookieMaxAge int `yaml:"cookie_max_age"`

    // Indicates if CSRF cookie is secure.
    // Optional. Default value false.
    CookieSecure bool `yaml:"cookie_secure"`

    // Indicates if CSRF cookie is HTTP only.
    // Optional. Default value false.
    CookieHTTPOnly bool `yaml:"cookie_http_only"`

    // Indicates SameSite mode of the CSRF cookie.
    // Optional. Default value SameSiteDefaultMode.
    CookieSameSite http.SameSite `yaml:"cookie_same_site"`
}

type DecompressConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // GzipDecompressPool defines an interface to provide the sync.Pool used to create/store Gzip readers
    GzipDecompressPool Decompressor
}

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

type DefaultGzipDecompressPool struct {
}

type Extractor func(context echo.Context) (string, error)

type GzipConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Gzip compression level.
    // Optional. Default value -1.
    Level int `yaml:"level"`
}

type JWTConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // BeforeFunc defines a function which is executed just before the middleware.
    BeforeFunc BeforeFunc

    // SuccessHandler defines a function which is executed for a valid token.
    SuccessHandler JWTSuccessHandler

    // ErrorHandler defines a function which is executed for an invalid token.
    // It may be used to define a custom JWT error.
    ErrorHandler JWTErrorHandler

    // ErrorHandlerWithContext is almost identical to ErrorHandler, but it's passed the current context.
    ErrorHandlerWithContext JWTErrorHandlerWithContext

    // Signing key to validate token. Used as fallback if SigningKeys has length 0.
    // Required. This or SigningKeys.
    SigningKey interface{}

    // Map of signing keys to validate token with kid field usage.
    // Required. This or SigningKey.
    SigningKeys map[string]interface{}

    // Signing method, used to check token signing method.
    // Optional. Default value HS256.
    SigningMethod string

    // Context key to store user information from the token into context.
    // Optional. Default value "user".
    ContextKey string

    // Claims are extendable claims data defining token content.
    // Optional. Default value jwt.MapClaims
    Claims jwt.Claims

    // TokenLookup is a string in the form of "<source>:<name>" that is used
    // to extract token from the request.
    // Optional. Default value "header:Authorization".
    // Possible values:
    // - "header:<name>"
    // - "query:<name>"
    // - "param:<name>"
    // - "cookie:<name>"
    // - "form:<name>"
    TokenLookup string

    // AuthScheme to be used in the Authorization header.
    // Optional. Default value "Bearer".
    AuthScheme string
    // contains filtered or unexported fields
}

type JWTErrorHandler func(error) error

type JWTErrorHandlerWithContext func(error, echo.Context) error

type JWTSuccessHandler func(echo.Context)

type KeyAuthConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // KeyLookup is a string in the form of "<source>:<name>" that is used
    // to extract key from the request.
    // Optional. Default value "header:Authorization".
    // Possible values:
    // - "header:<name>"
    // - "query:<name>"
    // - "form:<name>"
    KeyLookup string `yaml:"key_lookup"`

    // AuthScheme to be used in the Authorization header.
    // Optional. Default value "Bearer".
    AuthScheme string

    // Validator is a function to validate key.
    // Required.
    Validator KeyAuthValidator
}

type KeyAuthValidator func(string, echo.Context) (bool, error)

type LoggerConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Tags to construct the logger format.
    //
    // - time_unix
    // - time_unix_nano
    // - time_rfc3339
    // - time_rfc3339_nano
    // - time_custom
    // - id (Request ID)
    // - remote_ip
    // - uri
    // - host
    // - method
    // - path
    // - protocol
    // - referer
    // - user_agent
    // - status
    // - error
    // - latency (In nanoseconds)
    // - latency_human (Human readable)
    // - bytes_in (Bytes received)
    // - bytes_out (Bytes sent)
    // - header:<NAME>
    // - query:<NAME>
    // - form:<NAME>
    //
    // Example "${remote_ip} ${status}"
    //
    // Optional. Default value DefaultLoggerConfig.Format.
    Format string `yaml:"format"`

    // Optional. Default value DefaultLoggerConfig.CustomTimeFormat.
    CustomTimeFormat string `yaml:"custom_time_format"`

    // Output is a writer where logs in JSON format are written.
    // Optional. Default value os.Stdout.
    Output io.Writer
    // contains filtered or unexported fields
}

type MethodOverrideConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Getter is a function that gets overridden method from the request.
    // Optional. Default values MethodFromHeader(echo.HeaderXHTTPMethodOverride).
    Getter MethodOverrideGetter
}

type MethodOverrideGetter func(echo.Context) string

type ProxyBalancer interface {
    AddTarget(*ProxyTarget) bool
    RemoveTarget(string) bool
    Next(echo.Context) *ProxyTarget
}

type ProxyConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Balancer defines a load balancing technique.
    // Required.
    Balancer ProxyBalancer

    // Rewrite defines URL path rewrite rules. The values captured in asterisk can be
    // retrieved by index e.g. $1, $2 and so on.
    // Examples:
    // "/old":              "/new",
    // "/api/*":            "/$1",
    // "/js/*":             "/public/javascripts/$1",
    // "/users/*/orders/*": "/user/$1/order/$2",
    Rewrite map[string]string

    // Context key to store selected ProxyTarget into context.
    // Optional. Default value "target".
    ContextKey string

    // To customize the transport to remote.
    // Examples: If custom TLS certificates are required.
    Transport http.RoundTripper

    // ModifyResponse defines function to modify response from ProxyTarget.
    ModifyResponse func(*http.Response) error
    // contains filtered or unexported fields
}

type ProxyTarget struct {
    Name string
    URL  *url.URL
    Meta echo.Map
}

type RateLimiterConfig struct {
    Skipper    Skipper
    BeforeFunc BeforeFunc
    // IdentifierExtractor uses echo.Context to extract the identifier for a visitor
    IdentifierExtractor Extractor
    // Store defines a store for the rate limiter
    Store RateLimiterStore
    // ErrorHandler provides a handler to be called when IdentifierExtractor returns an error
    ErrorHandler func(context echo.Context, err error) error
    // DenyHandler provides a handler to be called when RateLimiter denies access
    DenyHandler func(context echo.Context, identifier string, err error) error
}

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

type RateLimiterMemoryStoreConfig struct {
    Rate      rate.Limit    // Rate of requests allowed to pass as req/s
    Burst     int           // Burst additionally allows a number of requests to pass when rate limit is reached
    ExpiresIn time.Duration // ExpiresIn is the duration after that a rate limiter is cleaned up
}

type RateLimiterStore interface {
    // Stores for the rate limiter have to implement the Allow method
    Allow(identifier string) (bool, error)
}

type RecoverConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Size of the stack to be printed.
    // Optional. Default value 4KB.
    StackSize int `yaml:"stack_size"`

    // DisableStackAll disables formatting stack traces of all other goroutines
    // into buffer after the trace for the current goroutine.
    // Optional. Default value false.
    DisableStackAll bool `yaml:"disable_stack_all"`

    // DisablePrintStack disables printing stack trace.
    // Optional. Default value as false.
    DisablePrintStack bool `yaml:"disable_print_stack"`

    // LogLevel is log level to printing stack trace.
    // Optional. Default value 0 (Print).
    LogLevel log.Lvl
}

type RedirectConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper

    // Status code to be used when redirecting the request.
    // Optional. Default value http.StatusMovedPermanently.
    Code int `yaml:"code"`
}

type RequestIDConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Generator defines a function to generate an ID.
    // Optional. Default value random.String(32).
    Generator func() string
}

type RewriteConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Rules defines the URL path rewrite rules. The values captured in asterisk can be
    // retrieved by index e.g. $1, $2 and so on.
    // Example:
    // "/old":              "/new",
    // "/api/*":            "/$1",
    // "/js/*":             "/public/javascripts/$1",
    // "/users/*/orders/*": "/user/$1/order/$2",
    // Required.
    Rules map[string]string `yaml:"rules"`
    // contains filtered or unexported fields
}

type SecureConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // XSSProtection provides protection against cross-site scripting attack (XSS)
    // by setting the `X-XSS-Protection` header.
    // Optional. Default value "1; mode=block".
    XSSProtection string `yaml:"xss_protection"`

    // ContentTypeNosniff provides protection against overriding Content-Type
    // header by setting the `X-Content-Type-Options` header.
    // Optional. Default value "nosniff".
    ContentTypeNosniff string `yaml:"content_type_nosniff"`

    // XFrameOptions can be used to indicate whether or not a browser should
    // be allowed to render a page in a <frame>, <iframe> or <object> .
    // Sites can use this to avoid clickjacking attacks, by ensuring that their
    // content is not embedded into other sites.provides protection against
    // clickjacking.
    // Optional. Default value "SAMEORIGIN".
    // Possible values:
    // - "SAMEORIGIN" - The page can only be displayed in a frame on the same origin as the page itself.
    // - "DENY" - The page cannot be displayed in a frame, regardless of the site attempting to do so.
    // - "ALLOW-FROM uri" - The page can only be displayed in a frame on the specified origin.
    XFrameOptions string `yaml:"x_frame_options"`

    // 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. This reduces your exposure to some SSL-stripping
    // man-in-the-middle (MITM) attacks.
    // Optional. Default value 0.
    HSTSMaxAge int `yaml:"hsts_max_age"`

    // HSTSExcludeSubdomains won't include subdomains tag in the `Strict Transport Security`
    // header, excluding all subdomains from security policy. It has no effect
    // unless HSTSMaxAge is set to a non-zero value.
    // Optional. Default value false.
    HSTSExcludeSubdomains bool `yaml:"hsts_exclude_subdomains"`

    // ContentSecurityPolicy sets the `Content-Security-Policy` header providing
    // security against cross-site scripting (XSS), clickjacking and other code
    // injection attacks resulting from execution of malicious content in the
    // trusted web page context.
    // Optional. Default value "".
    ContentSecurityPolicy string `yaml:"content_security_policy"`

    // CSPReportOnly would use the `Content-Security-Policy-Report-Only` header instead
    // of the `Content-Security-Policy` header. This allows iterative updates of the
    // content security policy by only reporting the violations that would
    // have occurred instead of blocking the resource.
    // Optional. Default value false.
    CSPReportOnly bool `yaml:"csp_report_only"`

    // HSTSPreloadEnabled will add the preload tag in the `Strict Transport Security`
    // header, which enables the domain to be included in the HSTS preload list
    // maintained by Chrome (and used by Firefox and Safari): https://hstspreload.org/
    // Optional.  Default value false.
    HSTSPreloadEnabled bool `yaml:"hsts_preload_enabled"`

    // ReferrerPolicy sets the `Referrer-Policy` header providing security against
    // leaking potentially sensitive request paths to third parties.
    // Optional. Default value "".
    ReferrerPolicy string `yaml:"referrer_policy"`
}

type Skipper func(echo.Context) bool

type StaticConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Root directory from where the static content is served.
    // Required.
    Root string `yaml:"root"`

    // Index file for serving a directory.
    // Optional. Default value "index.html".
    Index string `yaml:"index"`

    // Enable HTML5 mode by forwarding all not-found requests to root so that
    // SPA (single-page application) can handle the routing.
    // Optional. Default value false.
    HTML5 bool `yaml:"html5"`

    // Enable directory browsing.
    // Optional. Default value false.
    Browse bool `yaml:"browse"`

    // Enable ignoring of the base of the URL path.
    // Example: when assigning a static middleware to a non root path group,
    // the filesystem path is not doubled
    // Optional. Default value false.
    IgnoreBase bool `yaml:"ignoreBase"`
}

type TimeoutConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper
    // ErrorHandler defines a function which is executed for a timeout
    // It can be used to define a custom timeout error
    ErrorHandler TimeoutErrorHandlerWithContext
    // Timeout configures a timeout for the middleware, defaults to 0 for no timeout
    Timeout time.Duration
}

type TimeoutErrorHandlerWithContext func(error, echo.Context) error

type TrailingSlashConfig struct {
    // Skipper defines a function to skip middleware.
    Skipper Skipper

    // Status code to be used when redirecting the request.
    // Optional, but when provided the request is redirected using this code.
    RedirectCode int `yaml:"redirect_code"`
}

type Visitor struct {
    *rate.Limiter
    // contains filtered or unexported fields
}