const (
    StatusContinue             = 100 // RFC 7231, 6.2.1
    StatusSwitchingProtocols   = 101 // RFC 7231, 6.2.2
    StatusProcessing           = 102 // RFC 2518, 10.1
    StatusEarlyHints           = 103 // RFC 8297
    StatusOK                   = 200 // RFC 7231, 6.3.1
    StatusCreated              = 201 // RFC 7231, 6.3.2
    StatusAccepted             = 202 // RFC 7231, 6.3.3
    StatusNonAuthoritativeInfo = 203 // RFC 7231, 6.3.4
    StatusNoContent            = 204 // RFC 7231, 6.3.5
    StatusResetContent         = 205 // RFC 7231, 6.3.6
    StatusPartialContent       = 206 // RFC 7233, 4.1
    StatusMultiStatus          = 207 // RFC 4918, 11.1
    StatusAlreadyReported      = 208 // RFC 5842, 7.1
    StatusIMUsed               = 226 // RFC 3229, 10.4.1

    StatusMultipleChoices  = 300 // RFC 7231, 6.4.1
    StatusMovedPermanently = 301 // RFC 7231, 6.4.2
    StatusFound            = 302 // RFC 7231, 6.4.3
    StatusSeeOther         = 303 // RFC 7231, 6.4.4
    StatusNotModified      = 304 // RFC 7232, 4.1
    StatusUseProxy         = 305 // RFC 7231, 6.4.5

    StatusTemporaryRedirect = 307 // RFC 7231, 6.4.7
    StatusPermanentRedirect = 308 // RFC 7538, 3

    StatusBadRequest                   = 400 // RFC 7231, 6.5.1
    StatusUnauthorized                 = 401 // RFC 7235, 3.1
    StatusPaymentRequired              = 402 // RFC 7231, 6.5.2
    StatusForbidden                    = 403 // RFC 7231, 6.5.3
    StatusNotFound                     = 404 // RFC 7231, 6.5.4
    StatusMethodNotAllowed             = 405 // RFC 7231, 6.5.5
    StatusNotAcceptable                = 406 // RFC 7231, 6.5.6
    StatusProxyAuthRequired            = 407 // RFC 7235, 3.2
    StatusRequestTimeout               = 408 // RFC 7231, 6.5.7
    StatusConflict                     = 409 // RFC 7231, 6.5.8
    StatusGone                         = 410 // RFC 7231, 6.5.9
    StatusLengthRequired               = 411 // RFC 7231, 6.5.10
    StatusPreconditionFailed           = 412 // RFC 7232, 4.2
    StatusRequestEntityTooLarge        = 413 // RFC 7231, 6.5.11
    StatusPayloadTooRage               = StatusRequestEntityTooLarge
    StatusRequestURITooLong            = 414 // RFC 7231, 6.5.12
    StatusUnsupportedMediaType         = 415 // RFC 7231, 6.5.13
    StatusRequestedRangeNotSatisfiable = 416 // RFC 7233, 4.4
    StatusExpectationFailed            = 417 // RFC 7231, 6.5.14
    StatusTeapot                       = 418 // RFC 7168, 2.3.3
    StatusMisdirectedRequest           = 421 // RFC 7540, 9.1.2
    StatusUnprocessableEntity          = 422 // RFC 4918, 11.2
    StatusLocked                       = 423 // RFC 4918, 11.3
    StatusFailedDependency             = 424 // RFC 4918, 11.4
    StatusTooEarly                     = 425 // RFC 8470, 5.2.
    StatusUpgradeRequired              = 426 // RFC 7231, 6.5.15
    StatusPreconditionRequired         = 428 // RFC 6585, 3
    StatusTooManyRequests              = 429 // RFC 6585, 4
    StatusRequestHeaderFieldsTooLarge  = 431 // RFC 6585, 5
    StatusUnavailableForLegalReasons   = 451 // RFC 7725, 3
    // Unofficial Client Errors.
    StatusPageExpired                      = context.StatusPageExpired
    StatusBlockedByWindowsParentalControls = context.StatusBlockedByWindowsParentalControls
    StatusInvalidToken                     = context.StatusInvalidToken
    StatusTokenRequired                    = context.StatusTokenRequired
    //
    StatusInternalServerError           = 500 // RFC 7231, 6.6.1
    StatusNotImplemented                = 501 // RFC 7231, 6.6.2
    StatusBadGateway                    = 502 // RFC 7231, 6.6.3
    StatusServiceUnavailable            = 503 // RFC 7231, 6.6.4
    StatusGatewayTimeout                = 504 // RFC 7231, 6.6.5
    StatusHTTPVersionNotSupported       = 505 // RFC 7231, 6.6.6
    StatusVariantAlsoNegotiates         = 506 // RFC 2295, 8.1
    StatusInsufficientStorage           = 507 // RFC 4918, 11.5
    StatusLoopDetected                  = 508 // RFC 5842, 7.2
    StatusNotExtended                   = 510 // RFC 2774, 7
    StatusNetworkAuthenticationRequired = 511 // RFC 6585, 6
    // Unofficial Server Errors.
    StatusBandwidthLimitExceeded = context.StatusBandwidthLimitExceeded
    StatusInvalidSSLCertificate  = context.StatusInvalidSSLCertificate
    StatusSiteOverloaded         = context.StatusSiteOverloaded
    StatusSiteFrozen             = context.StatusSiteFrozen
    StatusNetworkReadTimeout     = context.StatusNetworkReadTimeout
)

