middleware

type BulkheadConfig struct {
	// Resource limits
	MaxConcurrentRequests int           `json:"max_concurrent_requests"` // Global concurrent request limit
	MaxWaitTime           time.Duration `json:"max_wait_time"`           // Max time to wait for resource

	// Tenant isolation
	PerTenantLimits       map[string]int `json:"per_tenant_limits"`       // Per-tenant concurrent limits
	DefaultTenantLimit    int            `json:"default_tenant_limit"`    // Default limit for unlisted tenants
	EnableTenantIsolation bool           `json:"enable_tenant_isolation"` // Enable per-tenant bulkheads

	// Operation isolation
	PerOperationLimits       map[string]int `json:"per_operation_limits"`       // Per-operation concurrent limits
	DefaultOperationLimit    int            `json:"default_operation_limit"`    // Default limit for unlisted operations
	EnableOperationIsolation bool           `json:"enable_operation_isolation"` // Enable per-operation bulkheads

	// Priority handling
	EnablePriority        bool                    `json:"enable_priority"`         // Enable priority-based queuing
	PriorityExtractor     func(*lift.Context) int `json:"-"`                       // Extract priority from context
	HighPriorityThreshold int                     `json:"high_priority_threshold"` // Threshold for high priority

	// Rejection handling
	RejectionHandler func(*lift.Context, string) error `json:"-"` // Custom rejection handler

	// Observability
	Logger        observability.StructuredLogger `json:"-"`
	Metrics       observability.MetricsCollector `json:"-"`
	EnableMetrics bool                           `json:"enable_metrics"`

	// Naming
	Name string `json:"name"` // Bulkhead name for metrics
}

type BulkheadStats struct {
	Name                string                    `json:"name"`
	ActiveRequests      int                       `json:"active_requests"`
	QueuedRequests      int                       `json:"queued_requests"`
	TotalRequests       int64                     `json:"total_requests"`
	RejectedRequests    int64                     `json:"rejected_requests"`
	CompletedRequests   int64                     `json:"completed_requests"`
	AverageWaitTime     time.Duration             `json:"average_wait_time"`
	MaxWaitTime         time.Duration             `json:"max_wait_time"`
	ResourceUtilization float64                   `json:"resource_utilization"`
	TenantStats         map[string]*ResourceStats `json:"tenant_stats,omitempty"`
	OperationStats      map[string]*ResourceStats `json:"operation_stats,omitempty"`
}

type CircuitBreakerConfig struct {
	// Failure detection
	FailureThreshold int           `json:"failure_threshold"` // Failures before opening
	SuccessThreshold int           `json:"success_threshold"` // Successes to close from half-open
	Timeout          time.Duration `json:"timeout"`           // How long to stay open

	// Advanced failure detection
	ErrorRateThreshold  float64       `json:"error_rate_threshold"`  // Error rate (0.0-1.0) to trigger
	MinRequestThreshold int           `json:"min_request_threshold"` // Minimum requests before rate calculation
	SlidingWindowSize   time.Duration `json:"sliding_window_size"`   // Window for error rate calculation

	// Recovery settings
	MaxRetryAttempts int           `json:"max_retry_attempts"` // Max attempts in half-open
	RetryBackoff     time.Duration `json:"retry_backoff"`      // Backoff between retry attempts

	// Customization
	ShouldTrip      func(error) bool                               `json:"-"` // Custom failure detection
	FallbackHandler func(*lift.Context) error                      `json:"-"` // Custom fallback
	OnStateChange   func(CircuitBreakerState, CircuitBreakerState) `json:"-"` // State change callback

	// Multi-tenant settings
	PerTenant             bool `json:"per_tenant"`              // Separate circuit breakers per tenant
	PerOperation          bool `json:"per_operation"`           // Separate circuit breakers per operation
	EnableTenantIsolation bool `json:"enable_tenant_isolation"` // Enable tenant isolation (alias for PerTenant)

	// Observability
	Logger        observability.StructuredLogger `json:"-"`
	Metrics       observability.MetricsCollector `json:"-"`
	EnableMetrics bool                           `json:"enable_metrics"`

	// Naming
	Name string `json:"name"` // Circuit breaker name for metrics
}

