middleware

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

type CORSConfig struct {
	AllowOrigins     []string // Allowed origins
	AllowMethods     []string // Allowed HTTP methods
	AllowHeaders     []string // Allowed headers
	ExposeHeaders    []string // Headers to expose to client
	AllowCredentials bool     // Allow credentials
	MaxAge           int      // Max age for preflight requests
}

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

type CSRFConfig struct {
	TokenLength    int                           // Length of CSRF token
	TokenName      string                        // Name of the token in form/header
	CookieName     string                        // Name of the cookie to store token
	CookiePath     string                        // Path for the cookie
	CookieDomain   string                        // Domain for the cookie
	CookieSecure   bool                          // Secure flag for cookie
	CookieHTTPOnly bool                          // HTTPOnly flag for cookie
	CookieSameSite string                        // SameSite attribute for cookie
	Expiration     time.Duration                 // Token expiration time
	HeaderName     string                        // Header name for token
	ErrorHandler   func(*fiber.Ctx, error) error // Error handler
}

type CompressionConfig struct {
	Level    int      // Compression level (1-9)
	Types    []string // Content types to compress
	MinSize  int      // Minimum size to compress
	Excluded []string // Excluded paths
}

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

type GuardConfig struct {
	ErrorHandler func(*fiber.Ctx, error) error // Error handler for unauthorized access
	UserKey      string                        // Key to retrieve user from context
	RoleKey      string                        // Key to retrieve user role from context
}

type LoggerConfig struct {
	Format     string                // Log format
	TimeFormat string                // Time format
	TimeZone   string                // Time zone
	Output     *os.File              // Output destination
	SkipPaths  []string              // Paths to skip logging
	SkipFunc   func(*fiber.Ctx) bool // Function to determine if request should be skipped
}

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

type MiddlewareConfig struct {
	Environment       string
	EnableCORS        bool
	EnableCSRF        bool
	EnableSession     bool
	EnableRateLimit   bool
	EnableCompression bool
	EnableSecurity    bool
	EnableLogging     bool
	EnableRecovery    bool
	EnableRequestID   bool
}

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

type RateLimitConfig struct {
	Global   RateLimiterConfig // Global rate limit
	PerIP    RateLimiterConfig // Per IP rate limit
	PerUser  RateLimiterConfig // Per user rate limit
	PerRoute RateLimiterConfig // Per route rate limit
}

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

type RateLimiterConfig struct {
	Max        int                     // Maximum number of requests
	Expiration time.Duration           // Time window for rate limiting
	KeyFunc    func(*fiber.Ctx) string // Function to generate rate limit key
	Message    string                  // Error message when rate limit exceeded
	StatusCode int                     // HTTP status code when rate limit exceeded
}

type RecoveryConfig struct {
	EnableStackTrace bool                          // Enable stack trace in response
	StackTraceSize   int                           // Stack trace size limit
	ErrorHandler     func(*fiber.Ctx, error) error // Custom error handler
}

type RedisRateLimiter struct {
	// This would be implemented with Redis client
	// For now, we'll use the in-memory implementation
	*RateLimiter
}

type RequestIDConfig struct {
	Header     string        // Header name for request ID
	Generator  func() string // Function to generate request ID
	ContextKey string        // Key to store request ID in context
}

type SecurityConfig struct {
	XSSProtection             bool   // XSS Protection header
	ContentTypeNosniff        bool   // Content Type No Sniff header
	XFrameOptions             string // X-Frame-Options header value
	XContentTypeOptions       bool   // X-Content-Type-Options header
	ReferrerPolicy            string // Referrer-Policy header value
	PermissionsPolicy         string // Permissions-Policy header value
	StrictTransportSecurity   string // Strict-Transport-Security header value
	ContentSecurityPolicy     string // Content-Security-Policy header value
	ExpectCT                  string // Expect-CT header value
	CrossOriginEmbedderPolicy string // Cross-Origin-Embedder-Policy header value
	CrossOriginOpenerPolicy   string // Cross-Origin-Opener-Policy header value
	CrossOriginResourcePolicy string // Cross-Origin-Resource-Policy header value
}

type Session struct {
	ID        string                 `json:"id"`
	Data      map[string]interface{} `json:"data"`
	CreatedAt time.Time              `json:"created_at"`
	UpdatedAt time.Time              `json:"updated_at"`
	ExpiresAt time.Time              `json:"expires_at"`
}

type SessionConfig struct {
	Name            string        // Session cookie name
	Secret          string        // Secret key for session encryption
	CookiePath      string        // Path for the cookie
	CookieDomain    string        // Domain for the cookie
	CookieSecure    bool          // Secure flag for cookie
	CookieHTTPOnly  bool          // HTTPOnly flag for cookie
	CookieSameSite  string        // SameSite attribute for cookie
	Expiration      time.Duration // Session expiration time
	CleanupInterval time.Duration // Interval for cleaning up expired sessions
	Store           SessionStore  // Session store implementation
}

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

type SessionStore interface {
	Get(sessionID string) (*Session, error)
	Set(sessionID string, session *Session) error
	Delete(sessionID string) error
	Cleanup() error
}