const (
    MethodGet     = "GET"
    MethodPost    = "POST"
    MethodPut     = "PUT"
    MethodDelete  = "DELETE"
    MethodConnect = "CONNECT"
    MethodHead    = "HEAD"
    MethodPatch   = "PATCH"
    MethodOptions = "OPTIONS"
    MethodTrace   = "TRACE"
)

const (
    // RouteOverride replaces an existing route with the new one, the default rule.
    RouteOverride = router.RouteOverride
    // RouteSkip keeps the original route and skips the new one.
    RouteSkip = router.RouteSkip
    // RouteError log when a route already exists, shown after the `Build` state,
    // server never starts.
    RouteError = router.RouteError
    // RouteOverlap will overlap the new route to the previous one.
    // If the route stopped and its response can be reset then the new route will be execute.
    RouteOverlap = router.RouteOverlap
)

const (
    ReferrerInvalid  = context.ReferrerInvalid
    ReferrerIndirect = context.ReferrerIndirect
    ReferrerDirect   = context.ReferrerDirect
    ReferrerEmail    = context.ReferrerEmail
    ReferrerSearch   = context.ReferrerSearch
    ReferrerSocial   = context.ReferrerSocial

    ReferrerNotGoogleSearch     = context.ReferrerNotGoogleSearch
    ReferrerGoogleOrganicSearch = context.ReferrerGoogleOrganicSearch
    ReferrerGoogleAdwords       = context.ReferrerGoogleAdwords
)

const (
    B   = 1 << (10 * iota)
    KB
    MB
    GB
    TB
    PB
    EB
)

const MethodNone = "NONE"

const NoLayout = view.NoLayout

const Version = "12.1.8"

var (
    // HTML view engine.
    // Shortcut of the kataras/iris/view.HTML.
    HTML = view.HTML
    // Django view engine.
    // Shortcut of the kataras/iris/view.Django.
    Django = view.Django
    // Handlebars view engine.
    // Shortcut of the kataras/iris/view.Handlebars.
    Handlebars = view.Handlebars
    // Pug view engine.
    // Shortcut of the kataras/iris/view.Pug.
    Pug = view.Pug
    // Amber view engine.
    // Shortcut of the kataras/iris/view.Amber.
    Amber = view.Amber
    // Jet view engine.
    // Shortcut of the kataras/iris/view.Jet.
    Jet = view.Jet
)