type CircuitBreakerState string

type CircuitBreakerStats struct {
	State                CircuitBreakerState `json:"state"`
	FailureCount         int64               `json:"failure_count"`
	SuccessCount         int64               `json:"success_count"`
	TotalRequests        int64               `json:"total_requests"`
	ErrorRate            float64             `json:"error_rate"`
	LastFailure          time.Time           `json:"last_failure"`
	LastSuccess          time.Time           `json:"last_success"`
	StateChangedAt       time.Time           `json:"state_changed_at"`
	NextRetryAt          time.Time           `json:"next_retry_at,omitempty"`
	ConsecutiveFailures  int                 `json:"consecutive_failures"`
	ConsecutiveSuccesses int                 `json:"consecutive_successes"`
}

type CookieToken struct {
	Name     string
	Value    string
	HttpOnly bool
	Secure   bool
	SameSite string
	Path     string
	Domain   string
	MaxAge   int
}

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

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

type EnhancedObservabilityConfig struct {
	// Core components
	Logger  observability.StructuredLogger
	Metrics observability.MetricsCollector
	Tracer  *xray.XRayTracer

	// Feature flags
	EnableLogging bool `json:"enable_logging"`
	EnableMetrics bool `json:"enable_metrics"`
	EnableTracing bool `json:"enable_tracing"`

	// Custom extractors
	OperationNameFunc func(*lift.Context) string
	TenantIDFunc      func(*lift.Context) string
	UserIDFunc        func(*lift.Context) string

	// Performance settings
	LogRequestBody  bool    `json:"log_request_body"`
	LogResponseBody bool    `json:"log_response_body"`
	MaxBodyLogSize  int     `json:"max_body_log_size"`
	SampleRate      float64 `json:"sample_rate"` // 0.0 to 1.0

	// Custom dimensions/tags
	DefaultTags map[string]string `json:"default_tags"`
}

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

type HealthCheckConfig struct {
	// Endpoint configuration
	Path       string `json:"path"`        // Health check endpoint path (default: /health)
	DetailPath string `json:"detail_path"` // Detailed health check path (default: /health/detail)
	ReadyPath  string `json:"ready_path"`  // Readiness check path (default: /ready)
	LivePath   string `json:"live_path"`   // Liveness check path (default: /live)

	// Check configuration
	Timeout     time.Duration `json:"timeout"`      // Timeout for individual checks
	Interval    time.Duration `json:"interval"`     // How often to run background checks
	GracePeriod time.Duration `json:"grace_period"` // Grace period during startup

	// Circuit breaker settings
	FailureThreshold int           `json:"failure_threshold"` // Failures before marking unhealthy
	RecoveryTime     time.Duration `json:"recovery_time"`     // Time to wait before retry

	// Dependencies
	Dependencies []HealthChecker `json:"-"` // External dependencies to check

	// Observability
	Logger  observability.StructuredLogger `json:"-"`
	Metrics observability.MetricsCollector `json:"-"`

	// Feature flags
	EnableDetailedChecks bool `json:"enable_detailed_checks"`
	EnableMetrics        bool `json:"enable_metrics"`
	EnableBackgroundRuns bool `json:"enable_background_runs"`
}

type HealthCheckResult struct {
	Name      string         `json:"name"`
	Status    HealthStatus   `json:"status"`
	Message   string         `json:"message,omitempty"`
	Duration  time.Duration  `json:"duration"`
	Timestamp time.Time      `json:"timestamp"`
	Details   map[string]any `json:"details,omitempty"`
	Required  bool           `json:"required"`
}

type HealthChecker interface {
	Name() string
	Check(ctx context.Context) error
	IsRequired() bool // If true, failure marks entire system as unhealthy
}

