interceptors

var (
	// Allow returns a result that allows the request to proceed.
	Allow = router.Allow

	// AllowWithValues allows the request and enriches the context with values.
	AllowWithValues = router.AllowWithValues

	// Block returns a result that blocks the request with an error.
	Block = router.Block

	// BlockWithValues blocks the request but still provides values.
	BlockWithValues = router.BlockWithValues
)

var (
	// NewInterceptor creates a named interceptor from a function.
	NewInterceptor = router.NewInterceptor

	// InterceptorFromFunc creates an anonymous interceptor from a function.
	InterceptorFromFunc = router.InterceptorFromFunc
)

var (
	// RequireAuth requires authentication (checks "auth" or "user" in context).
	RequireAuth = router.RequireAuth

	// RequireAuthProvider requires a specific auth provider.
	RequireAuthProvider = router.RequireAuthProvider
)

var (
	// RequireScopes requires ALL specified scopes.
	RequireScopes = router.RequireScopes

	// RequireAnyScope requires ANY of the specified scopes.
	RequireAnyScope = router.RequireAnyScope

	// RequireRole requires ANY of the specified roles.
	RequireRole = router.RequireRole

	// RequireAllRoles requires ALL specified roles.
	RequireAllRoles = router.RequireAllRoles
)

var (
	// FeatureFlag checks if a feature is enabled using a checker function.
	FeatureFlag = router.FeatureFlag

	// FeatureFlagFromContext checks a feature flag from the "feature-flags" context map.
	FeatureFlagFromContext = router.FeatureFlagFromContext
)

var (
	// Enrich enriches the context with values from a loader function.
	Enrich = router.Enrich

	// EnrichUser loads user data into context under the "user" key.
	EnrichUser = router.EnrichUser
)

var (
	// RequireMetadata checks that a route metadata key matches an expected value.
	RequireMetadata = router.RequireMetadata

	// RequireTag checks if a route has a specific tag.
	RequireTag = router.RequireTag
)

var (
	// RateLimit creates a rate limit interceptor with a custom checker.
	RateLimit = router.RateLimit

	// RateLimitByIP creates a rate limit interceptor keyed by client IP.
	RateLimitByIP = router.RateLimitByIP
)

var (
	// AllowIPs only allows specific IP addresses.
	AllowIPs = router.AllowIPs

	// DenyIPs blocks specific IP addresses.
	DenyIPs = router.DenyIPs
)

var (
	// RequireHeader requires specific headers to be present.
	RequireHeader = router.RequireHeader

	// RequireContentType requires a specific Content-Type.
	RequireContentType = router.RequireContentType
)

var (
	// FromFunc creates an anonymous interceptor from a simple function.
	FromFunc = router.FromFunc

	// Named wraps an anonymous interceptor with a name.
	Named = router.Named
)

var (
	// And combines interceptors — ALL must pass (short-circuits on first block).
	And = router.And

	// Or combines interceptors — ANY one passing is sufficient.
	Or = router.Or

	// Not inverts an interceptor's decision.
	Not = router.Not

	// When conditionally executes an interceptor based on a predicate.
	When = router.When

	// Unless conditionally skips an interceptor based on a predicate.
	Unless = router.Unless

	// IfMetadata conditionally executes an interceptor based on route metadata.
	IfMetadata = router.IfMetadata

	// IfTag conditionally executes an interceptor based on route tags.
	IfTag = router.IfTag

	// ChainInterceptors combines multiple interceptors into a single one (alias for And).
	ChainInterceptors = router.ChainInterceptors
)

var (
	// Parallel executes interceptors concurrently — ALL must pass.
	Parallel = router.Parallel

	// ParallelAny executes interceptors concurrently — ANY one passing is sufficient.
	ParallelAny = router.ParallelAny
)

var (
	// Maintenance blocks requests when maintenance mode is active.
	Maintenance = router.Maintenance
)

var (
	// TenantIsolation validates tenant access from URL param against user context.
	TenantIsolation = router.TenantIsolation
)