var (
    // LimitRequestBodySize is a middleware which sets a request body size limit
    // for all next handlers in the chain.
    //
    // A shortcut for the `context#LimitRequestBodySize`.
    LimitRequestBodySize = context.LimitRequestBodySize
    // NewConditionalHandler returns a single Handler which can be registered
    // as a middleware.
    // Filter is just a type of Handler which returns a boolean.
    // Handlers here should act like middleware, they should contain `ctx.Next` to proceed
    // to the next handler of the chain. Those "handlers" are registered to the per-request context.
    //
    //
    // It checks the "filter" and if passed then
    // it, correctly, executes the "handlers".
    //
    // If passed, this function makes sure that the Context's information
    // about its per-request handler chain based on the new "handlers" is always updated.
    //
    // If not passed, then simply the Next handler(if any) is executed and "handlers" are ignored.
    // Example can be found at: _examples/routing/conditional-chain.
    //
    // A shortcut for the `context#NewConditionalHandler`.
    NewConditionalHandler = context.NewConditionalHandler
    // FileServer returns a Handler which serves files from a specific system, phyisical, directory
    // or an embedded one.
    // The first parameter is the directory, relative to the executable program.
    // The second optional parameter is any optional settings that the caller can use.
    //
    // See `Party#HandleDir` too.
    // Examples can be found at: https://github.com/kataras/iris/tree/master/_examples/file-server
    // A shortcut for the `router.FileServer`.
    FileServer = router.FileServer
    // DirListRich can be passed to `DirOptions.DirList` field
    // to override the default file listing appearance.
    // Read more at: `core/router.DirListRich`.
    DirListRich = router.DirListRich
    // StripPrefix returns a handler that serves HTTP requests
    // by removing the given prefix from the request URL's Path
    // and invoking the handler h. StripPrefix handles a
    // request for a path that doesn't begin with prefix by
    // replying with an HTTP 404 not found error.
    //
    // Usage:
    // fileserver := iris.FileServer("./static_files", DirOptions {...})
    // h := iris.StripPrefix("/static", fileserver)
    // app.Get("/static/{file:path}", h)
    // app.Head("/static/{file:path}", h)
    StripPrefix = router.StripPrefix
    // Gzip is a middleware which enables writing
    // using gzip compression, if client supports.
    //
    // A shortcut for the `context#Gzip`.
    Gzip = context.Gzip
    // GzipReader is a middleware which enables gzip decompression,
    // when client sends gzip compressed data.
    //
    // Similar to: func(ctx iris.Context) {
    //	ctx.GzipReader(true)
    //	ctx.Next()
    // }
    //
    // A shortcut for the `context#GzipReader`.
    GzipReader = context.GzipReader
    // FromStd converts native http.Handler, http.HandlerFunc & func(w, r, next) to context.Handler.
    //
    // Supported form types:
    // 		 .FromStd(h http.Handler)
    // 		 .FromStd(func(w http.ResponseWriter, r *http.Request))
    // 		 .FromStd(func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc))
    //
    // A shortcut for the `handlerconv#FromStd`.
    FromStd = handlerconv.FromStd
    // Cache is a middleware providing server-side cache functionalities
    // to the next handlers, can be used as: `app.Get("/", iris.Cache, aboutHandler)`.
    // It should be used after Static methods.
    // See `iris#Cache304` for an alternative, faster way.
    //
    // Examples can be found at: https://github.com/kataras/iris/tree/master/_examples/#caching
    Cache = cache.Handler
    // NoCache is a middleware which overrides the Cache-Control, Pragma and Expires headers
    // in order to disable the cache during the browser's back and forward feature.
    //
    // A good use of this middleware is on HTML routes; to refresh the page even on "back" and "forward" browser's arrow buttons.
    //
    // See `iris#StaticCache` for the opposite behavior.
    //
    // A shortcut of the `cache#NoCache`
    NoCache = cache.NoCache
    // StaticCache middleware for caching static files by sending the "Cache-Control" and "Expires" headers to the client.
    // It accepts a single input parameter, the "cacheDur", a time.Duration that it's used to calculate the expiration.
    //
    // If "cacheDur" <=0 then it returns the `NoCache` middleware instaed to disable the caching between browser's "back" and "forward" actions.
    //
    // Usage: `app.Use(iris.StaticCache(24 * time.Hour))` or `app.Use(iris.StaticCache(-1))`.
    // A middleware, which is a simple Handler can be called inside another handler as well, example:
    // cacheMiddleware := iris.StaticCache(...)
    // func(ctx iris.Context){
    //  cacheMiddleware(ctx)
    //  [...]
    // }
    //
    // A shortcut of the `cache#StaticCache`
    StaticCache = cache.StaticCache
    // Cache304 sends a `StatusNotModified` (304) whenever
    // the "If-Modified-Since" request header (time) is before the
    // time.Now() + expiresEvery (always compared to their UTC values).
    // Use this, which is a shortcut of the, `chache#Cache304` instead of the "github.com/kataras/iris/v12/cache" or iris.Cache
    // for better performance.
    // Clients that are compatible with the http RCF (all browsers are and tools like postman)
    // will handle the caching.
    // The only disadvantage of using that instead of server-side caching
    // is that this method will send a 304 status code instead of 200,
    // So, if you use it side by side with other micro services
    // you have to check for that status code as well for a valid response.
    //
    // Developers are free to extend this method's behavior
    // by watching system directories changes manually and use of the `ctx.WriteWithExpiration`
    // with a "modtime" based on the file modified date,
    // similar to the `HandleDir`(which sends status OK(200) and browser disk caching instead of 304).
    //
    // A shortcut of the `cache#Cache304`.
    Cache304 = cache.Cache304

    // CookieAllowReclaim accepts the Context itself.
    // If set it will add the cookie to (on `CookieSet`, `CookieSetKV`, `CookieUpsert`)
    // or remove the cookie from (on `CookieRemove`) the Request object too.
    //
    // A shortcut for the `context#CookieAllowReclaim`.
    CookieAllowReclaim = context.CookieAllowReclaim
    // CookieAllowSubdomains set to the Cookie Options
    // in order to allow subdomains to have access to the cookies.
    // It sets the cookie's Domain field (if was empty) and
    // it also sets the cookie's SameSite to lax mode too.
    //
    // A shortcut for the `context#CookieAllowSubdomains`.
    CookieAllowSubdomains = context.CookieAllowSubdomains
    // CookieSameSite sets a same-site rule for cookies to set.
    // SameSite allows a server to define a cookie attribute making it impossible for
    // the browser to send this cookie along with cross-site requests. The main
    // goal is to mitigate the risk of cross-origin information leakage, and provide
    // some protection against cross-site request forgery attacks.
    //
    // See https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00 for details.
    //
    // A shortcut for the `context#CookieSameSite`.
    CookieSameSite = context.CookieHTTPOnly
    // CookieSecure sets the cookie's Secure option if the current request's
    // connection is using TLS. See `CookieHTTPOnly` too.
    //
    // A shortcut for the `context#CookieSecure`.
    CookieSecure = context.CookieSecure
    // CookieHTTPOnly is a `CookieOption`.
    // Use it to set the cookie's HttpOnly field to false or true.
    // HttpOnly field defaults to true for `RemoveCookie` and `SetCookieKV`.
    //
    // A shortcut for the `context#CookieHTTPOnly`.
    CookieHTTPOnly = context.CookieHTTPOnly
    // CookiePath is a `CookieOption`.
    // Use it to change the cookie's Path field.
    //
    // A shortcut for the `context#CookiePath`.
    CookiePath = context.CookiePath
    // CookieCleanPath is a `CookieOption`.
    // Use it to clear the cookie's Path field, exactly the same as `CookiePath("")`.
    //
    // A shortcut for the `context#CookieCleanPath`.
    CookieCleanPath = context.CookieCleanPath
    // CookieExpires is a `CookieOption`.
    // Use it to change the cookie's Expires and MaxAge fields by passing the lifetime of the cookie.
    //
    // A shortcut for the `context#CookieExpires`.
    CookieExpires = context.CookieExpires
    // CookieEncoding accepts a value which implements `Encode` and `Decode` methods.
    // It calls its `Encode` on `Context.SetCookie, UpsertCookie, and SetCookieKV` methods.
    // And on `Context.GetCookie` method it calls its `Decode`.
    //
    // A shortcut for the `context#CookieEncoding`.
    CookieEncoding = context.CookieEncoding

    // IsErrPath can be used at `context#ReadForm` and `context#ReadQuery`.
    // It reports whether the incoming error is type of `formbinder.ErrPath`,
    // which can be ignored when server allows unknown post values to be sent by the client.
    //
    // A shortcut for the `context#IsErrPath`.
    IsErrPath = context.IsErrPath
    // ErrEmptyForm is the type error which API users can make use of
    // to check if a form was empty on `Context.ReadForm`.
    //
    // A shortcut for the `context#ErrEmptyForm`.
    ErrEmptyForm = context.ErrEmptyForm
    // NewProblem returns a new Problem.
    // Head over to the `Problem` type godoc for more.
    //
    // A shortcut for the `context#NewProblem`.
    NewProblem = context.NewProblem
    // XMLMap wraps a map[string]interface{} to compatible xml marshaler,
    // in order to be able to render maps as XML on the `Context.XML` method.
    //
    // Example: `Context.XML(XMLMap("Root", map[string]interface{}{...})`.
    //
    // A shortcut for the `context#XMLMap`.
    XMLMap = context.XMLMap
    // ErrStopExecution if returned from a hero middleware or a request-scope dependency
    // stops the handler's execution, see _examples/dependency-injection/basic/middleware.
    ErrStopExecution = hero.ErrStopExecution
    // ErrHijackNotSupported is returned by the Hijack method to
    // indicate that Hijack feature is not available.
    //
    // A shortcut for the `context#ErrHijackNotSupported`.
    ErrHijackNotSupported = context.ErrHijackNotSupported
    // ErrPushNotSupported is returned by the Push method to
    // indicate that HTTP/2 Push support is not available.
    //
    // A shortcut for the `context#ErrPushNotSupported`.
    ErrPushNotSupported = context.ErrPushNotSupported
    // ErrGzipNotSupported may be returned from
    // `WriteGzip` and `GzipReader` methods if
    // the client does not support the "gzip" compression.
    //
    // A shortcut for the `context#ErrGzipNotSupported`.
    ErrGzipNotSupported = context.ErrGzipNotSupported
)