type HealthConfig = HealthCheckConfig

type HealthStatus string

type HealthSummary struct {
	Total     int `json:"total"`
	Healthy   int `json:"healthy"`
	Unhealthy int `json:"unhealthy"`
	Degraded  int `json:"degraded"`
	Unknown   int `json:"unknown"`
}

type IdempotencyOptions struct {
	// Store is the backend for storing idempotency records
	Store IdempotencyStore
	// HeaderName is the header to check for idempotency key (default: "Idempotency-Key")
	HeaderName string
	// TTL is how long to store successful responses (default: 24 hours)
	TTL time.Duration
	// ProcessingTimeout is how long to wait for in-flight requests (default: 30 seconds)
	ProcessingTimeout time.Duration
	// IncludeRequestHash includes request body hash for stricter validation
	IncludeRequestHash bool
	// OnDuplicate is called when a duplicate request is detected
	OnDuplicate func(ctx *lift.Context, record *IdempotencyRecord)
}

type IdempotencyRecord struct {
	Key          string    `json:"key"`
	Status       string    `json:"status"` // "processing", "completed", "error"
	Response     any       `json:"response,omitempty"`
	StatusCode   int       `json:"status_code,omitempty"`
	Error        string    `json:"error,omitempty"`
	CreatedAt    time.Time `json:"created_at"`
	ExpiresAt    time.Time `json:"expires_at"`
	RequestHash  string    `json:"request_hash,omitempty"`
	FunctionName string    `json:"function_name,omitempty"`
	TenantID     string    `json:"tenant_id,omitempty"`
	UserID       string    `json:"user_id,omitempty"`
}

type IdempotencyStore interface {
	// Get retrieves a stored response by key
	Get(ctx context.Context, key string) (*IdempotencyRecord, error)
	// Set stores a response with the given key
	Set(ctx context.Context, key string, record *IdempotencyRecord) error
	// SetProcessing marks a key as being processed (prevents concurrent duplicates)
	SetProcessing(ctx context.Context, key string, expiresAt time.Time) error
	// Delete removes a key from the store
	Delete(ctx context.Context, key string) error
}

type JWTClaims struct {
	jwt.RegisteredClaims
	TenantID  string   `json:"tenant_id"`
	AccountID string   `json:"account_id"`
	Roles     []string `json:"roles"`
	Scopes    []string `json:"scopes"`
}

type JWTConfig struct {
	// Secret key for HMAC algorithms
	Secret string

	// Public key for RSA/ECDSA algorithms
	PublicKey any

	// Algorithm to use (HS256, RS256, etc)
	Algorithm string

	// Token lookup string (e.g., "header:Authorization,query:token")
	TokenLookup string

	// Claims validator function
	Validator func(claims jwt.MapClaims) error

	// Error handler
	ErrorHandler func(ctx *lift.Context, err error) error

	// Skip authentication for these paths
	SkipPaths []string

	// Optional: custom claims type
	Claims jwt.Claims

	// Optional: custom token extractor
	Extractor func(ctx *lift.Context) (string, error)
}

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

type LimitedConfig struct {
	// DynamoDB configuration
	Region    string
	TableName string
	Endpoint  string // Optional, for local testing

	// Rate limiting parameters
	Window time.Duration
	Limit  int

	// Strategy type
	Strategy string // "fixed", "sliding", "token", "leaky"

	// Logger
	Logger *zap.Logger
}

type LoadMetrics struct {
	// System metrics
	CPUUsage    float64 `json:"cpu_usage"`
	MemoryUsage float64 `json:"memory_usage"`

	// Application metrics
	ActiveRequests int64         `json:"active_requests"`
	RequestRate    float64       `json:"request_rate"`
	AverageLatency time.Duration `json:"average_latency"`
	P95Latency     time.Duration `json:"p95_latency"`
	P99Latency     time.Duration `json:"p99_latency"`
	ErrorRate      float64       `json:"error_rate"`

	// Load shedding metrics
	CurrentSheddingRate float64 `json:"current_shedding_rate"`
	TotalRequests       int64   `json:"total_requests"`
	ShedRequests        int64   `json:"shed_requests"`

	// Timestamps
	LastUpdated time.Time `json:"last_updated"`
	WindowStart time.Time `json:"window_start"`
}

