plugin

type Alert struct {
	Level       string                 `json:"level"`
	Title       string                 `json:"title"`
	Description string                 `json:"description"`
	Timestamp   time.Time              `json:"timestamp"`
	Tags        map[string]string      `json:"tags"`
	Data        map[string]interface{} `json:"data"`
}

type AlertConfig struct {
	Provider string                 `json:"provider"`
	Webhook  string                 `json:"webhook"`
	Config   map[string]interface{} `json:"config"`
}

type AlertProvider interface {
	SendAlert(alert Alert) error
}

type AuditConfig struct {
	Level  string                 `json:"level"`
	Output string                 `json:"output"`
	Config map[string]interface{} `json:"config"`
}

type AuditEvent struct {
	Timestamp time.Time              `json:"timestamp"`
	User      string                 `json:"user"`
	Action    string                 `json:"action"`
	Resource  string                 `json:"resource"`
	Result    string                 `json:"result"`
	Details   map[string]interface{} `json:"details"`
}

type AuditLogger interface {
	LogEvent(event AuditEvent) error
}

type AuthConfig struct {
	Type     string                 `json:"type"`
	Provider string                 `json:"provider"`
	Config   map[string]interface{} `json:"config"`
}

type AuthProvider interface {
	Authenticate(username, password string) (bool, error)
	ValidateToken(token string) (bool, error)
}

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

type CoreExtensionPlugin interface {
	Plugin

	// Extend server initialization
	ExtendServerInit(server *Server) error

	// Modify server configuration
	ModifyConfig(config *Settings) error

	// Register custom services
	RegisterServices(host PluginHost) error
}

type DashboardConfig struct {
	Type     string                 `json:"type"`
	Endpoint string                 `json:"endpoint"`
	Config   map[string]interface{} `json:"config"`
}

type DashboardProvider interface {
	CreateDashboard(config DashboardConfig) error
	UpdateDashboard(id string, config DashboardConfig) error
}

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

type DependencyType string

type EncryptionConfig struct {
	Algorithm string                 `json:"algorithm"`
	KeySize   int                    `json:"key_size"`
	Config    map[string]interface{} `json:"config"`
}

type EncryptionProvider interface {
	Encrypt(data []byte) ([]byte, error)
	Decrypt(data []byte) ([]byte, error)
}

type EndpointProtectionRequest struct {
	Action      string   `json:"action"`       // "protect" or "whitelist"
	Paths       []string `json:"paths"`        // Endpoint paths to protect/whitelist
	Reason      string   `json:"reason"`       // Reason for the request
	RequesterID string   `json:"requester_id"` // Plugin requesting the change
	Temporary   bool     `json:"temporary"`    // Whether the protection is temporary
	Duration    string   `json:"duration"`     // Duration for temporary protection (e.g., "5m", "1h")
	Priority    int      `json:"priority"`     // Priority level (higher = more important)
}

type Logger interface {
	Info(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
	Error(msg string, args ...interface{})
	Debug(msg string, args ...interface{})
}

type MetricsCollector interface {
	Collect() (map[string]interface{}, error)
	Name() string
}

type MetricsConfig struct {
	Type     string                 `json:"type"`
	Endpoint string                 `json:"endpoint"`
	Config   map[string]interface{} `json:"config"`
}

type MiddlewareConfig struct {
	Path     string                 `json:"path"`
	Priority int                    `json:"priority"`
	Config   map[string]interface{} `json:"config"`
}

type MiddlewarePlugin interface {
	Plugin

	// Create middleware handler
	CreateMiddleware(config MiddlewareConfig) (func(http.Handler) http.Handler, error)

	// Middleware priority (lower numbers run first)
	Priority() int

	// Paths this middleware applies to
	ApplicablePaths() []string
}

type MonitoringPlugin interface {
	Plugin

	// Custom metrics collectors
	CreateMetricsCollector(config MetricsConfig) (MetricsCollector, error)

	// Alert providers
	CreateAlertProvider(config AlertConfig) (AlertProvider, error)

	// Dashboard providers
	CreateDashboardProvider(config DashboardConfig) (DashboardProvider, error)
}

type Plugin interface {
	// Initialize the plugin with server context and configuration
	Initialize(ctx context.Context, server PluginHost, config map[string]interface{}) error

	// Name returns the unique plugin identifier
	Name() string

	// Version returns the plugin version
	Version() string

	// Description returns human-readable plugin description
	Description() string

	// Dependencies returns required plugin dependencies
	Dependencies() []PluginDependency

	// Shutdown gracefully stops the plugin
	Shutdown(ctx context.Context) error
}

type PluginDependency struct {
	Name     string         `json:"name"`
	Version  string         `json:"version"`
	Type     DependencyType `json:"type"`
	Optional bool           `json:"optional"`
}

type PluginEvent struct {
	Type      string                 `json:"type"`
	Source    string                 `json:"source"`
	Timestamp time.Time              `json:"timestamp"`
	Data      map[string]interface{} `json:"data"`
}

type PluginEventHandler func(event PluginEvent) error

type PluginHost interface {
	// Register middleware handlers
	RegisterMiddleware(path string, middleware func(http.Handler) http.Handler) error

	// Register API endpoints
	RegisterHandler(pattern string, handler http.HandlerFunc) error

	// Access storage backend
	Storage() storage.Storage

	// Access configuration
	Config() *Settings

	// Access metrics system
	Metrics() *metrics.Metrics

	// Access logger
	Logger() *slog.Logger

	// Register periodic tasks
	RegisterTask(name string, interval time.Duration, task func(context.Context) error) error

	// Publish events to plugin system
	PublishEvent(event PluginEvent) error

	// Subscribe to plugin events
	SubscribeEvent(eventType string, handler PluginEventHandler) error
}

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

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

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

type SecurityPlugin interface {
	Plugin

	// Authentication providers
	CreateAuthProvider(config AuthConfig) (AuthProvider, error)

	// Audit logging enhancements
	CreateAuditLogger(config AuditConfig) (AuditLogger, error)

	// Encryption providers
	CreateEncryptionProvider(config EncryptionConfig) (EncryptionProvider, error)
}

type SecurityThreatInfo struct {
	ThreatType        string  `json:"threat_type"`        // Type of threat (e.g., "malicious_ip", "suspicious_behavior")
	Severity          string  `json:"severity"`           // "low", "medium", "high", "critical"
	ClientIP          string  `json:"client_ip"`          // IP address of the threat
	UserAgent         string  `json:"user_agent"`         // User agent string
	Endpoint          string  `json:"endpoint"`           // Endpoint being accessed
	Description       string  `json:"description"`        // Human-readable description
	Confidence        float64 `json:"confidence"`         // Confidence score (0.0 to 1.0)
	RecommendedAction string  `json:"recommended_action"` // "block", "monitor", "rate_limit"
}

type Server struct {
}

type Settings struct {
	Bind    string `toml:"bind"`
	DataDir string `toml:"dataDir"`
}

type StorageConfig struct {
	Type   string                 `json:"type"`
	Config map[string]interface{} `json:"config"`
}

type StoragePlugin interface {
	Plugin

	// Create storage backend instance
	CreateStorage(config StorageConfig) (storage.Storage, error)

	// Backend type identifier
	BackendType() string

	// Required configuration schema
	ConfigSchema() map[string]interface{}
}