var ErrServerClosed = http.ErrServerClosed

var RegisterOnInterrupt = host.RegisterOnInterrupt

var StatusText = context.StatusText

var TLSNoRedirect = func(su *host.Supervisor) { su.NoRedirect() }

var WithEmptyFormError = func(app *Application) {
    app.config.FireEmptyFormError = true
}

var WithFireMethodNotAllowed = func(app *Application) {
    app.config.FireMethodNotAllowed = true
}

var WithGlobalConfiguration = func(app *Application) {
    app.Configure(WithConfiguration(YAML(globalConfigurationKeyword)))
}

var WithLowercaseRouting = func(app *Application) {
    app.config.ForceLowercaseRouting = true
}

var WithOptimizations = func(app *Application) {
    app.config.EnableOptimizations = true
}

var WithPathEscape = func(app *Application) {
    app.config.EnablePathEscape = true
}

var WithPathIntelligence = func(app *Application) {
    app.config.EnablePathIntelligence = true
}

var WithResetOnFireErrorCode = func(app *Application) {
    app.config.ResetOnFireErrorCode = true
}

var WithTunneling = func(app *Application) {
    conf := TunnelingConfiguration{
        Tunnels: []Tunnel{{}},
    }

    app.config.Tunneling = conf
}

var WithoutAutoFireStatusCode = func(app *Application) {
    app.config.DisableAutoFireStatusCode = true
}