type LoadSheddingConfig struct {
	// Basic settings
	Strategy LoadSheddingStrategy `json:"strategy"` // Load shedding strategy
	Enabled  bool                 `json:"enabled"`  // Enable/disable load shedding

	// Threshold settings
	CPUThreshold       float64       `json:"cpu_threshold"`        // CPU usage threshold (0.0-1.0)
	MemoryThreshold    float64       `json:"memory_threshold"`     // Memory usage threshold (0.0-1.0)
	LatencyThreshold   time.Duration `json:"latency_threshold"`    // Response time threshold
	ErrorRateThreshold float64       `json:"error_rate_threshold"` // Error rate threshold (0.0-1.0)

	// Adaptive settings
	TargetLatency   time.Duration `json:"target_latency"`    // Target response time
	MaxSheddingRate float64       `json:"max_shedding_rate"` // Maximum shedding rate (0.0-1.0)
	MinSheddingRate float64       `json:"min_shedding_rate"` // Minimum shedding rate (0.0-1.0)
	SheddingRate    float64       `json:"shedding_rate"`     // Fixed shedding rate (for simple strategies)
	AdaptationRate  float64       `json:"adaptation_rate"`   // How quickly to adapt (0.0-1.0)

	// Priority settings
	PriorityExtractor  func(*lift.Context) int `json:"-"`                   // Extract priority from request
	PriorityThresholds map[int]float64         `json:"priority_thresholds"` // Shedding rates by priority

	// Custom algorithm
	CustomShedder func(*lift.Context, *LoadMetrics) bool `json:"-"` // Custom shedding function

	// Monitoring settings
	MetricsWindow time.Duration `json:"metrics_window"` // Window for metrics calculation
	SamplingRate  float64       `json:"sampling_rate"`  // Rate of requests to sample for metrics

	// Response settings
	SheddingHandler    func(*lift.Context) error `json:"-"`                    // Custom shedding response
	SheddingStatusCode int                       `json:"shedding_status_code"` // HTTP status for shed requests
	SheddingMessage    string                    `json:"shedding_message"`     // Message for shed requests

	// Observability
	Logger        observability.StructuredLogger `json:"-"`
	Metrics       observability.MetricsCollector `json:"-"`
	EnableMetrics bool                           `json:"enable_metrics"`

	// Naming
	Name string `json:"name"` // Load shedding name for metrics
}

type LoadSheddingStats struct {
	Name                string               `json:"name"`
	Strategy            LoadSheddingStrategy `json:"strategy"`
	Enabled             bool                 `json:"enabled"`
	CurrentSheddingRate float64              `json:"current_shedding_rate"`
	TotalRequests       int64                `json:"total_requests"`
	ShedRequests        int64                `json:"shed_requests"`
	SheddingRatio       float64              `json:"shedding_ratio"`
	AverageLatency      time.Duration        `json:"average_latency"`
	SystemMetrics       LoadMetrics          `json:"system_metrics"`
}

type LoadSheddingStrategy string

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

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

type Middleware func(lift.Handler) lift.Handler

type ObservabilityConfig struct {
	Logger  observability.StructuredLogger
	Metrics observability.MetricsCollector
	// Optional: custom operation name extractor
	OperationNameFunc func(*lift.Context) string
}

type ObservabilityStats struct {
	Logger  *observability.LoggerStats  `json:"logger,omitempty"`
	Metrics *observability.MetricsStats `json:"metrics,omitempty"`
	Tracing *TracingStats               `json:"tracing,omitempty"`
}