var WithoutBanner = WithoutStartupLog

var WithoutBodyConsumptionOnUnmarshal = func(app *Application) {
    app.config.DisableBodyConsumptionOnUnmarshal = true
}

var WithoutInterruptHandler = func(app *Application) {
    app.config.DisableInterruptHandler = true
}

var WithoutPathCorrection = func(app *Application) {
    app.config.DisablePathCorrection = true
}

var WithoutPathCorrectionRedirection = func(app *Application) {
    app.config.DisablePathCorrection = false
    app.config.DisablePathCorrectionRedirection = true
}

var WithoutStartupLog = func(app *Application) {
    app.config.DisableStartupLog = true
}

type APIContainer = router.APIContainer

type Application struct {
    // routing embedded | exposing APIBuilder's and Router's public API.
    *router.APIBuilder
    *router.Router
    router.HTTPErrorHandler // if Router is Downgraded this is nil.
    ContextPool             *context.Pool

    // I18n contains localization and internationalization support.
    // Use the `Load` or `LoadAssets` to locale language files.
    //
    // See `Context#Tr` method for request-based translations.
    I18n *i18n.I18n

    // Validator is the request body validator, defaults to nil.
    Validator context.Validator

    // Hosts contains a list of all servers (Host Supervisors) that this app is running on.
    //
    // Hosts may be empty only if application ran(`app.Run`) with `iris.Raw` option runner,
    // otherwise it contains a single host (`app.Hosts[0]`).
    //
    // Additional Host Supervisors can be added to that list by calling the `app.NewHost` manually.
    //
    // Hosts field is available after `Run` or `NewHost`.
    Hosts []*host.Supervisor
    // contains filtered or unexported fields
}

type Attachments = router.Attachments

type Configuration struct {

    // LogLevel is the log level the application should use to output messages.
    // Logger, by default, is mostly used on Build state but it is also possible
    // that debug error messages could be thrown when the app is running, e.g.
    // when malformed data structures try to be sent on Client (i.e Context.JSON/JSONP/XML...).
    //
    // Defaults to "info". Possible values are:
    // * "disable"
    // * "fatal"
    // * "error"
    // * "warn"
    // * "info"
    // * "debug"
    LogLevel string `json:"logLevel" yaml:"LogLevel" toml:"LogLevel" env:"LOG_LEVEL"`

    // SocketSharding enables SO_REUSEPORT (or SO_REUSEADDR for windows)
    // on all registered Hosts.
    // This option allows linear scaling server performance on multi-CPU servers.
    //
    // Please read the following:
    // 1. https://stackoverflow.com/a/14388707
    // 2. https://stackoverflow.com/a/59692868
    // 3. https://www.nginx.com/blog/socket-sharding-nginx-release-1-9-1/
    // 4. (BOOK) Learning HTTP/2: A Practical Guide for Beginners:
    //	  Page 37, To Shard or Not to Shard?
    //
    // Defaults to false.
    SocketSharding bool `json:"socketSharding" yaml:"SocketSharding" toml:"SocketSharding" env:"SOCKET_SHARDING"`
    // Tunneling can be optionally set to enable ngrok http(s) tunneling for this Iris app instance.
    // See the `WithTunneling` Configurator too.
    Tunneling TunnelingConfiguration `json:"tunneling,omitempty" yaml:"Tunneling" toml:"Tunneling"`
    // IgnoreServerErrors will cause to ignore the matched "errors"
    // from the main application's `Run` function.
    // This is a slice of string, not a slice of error
    // users can register these errors using yaml or toml configuration file
    // like the rest of the configuration fields.
    //
    // See `WithoutServerError(...)` function too.
    //
    // Example: https://github.com/kataras/iris/tree/master/_examples/http-server/listen-addr/omit-server-errors
    //
    // Defaults to an empty slice.
    IgnoreServerErrors []string `json:"ignoreServerErrors,omitempty" yaml:"IgnoreServerErrors" toml:"IgnoreServerErrors"`

    // DisableStartupLog if set to true then it turns off the write banner on server startup.
    //
    // Defaults to false.
    DisableStartupLog bool `json:"disableStartupLog,omitempty" yaml:"DisableStartupLog" toml:"DisableStartupLog"`
    // DisableInterruptHandler if set to true then it disables the automatic graceful server shutdown
    // when control/cmd+C pressed.
    // Turn this to true if you're planning to handle this by your own via a custom host.Task.
    //
    // Defaults to false.
    DisableInterruptHandler bool `json:"disableInterruptHandler,omitempty" yaml:"DisableInterruptHandler" toml:"DisableInterruptHandler"`

    // DisablePathCorrection disables the correcting
    // and redirecting or executing directly the handler of
    // the requested path to the registered path
    // for example, if /home/ path is requested but no handler for this Route found,
    // then the Router checks if /home handler exists, if yes,
    // (permanent)redirects the client to the correct path /home.
    //
    // See `DisablePathCorrectionRedirection` to enable direct handler execution instead of redirection.
    //
    // Defaults to false.
    DisablePathCorrection bool `json:"disablePathCorrection,omitempty" yaml:"DisablePathCorrection" toml:"DisablePathCorrection"`
    // DisablePathCorrectionRedirection works whenever configuration.DisablePathCorrection is set to false
    // and if DisablePathCorrectionRedirection set to true then it will fire the handler of the matching route without
    // the trailing slash ("/") instead of send a redirection status.
    //
    // Defaults to false.
    DisablePathCorrectionRedirection bool `json:"disablePathCorrectionRedirection,omitempty" yaml:"DisablePathCorrectionRedirection" toml:"DisablePathCorrectionRedirection"`
    // EnablePathIntelligence if set to true,
    // the router will redirect HTTP "GET" not found pages to the most closest one path(if any). For example
    // you register a route at "/contact" path -
    // a client tries to reach it by "/cont", the path will be automatic fixed
    // and the client will be redirected to the "/contact" path
    // instead of getting a 404 not found response back.
    //
    // Defaults to false.
    EnablePathIntelligence bool `json:"enablePathIntelligence,omitempty" yaml:"EnablePathIntelligence" toml:"EnablePathIntelligence"`
    // EnablePathEscape when is true then its escapes the path and the named parameters (if any).
    // When do you need to Disable(false) it:
    // accepts parameters with slash '/'
    // Request: http://localhost:8080/details/Project%2FDelta
    // ctx.Param("project") returns the raw named parameter: Project%2FDelta
    // which you can escape it manually with net/url:
    // projectName, _ := url.QueryUnescape(c.Param("project").
    //
    // Defaults to false.
    EnablePathEscape bool `json:"enablePathEscape,omitempty" yaml:"EnablePathEscape" toml:"EnablePathEscape"`
    // ForceLowercaseRouting if enabled, converts all registered routes paths to lowercase
    // and it does lowercase the request path too for matching.
    //
    // Defaults to false.
    ForceLowercaseRouting bool `json:"forceLowercaseRouting,omitempty" yaml:"ForceLowercaseRouting" toml:"ForceLowercaseRouting"`
    // FireMethodNotAllowed if it's true router checks for StatusMethodNotAllowed(405) and
    //  fires the 405 error instead of 404
    // Defaults to false.
    FireMethodNotAllowed bool `json:"fireMethodNotAllowed,omitempty" yaml:"FireMethodNotAllowed" toml:"FireMethodNotAllowed"`
    // DisableAutoFireStatusCode if true then it turns off the http error status code
    // handler automatic execution on error code from a `Context.StatusCode` call.
    // By-default a custom http error handler will be fired when "Context.StatusCode(errorCode)" called.
    //
    // Defaults to false.
    DisableAutoFireStatusCode bool `json:"disableAutoFireStatusCode,omitempty" yaml:"DisableAutoFireStatusCode" toml:"DisableAutoFireStatusCode"`
    // ResetOnFireErrorCode if true then any previously response body or headers through
    // response recorder or gzip writer will be ignored and the router
    // will fire the registered (or default) HTTP error handler instead.
    // See `core/router/handler#FireErrorCode` and `Context.EndRequest` for more details.
    //
    // Read more at: https://github.com/kataras/iris/issues/1531
    //
    // Defaults to false.
    ResetOnFireErrorCode bool `json:"resetOnFireErrorCode,omitempty" yaml:"ResetOnFireErrorCode" toml:"ResetOnFireErrorCode"`

    // EnableOptimization when this field is true
    // then the application tries to optimize for the best performance where is possible.
    //
    // Defaults to false.
    EnableOptimizations bool `json:"enableOptimizations,omitempty" yaml:"EnableOptimizations" toml:"EnableOptimizations"`
    // DisableBodyConsumptionOnUnmarshal manages the reading behavior of the context's body readers/binders.
    // If set to true then it
    // disables the body consumption by the `context.UnmarshalBody/ReadJSON/ReadXML`.
    //
    // By-default io.ReadAll` is used to read the body from the `context.Request.Body which is an `io.ReadCloser`,
    // if this field set to true then a new buffer will be created to read from and the request body.
    // The body will not be changed and existing data before the
    // context.UnmarshalBody/ReadJSON/ReadXML will be not consumed.
    DisableBodyConsumptionOnUnmarshal bool `json:"disableBodyConsumptionOnUnmarshal,omitempty" yaml:"DisableBodyConsumptionOnUnmarshal" toml:"DisableBodyConsumptionOnUnmarshal"`
    // FireEmptyFormError returns if set to tue true then the `context.ReadBody/ReadForm`
    // will return an `iris.ErrEmptyForm` on empty request form data.
    FireEmptyFormError bool `json:"fireEmptyFormError,omitempty" yaml:"FireEmptyFormError" toml:"FireEmptyFormError"`

    // TimeFormat time format for any kind of datetime parsing
    // Defaults to  "Mon, 02 Jan 2006 15:04:05 GMT".
    TimeFormat string `json:"timeFormat,omitempty" yaml:"TimeFormat" toml:"TimeFormat"`

    // Charset character encoding for various rendering
    // used for templates and the rest of the responses
    // Defaults to "utf-8".
    Charset string `json:"charset,omitempty" yaml:"Charset" toml:"Charset"`

    // PostMaxMemory sets the maximum post data size
    // that a client can send to the server, this differs
    // from the overral request body size which can be modified
    // by the `context#SetMaxRequestBodySize` or `iris#LimitRequestBodySize`.
    //
    // Defaults to 32MB or 32 << 20 if you prefer.
    PostMaxMemory int64 `json:"postMaxMemory" yaml:"PostMaxMemory" toml:"PostMaxMemory"`

    // Context values' keys for various features.
    //
    // LocaleContextKey is used by i18n to get the current request's locale, which contains a translate function too.
    //
    // Defaults to "iris.locale".
    LocaleContextKey string `json:"localeContextKey,omitempty" yaml:"LocaleContextKey" toml:"LocaleContextKey"`
    // LanguageContextKey is the context key which a language can be modified by a middleware.
    // It has the highest priority over the rest and if it is empty then it is ignored,
    // if it set to a static string of "default" or to the default language's code
    // then the rest of the language extractors will not be called at all and
    // the default language will be set instead.
    //
    // Use with `Context.SetLanguage("el-GR")`.
    //
    // See `i18n.ExtractFunc` for a more organised way of the same feature.
    // Defaults to "iris.locale.language".
    LanguageContextKey string `json:"languageContextKey,omitempty" yaml:"LanguageContextKey" toml:"LanguageContextKey"`
    // VersionContextKey is the context key which an API Version can be modified
    // via a middleware through `SetVersion` method, e.g. `versioning.SetVersion(ctx, "1.0, 1.1")`.
    // Defaults to "iris.api.version".
    VersionContextKey string `json:"versionContextKey" yaml:"VersionContextKey" toml:"VersionContextKey"`
    // GetViewLayoutContextKey is the key of the context's user values' key
    // which is being used to set the template
    // layout from a middleware or the main handler.
    // Overrides the parent's or the configuration's.
    //
    // Defaults to "iris.ViewLayout"
    ViewLayoutContextKey string `json:"viewLayoutContextKey,omitempty" yaml:"ViewLayoutContextKey" toml:"ViewLayoutContextKey"`
    // GetViewDataContextKey is the key of the context's user values' key
    // which is being used to set the template
    // binding data from a middleware or the main handler.
    //
    // Defaults to "iris.viewData"
    ViewDataContextKey string `json:"viewDataContextKey,omitempty" yaml:"ViewDataContextKey" toml:"ViewDataContextKey"`
    // RemoteAddrHeaders are the allowed request headers names
    // that can be valid to parse the client's IP based on.
    // By-default no "X-" header is consired safe to be used for retrieving the
    // client's IP address, because those headers can manually change by
    // the client. But sometimes are useful e.g., when behind a proxy
    // you want to enable the "X-Forwarded-For" or when cloudflare
    // you want to enable the "CF-Connecting-IP", inneed you
    // can allow the `ctx.RemoteAddr()` to use any header
    // that the client may sent.
    //
    // Defaults to an empty map but an example usage is:
    // RemoteAddrHeaders {
    //	"X-Real-Ip":             true,
    //  "X-Forwarded-For":       true,
    // 	"CF-Connecting-IP": 	 true,
    //	}
    //
    // Look `context.RemoteAddr()` for more.
    RemoteAddrHeaders map[string]bool `json:"remoteAddrHeaders,omitempty" yaml:"RemoteAddrHeaders" toml:"RemoteAddrHeaders"`
    // RemoteAddrPrivateSubnets defines the private sub-networks.
    // They are used to be compared against
    // IP Addresses fetched through `RemoteAddrHeaders` or `Context.Request.RemoteAddr`.
    // For details please navigate through: https://github.com/kataras/iris/issues/1453
    // Defaults to:
    // {
    // 	Start: net.ParseIP("10.0.0.0"),
    // 	End:   net.ParseIP("10.255.255.255"),
    // },
    // {
    // 	Start: net.ParseIP("100.64.0.0"),
    // 	End:   net.ParseIP("100.127.255.255"),
    // },
    // {
    // 	Start: net.ParseIP("172.16.0.0"),
    // 	End:   net.ParseIP("172.31.255.255"),
    // },
    // {
    // 	Start: net.ParseIP("192.0.0.0"),
    // 	End:   net.ParseIP("192.0.0.255"),
    // },
    // {
    // 	Start: net.ParseIP("192.168.0.0"),
    // 	End:   net.ParseIP("192.168.255.255"),
    // },
    // {
    // 	Start: net.ParseIP("198.18.0.0"),
    // 	End:   net.ParseIP("198.19.255.255"),
    // }
    //
    // Look `Context.RemoteAddr()` for more.
    RemoteAddrPrivateSubnets []netutil.IPRange `json:"remoteAddrPrivateSubnets" yaml:"RemoteAddrPrivateSubnets" toml:"RemoteAddrPrivateSubnets"`
    // SSLProxyHeaders defines the set of header key values
    // that would indicate a valid https Request (look `Context.IsSSL()`).
    // Example: `map[string]string{"X-Forwarded-Proto": "https"}`.
    //
    // Defaults to empty map.
    SSLProxyHeaders map[string]string `json:"sslProxyHeaders" yaml:"SSLProxyHeaders" toml:"SSLProxyHeaders"`
    // HostProxyHeaders defines the set of headers that may hold a proxied hostname value for the clients.
    // Look `Context.Host()` for more.
    // Defaults to empty map.
    HostProxyHeaders map[string]bool `json:"hostProxyHeaders" yaml:"HostProxyHeaders" toml:"HostProxyHeaders"`
    // Other are the custom, dynamic options, can be empty.
    // This field used only by you to set any app's options you want.
    //
    // Defaults to empty map.
    Other map[string]interface{} `json:"other,omitempty" yaml:"Other" toml:"Other"`
    // contains filtered or unexported fields
}