type OverallHealthResult struct {
	Status      HealthStatus                  `json:"status"`
	Timestamp   time.Time                     `json:"timestamp"`
	Duration    time.Duration                 `json:"duration"`
	Version     string                        `json:"version,omitempty"`
	Environment string                        `json:"environment,omitempty"`
	Checks      map[string]*HealthCheckResult `json:"checks,omitempty"`
	Summary     *HealthSummary                `json:"summary,omitempty"`
}

type RateLimitConfig struct {
	// DynamORM configuration
	DynamORM *dynamorm.DynamORMWrapper `json:"-"`

	// Rate limiting settings
	DefaultLimit  int           `json:"default_limit"`  // Requests per window
	DefaultWindow time.Duration `json:"default_window"` // Time window
	Window        time.Duration `json:"window"`         // Alias for DefaultWindow (backward compatibility)
	BurstLimit    int           `json:"burst_limit"`    // Burst allowance

	// Strategy settings
	Strategy    string        `json:"strategy"`    // fixed_window, sliding_window, multi_window
	Granularity time.Duration `json:"granularity"` // For sliding window strategy

	// Multi-tenant settings
	TenantLimits map[string]int `json:"tenant_limits"` // Per-tenant limits
	UserLimits   map[string]int `json:"user_limits"`   // Per-user limits

	// Key generation
	KeyPrefix     string                            `json:"key_prefix"`
	KeyFunc       func(*lift.Context) *RateLimitKey `json:"-"` // Custom key function
	IncludePath   bool                              `json:"include_path"`
	IncludeMethod bool                              `json:"include_method"`

	// Error handling
	ErrorHandler func(*lift.Context, *RateLimitResult) error `json:"-"` // Custom error handler

	// Behavior settings
	SkipSuccessful bool `json:"skip_successful"` // Only count failed requests
	SkipOptions    bool `json:"skip_options"`    // Skip OPTIONS requests

	// Headers
	HeaderPrefix string `json:"header_prefix"` // X-RateLimit prefix

	// Storage settings
	TableName       string        `json:"table_name"`
	TTL             time.Duration `json:"ttl"`              // How long to keep records
	CleanupInterval time.Duration `json:"cleanup_interval"` // How often to cleanup
}

type RateLimitEntry struct {
	Key         string    `json:"key"`
	Count       int       `json:"count"`
	WindowStart time.Time `json:"window_start"`
	LastRequest time.Time `json:"last_request"`
	TTL         int64     `json:"ttl"`
}

type RateLimitKey struct {
	Identifier string            `json:"identifier"` // Primary identifier (tenant:user, IP, etc.)
	Resource   string            `json:"resource"`   // Resource being accessed (path)
	Operation  string            `json:"operation"`  // Operation being performed (method)
	Metadata   map[string]string `json:"metadata"`   // Additional metadata
}

type RateLimitResult struct {
	Allowed     bool          `json:"allowed"`
	Limit       int           `json:"limit"`
	Remaining   int           `json:"remaining"`
	ResetAt     time.Time     `json:"reset_at"`
	RetryAfter  time.Duration `json:"retry_after"`
	WindowStart time.Time     `json:"window_start"`
}

type RateLimitStats struct {
	TotalRequests   int64 `json:"total_requests"`
	AllowedRequests int64 `json:"allowed_requests"`
	BlockedRequests int64 `json:"blocked_requests"`
	ErrorCount      int64 `json:"error_count"`
}

type ResourceStats struct {
	ActiveRequests   int     `json:"active_requests"`
	QueuedRequests   int     `json:"queued_requests"`
	TotalRequests    int64   `json:"total_requests"`
	RejectedRequests int64   `json:"rejected_requests"`
	Utilization      float64 `json:"utilization"`
	Limit            int     `json:"limit"`
}