type Configurator func(*Application)

type Context = context.Context

type CookieOption = context.CookieOption

type DirListRichOptions = router.DirListRichOptions

type DirOptions = router.DirOptions

type ExecutionOptions = router.ExecutionOptions

type ExecutionRules = router.ExecutionRules

type Filter = context.Filter

type Handler = context.Handler

type JSON = context.JSON

type Map = context.Map

type N = context.N

type Party = router.Party

type Problem = context.Problem

type ProblemOptions = context.ProblemOptions

type ProtoMarshalOptions = context.ProtoMarshalOptions

type ProtoUnmarshalOptions = context.ProtoUnmarshalOptions

type ResultHandler = hero.ResultHandler

type Runner func(*Application) error

type Supervisor = host.Supervisor

type Tunnel struct {
    // Name is the only one required field,
    // it is used to create and close tunnels, e.g. "MyApp".
    // If this field is not empty then ngrok tunnels will be created
    // when the iris app is up and running.
    Name string `json:"name" yaml:"Name" toml:"Name"`
    // Addr is basically optionally as it will be set through
    // Iris built-in Runners, however, if `iris.Raw` is used
    // then this field should be set of form 'hostname:port'
    // because framework cannot be aware
    // of the address you used to run the server on this custom runner.
    Addr string `json:"addr,omitempty" yaml:"Addr" toml:"Addr"`
}