type RetryConfig struct {
	// Basic retry settings
	MaxAttempts  int           `json:"max_attempts"`  // Maximum number of retry attempts
	InitialDelay time.Duration `json:"initial_delay"` // Initial delay before first retry
	MaxDelay     time.Duration `json:"max_delay"`     // Maximum delay between retries
	Strategy     RetryStrategy `json:"strategy"`      // Retry strategy to use

	// Backoff configuration
	BackoffMultiplier float64 `json:"backoff_multiplier"` // Multiplier for exponential backoff
	Jitter            bool    `json:"jitter"`             // Add random jitter to delays
	JitterRange       float64 `json:"jitter_range"`       // Jitter range (0.0-1.0)

	// Custom strategy
	CustomBackoff func(attempt int, lastDelay time.Duration) time.Duration `json:"-"` // Custom backoff function

	// Retry conditions
	RetryableErrors    []string         `json:"retryable_errors"`     // Specific error types to retry
	RetryCondition     func(error) bool `json:"-"`                    // Custom retry condition
	NonRetryableErrors []string         `json:"non_retryable_errors"` // Errors that should never be retried

	// HTTP-specific settings
	RetryableStatusCodes    []int `json:"retryable_status_codes"`     // HTTP status codes to retry
	NonRetryableStatusCodes []int `json:"non_retryable_status_codes"` // HTTP status codes to never retry

	// Context and timeouts
	PerAttemptTimeout time.Duration `json:"per_attempt_timeout"` // Timeout per individual attempt
	TotalTimeout      time.Duration `json:"total_timeout"`       // Total timeout for all attempts

	// Observability
	Logger        observability.StructuredLogger `json:"-"`
	Metrics       observability.MetricsCollector `json:"-"`
	EnableMetrics bool                           `json:"enable_metrics"`

	// Callbacks
	OnRetry  func(attempt int, err error, delay time.Duration) `json:"-"` // Called before each retry
	OnGiveUp func(attempts int, lastErr error)                 `json:"-"` // Called when giving up

	// Naming
	Name string `json:"name"` // Retry middleware name for metrics
}

type RetryStats struct {
	Name              string        `json:"name"`
	TotalRequests     int64         `json:"total_requests"`
	RetriedRequests   int64         `json:"retried_requests"`
	SuccessfulRetries int64         `json:"successful_retries"`
	FailedRetries     int64         `json:"failed_retries"`
	TotalAttempts     int64         `json:"total_attempts"`
	AverageAttempts   float64       `json:"average_attempts"`
	MaxAttempts       int           `json:"max_attempts"`
	AverageDelay      time.Duration `json:"average_delay"`
	TotalDelay        time.Duration `json:"total_delay"`
}

type RetryStrategy string

type SecurityHeadersConfig struct {
	// Content Security Policy
	ContentSecurityPolicy string

	// X-Frame-Options: DENY, SAMEORIGIN, or ALLOW-FROM uri
	XFrameOptions string

	// X-Content-Type-Options: nosniff
	XContentTypeOptions bool

	// X-XSS-Protection: 1; mode=block
	XXSSProtection string

	// Strict-Transport-Security
	StrictTransportSecurity string

	// Referrer-Policy
	ReferrerPolicy string

	// Permissions-Policy (formerly Feature-Policy)
	PermissionsPolicy string

	// Custom headers to add
	CustomHeaders map[string]string

	// Whether to include security headers in development
	IncludeInDevelopment bool
}

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

type ServiceMeshConfig struct {
	// AWS App Mesh configuration
	MeshName    string `json:"mesh_name"`
	VirtualNode string `json:"virtual_node"`

	// Service Discovery configuration
	ServiceName string `json:"service_name"`
	Namespace   string `json:"namespace"`

	// Health check configuration
	HealthCheckPath     string        `json:"health_check_path"`
	HealthCheckInterval time.Duration `json:"health_check_interval"`
	HealthCheckTimeout  time.Duration `json:"health_check_timeout"`

	// Port configuration
	Port string `json:"port"`

	// AWS Region
	Region string `json:"region"`
}