type TunnelingConfiguration struct {
    // AuthToken field is optionally and can be used
    // to authenticate the ngrok access.
    // ngrok authtoken <YOUR_AUTHTOKEN>
    AuthToken string `json:"authToken,omitempty" yaml:"AuthToken" toml:"AuthToken"`

    // Bin is the system binary path of the ngrok executable file.
    // If it's empty then the framework will try to find it through system env variables.
    Bin string `json:"bin,omitempty" yaml:"Bin" toml:"Bin"`

    // WebUIAddr is the web interface address of an already-running ngrok instance.
    // Iris will try to fetch the default web interface address(http://127.0.0.1:4040)
    // to determinate if a ngrok instance is running before try to start it manually.
    // However if a custom web interface address is used,
    // this field must be set e.g. http://127.0.0.1:5050.
    WebInterface string `json:"webInterface,omitempty" yaml:"WebInterface" toml:"WebInterface"`

    // Region is optionally, can be used to set the region which defaults to "us".
    // Available values are:
    // "us" for United States
    // "eu" for Europe
    // "ap" for Asia/Pacific
    // "au" for Australia
    // "sa" for South America
    // "jp" forJapan
    // "in" for India
    Region string `json:"region,omitempty" yaml:"Region" toml:"Region"`

    // Tunnels the collection of the tunnels.
    // One tunnel per Iris Host per Application, usually you only need one.
    Tunnels []Tunnel `json:"tunnels" yaml:"Tunnels" toml:"Tunnels"`
}

type UnmarshalerFunc = context.UnmarshalerFunc

type XML = context.XML