type ServiceMeshHealthStatus struct {
	Healthy      bool                   `json:"healthy"`
	Service      string                 `json:"service"`
	VirtualNode  string                 `json:"virtual_node"`
	Dependencies map[string]bool        `json:"dependencies,omitempty"`
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
}

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

type TimeoutConfig struct {
	// Basic timeout settings
	DefaultTimeout time.Duration `json:"default_timeout"` // Default timeout for all requests
	ReadTimeout    time.Duration `json:"read_timeout"`    // Timeout for reading request body
	WriteTimeout   time.Duration `json:"write_timeout"`   // Timeout for writing response
	IdleTimeout    time.Duration `json:"idle_timeout"`    // Timeout for idle connections

	// Per-operation timeouts
	OperationTimeouts map[string]time.Duration `json:"operation_timeouts"` // Timeouts per operation

	// Per-tenant timeouts
	TenantTimeouts map[string]time.Duration `json:"tenant_timeouts"` // Timeouts per tenant

	// Dynamic timeout settings
	EnableDynamicTimeout bool                              `json:"enable_dynamic_timeout"` // Enable dynamic timeout adjustment
	TimeoutCalculator    func(*lift.Context) time.Duration `json:"-"`                      // Custom timeout calculator

	// Graceful handling
	GracefulShutdown bool          `json:"graceful_shutdown"` // Enable graceful shutdown
	ShutdownTimeout  time.Duration `json:"shutdown_timeout"`  // Timeout for graceful shutdown

	// Response settings
	TimeoutHandler    func(*lift.Context) error `json:"-"`                   // Custom timeout response handler
	TimeoutStatusCode int                       `json:"timeout_status_code"` // HTTP status for timeout
	TimeoutMessage    string                    `json:"timeout_message"`     // Message for timeout response

	// Observability
	Logger        observability.StructuredLogger `json:"-"`
	Metrics       observability.MetricsCollector `json:"-"`
	EnableMetrics bool                           `json:"enable_metrics"`

	// Naming
	Name string `json:"name"` // Timeout middleware name for metrics
}

type TimeoutStats struct {
	Name            string        `json:"name"`
	TotalRequests   int64         `json:"total_requests"`
	TimeoutRequests int64         `json:"timeout_requests"`
	TimeoutRatio    float64       `json:"timeout_ratio"`
	AverageTimeout  time.Duration `json:"average_timeout"`
	MaxTimeout      time.Duration `json:"max_timeout"`
	MinTimeout      time.Duration `json:"min_timeout"`
	AverageDuration time.Duration `json:"average_duration"`
}

type TracingStats struct {
	TracesGenerated int64     `json:"traces_generated"`
	LastTrace       time.Time `json:"last_trace"`
	ErrorCount      int64     `json:"error_count"`
}

type ValidationConfig struct {
	MaxBodySize              int64                         `json:"max_body_size"`         // Maximum request body size in bytes
	MaxHeaderSize            int                           `json:"max_header_size"`       // Maximum header value size
	MaxQueryParamSize        int                           `json:"max_query_param_size"`  // Maximum query parameter size
	MaxPathParamSize         int                           `json:"max_path_param_size"`   // Maximum path parameter size
	AllowedContentTypes      []string                      `json:"allowed_content_types"` // Allowed content types
	BlockedUserAgents        []string                      `json:"blocked_user_agents"`   // Blocked user agent patterns
	CustomValidators         map[string]func(string) error `json:"-"`                     // Custom field validators
	EnableSQLInjectionCheck  bool                          `json:"enable_sql_injection_check"`
	EnableXSSCheck           bool                          `json:"enable_xss_check"`
	EnablePathTraversalCheck bool                          `json:"enable_path_traversal_check"`
}

type WebSocketAuthConfig struct {
	JWTConfig      security.JWTConfig
	TokenExtractor func(ctx *lift.Context) string
	OnError        func(ctx *lift.Context, err error) error
	SkipRoutes     []string // Routes to skip authentication (e.g., health checks)
}