core

type Anomaly struct {
	ID          string                 `json:"id"`
	Type        string                 `json:"type"`
	Severity    string                 `json:"severity"`
	Description string                 `json:"description"`
	Evidence    []models.PluginResult  `json:"evidence"`
	Confidence  float64                `json:"confidence"`
	Indicators  []string               `json:"indicators"`
	Timestamp   time.Time              `json:"timestamp"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

type AttackPath struct {
	ID          string              `json:"id"`
	Name        string              `json:"name"`
	Entry       models.PluginResult `json:"entry"`
	Steps       []AttackStep        `json:"steps"`
	Goal        string              `json:"goal"`
	Likelihood  float64             `json:"likelihood"`
	Impact      float64             `json:"impact"`
	RiskScore   float64             `json:"risk_score"`
	Mitigations []Mitigation        `json:"mitigations"`
	Timeline    []TimelineEvent     `json:"timeline"`
}

type AttackStep struct {
	Finding     models.PluginResult   `json:"finding"`
	Technique   models.MITRETechnique `json:"technique"`
	Requirement string                `json:"requirement"`
	Achieved    bool                  `json:"achieved"`
	Confidence  float64               `json:"confidence"`
}

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

type CacheInterface interface {
	Get(ctx context.Context, key string) (interface{}, error)
	Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error
	Delete(ctx context.Context, key string) error
	Exists(ctx context.Context, key string) (bool, error)
	Clear(ctx context.Context) error
}

type Checkpoint struct {
	Target          string                `json:"target"`
	CompletedStages []string              `json:"completed_stages"`
	CurrentStage    string                `json:"current_stage"`
	Timestamp       time.Time             `json:"timestamp"`
	Results         []models.PluginResult `json:"results"`
	Workspace       string                `json:"workspace"`
}

type ContextEvent struct {
	Type      EventType              `json:"type"`
	Source    string                 `json:"source"`
	Data      interface{}            `json:"data"`
	Timestamp time.Time              `json:"timestamp"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

type Counter interface {
	Inc()
	Add(float64)
}

type DataFlowEdge struct {
	From     string `json:"from"`
	To       string `json:"to"`
	DataType string `json:"data_type"`
}

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

type EventType string

type ExecutionMetadata struct {
	CreatedAt         time.Time
	EstimatedDuration time.Duration
	TotalPlugins      int
	ParallelPhases    int
	SequentialPhases  int
	ResourcesRequired Resources
	CriticalPath      []string
	OptimizationLevel string
}

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

type ExecutionPhase struct {
	ID           string
	Name         string
	Plugins      []Plugin
	Parallel     bool
	MaxWorkers   int
	Timeout      time.Duration
	Resources    ResourceAllocation
	Dependencies []string
	Priority     int
}

type ExecutionPlan struct {
	ID          string
	Target      *models.Target
	Phases      []*ExecutionPhase
	Order       []Plugin
	Allocations map[string]ResourceAllocation
	Graph       *DependencyGraph
	Metadata    ExecutionMetadata
	ResultChan  chan models.PluginResult
}

type ExecutionStatus string

type Gauge interface {
	Set(float64)
	Inc()
	Dec()
	Add(float64)
	Sub(float64)
}

type Histogram interface {
	Observe(float64)
}

type IntelligenceInterface interface {
	Correlate(ctx context.Context, results []models.PluginResult) ([]models.Correlation, error)
	DetectAnomalies(ctx context.Context, results []models.PluginResult) ([]Anomaly, error)
	AnalyzeAttackPaths(ctx context.Context, results []models.PluginResult) ([]AttackPath, error)
	ScoreRisk(ctx context.Context, result models.PluginResult) (float64, error)
}

type Logger interface {
	Debug(msg string, fields ...interface{})
	Info(msg string, fields ...interface{})
	Warn(msg string, fields ...interface{})
	Error(msg string, err error, fields ...interface{})
	Fatal(msg string, err error, fields ...interface{})
	WithField(key string, value interface{}) Logger
	WithFields(fields map[string]interface{}) Logger
}

type MetricsInterface interface {
	Counter(name string) Counter
	Histogram(name string) Histogram
	Gauge(name string) Gauge
	Timer(name string) Timer
}

type Mitigation struct {
	ID            string   `json:"id"`
	Name          string   `json:"name"`
	Description   string   `json:"description"`
	Type          string   `json:"type"`          // preventive, detective, corrective
	Effectiveness float64  `json:"effectiveness"` // 0-1
	Cost          string   `json:"cost"`          // low, medium, high
	Complexity    string   `json:"complexity"`    // low, medium, high
	References    []string `json:"references"`
}

type OptimizationStrategy interface {
	Apply(phases []*ExecutionPhase, predictions map[string]PerformancePrediction) []*ExecutionPhase
	Name() string
}

type ParallelizationStrategy struct{}

type Pattern struct {
	Name        string                 `json:"name"`
	Type        string                 `json:"type"`
	Regex       string                 `json:"regex,omitempty"`
	Keywords    []string               `json:"keywords,omitempty"`
	Conditions  []PatternCondition     `json:"conditions,omitempty"`
	Confidence  float64                `json:"confidence"`
	Description string                 `json:"description"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

type PatternCondition struct {
	Field    string      `json:"field"`
	Operator string      `json:"operator"` // equals, contains, regex, gt, lt
	Value    interface{} `json:"value"`
}

type PerformancePrediction struct {
	PluginName      string
	Duration        time.Duration
	CPUUsage        float64
	MemoryUsage     int64
	NetworkRequests int
	Confidence      float64
}

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

type PerformanceRecord struct {
	PluginName      string
	Duration        time.Duration
	CPUUsage        float64
	MemoryUsage     int64
	NetworkRequests int
	Timestamp       time.Time
}

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

type PipelineStatus struct {
	State        string                 `json:"state"` // pending, running, completed, failed, paused
	CurrentStage string                 `json:"current_stage"`
	Progress     float64                `json:"progress"`
	StageStatus  map[string]StageStatus `json:"stage_status"`
	StartTime    time.Time              `json:"start_time"`
	EndTime      time.Time              `json:"end_time"`
	Duration     time.Duration          `json:"duration"`
	Error        string                 `json:"error,omitempty"`
}

type Plugin interface {
	// Metadata methods
	Name() string
	Category() string
	Description() string
	Version() string
	Author() string

	// Dependency methods
	RequiredBinaries() []string
	RequiredEnvVars() []string
	SupportedTargetTypes() []string
	Dependencies() []PluginDependency
	Provides() []string
	Consumes() []string

	// Lifecycle methods
	Validate(ctx context.Context, cfg *config.Config) error
	Prepare(ctx context.Context, target *models.Target, cfg *config.Config, shared *SharedContext) error
	Run(ctx context.Context, target *models.Target, results chan<- models.PluginResult, shared *SharedContext) error
	Teardown(ctx context.Context) error

	// Capability methods
	IsPassive() bool
	RequiresConfirmation() bool
	EstimatedDuration() time.Duration
	MaxConcurrency() int
	Priority() int
	ResourceRequirements() Resources

	// Intelligence methods
	ProcessDiscovery(ctx context.Context, discovery models.Discovery) error
	GetIntelligencePatterns() []Pattern
}

type PluginDependency struct {
	Plugin   string `json:"plugin"`
	Required bool   `json:"required"`
	Reason   string `json:"reason"`
}

type PluginExecution struct {
	Plugin     Plugin
	Target     *models.Target
	Status     ExecutionStatus
	StartTime  time.Time
	EndTime    time.Time
	Results    []models.PluginResult
	Error      error
	Context    context.Context
	CancelFunc context.CancelFunc
	ResultChan chan models.PluginResult
	// contains filtered or unexported fields
}

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

type PluginMetadata struct {
	Name         string
	Category     string
	Description  string
	Version      string
	Author       string
	Dependencies []PluginDependency
	Provides     []string
	Consumes     []string
	Passive      bool
	Confirmed    bool
	Resources    Resources
}

type PluginMetrics struct {
	Name            string        `json:"name"`
	ExecutionTime   time.Duration `json:"execution_time"`
	ResultCount     int           `json:"result_count"`
	ErrorCount      int           `json:"error_count"`
	CPUUsage        float64       `json:"cpu_usage"`
	MemoryUsage     int64         `json:"memory_usage"`
	NetworkRequests int           `json:"network_requests"`
	CacheHits       int           `json:"cache_hits"`
	CacheMisses     int           `json:"cache_misses"`
}

type PluginNode struct {
	Plugin       Plugin
	Dependencies []string
	Dependents   []string
	Provides     []string
	Requires     []string
	Weight       int
	Status       ExecutionStatus
	Results      []models.PluginResult
}

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

type PluginStatus struct {
	Name        string        `json:"name"`
	State       string        `json:"state"` // pending, running, completed, failed
	StartTime   time.Time     `json:"start_time"`
	EndTime     time.Time     `json:"end_time"`
	Duration    time.Duration `json:"duration"`
	ResultCount int           `json:"result_count"`
	Error       string        `json:"error,omitempty"`
}

type PriorityOptimizationStrategy struct{}

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

type QueueItem struct {
	ID        string                 `json:"id"`
	Type      string                 `json:"type"`
	Data      interface{}            `json:"data"`
	Source    string                 `json:"source"`
	Timestamp time.Time              `json:"timestamp"`
	Metadata  map[string]interface{} `json:"metadata"`
	Priority  int                    `json:"priority"`
}

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

type QueueStats struct {
	Name    string `json:"name"`
	Size    int    `json:"size"`
	IsFull  bool   `json:"is_full"`
	IsEmpty bool   `json:"is_empty"`
	MaxSize int    `json:"max_size"`
}

type RegistryStats struct {
	Total      int            `json:"total"`
	Categories map[string]int `json:"categories"`
	Passive    int            `json:"passive"`
	Active     int            `json:"active"`
	Confirmed  int            `json:"confirmed"`
}

type ResourceAllocation struct {
	CPUCores  int
	MemoryMB  int
	DiskMB    int
	NetworkBW string
	Processes int
}

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

type ResourceOptimizationStrategy struct{}

type Resources struct {
	CPUCores         int    `json:"cpu_cores"`
	MemoryMB         int    `json:"memory_mb"`
	DiskMB           int    `json:"disk_mb"`
	NetworkBandwidth string `json:"network_bandwidth"`
	MaxFileHandles   int    `json:"max_file_handles"`
	MaxProcesses     int    `json:"max_processes"`
	RequiresRoot     bool   `json:"requires_root"`
	NetworkAccess    bool   `json:"network_access"`
}

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

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

type Stage struct {
	Name         string        `json:"name"`
	Category     string        `json:"category"`
	Plugins      []string      `json:"plugins"`
	Required     bool          `json:"required"`
	NeedsConfirm bool          `json:"needs_confirm"`
	DependsOn    []string      `json:"depends_on"`
	Timeout      time.Duration `json:"timeout"`
	Passive      bool          `json:"passive"`
	Description  string        `json:"description"`
}

type StageStatus struct {
	State     string        `json:"state"` // pending, running, completed, failed, skipped
	StartTime time.Time     `json:"start_time"`
	EndTime   time.Time     `json:"end_time"`
	Duration  time.Duration `json:"duration"`
	Results   int           `json:"results"`
	Error     string        `json:"error,omitempty"`
}

type SystemResources struct {
	TotalCPUCores int
	TotalMemoryMB int
	TotalDiskMB   int
	MaxProcesses  int
}

type TimelineEvent struct {
	Timestamp   time.Time              `json:"timestamp"`
	Event       string                 `json:"event"`
	Description string                 `json:"description"`
	Source      string                 `json:"source"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

type Timer interface {
	Start() func()
	Record(time.Duration)
}

type Workspace struct {
	ID          string                 `json:"id"`
	Target      string                 `json:"target"`
	BasePath    string                 `json:"base_path"`
	ScanID      string                 `json:"scan_id"`
	CreatedAt   time.Time              `json:"created_at"`
	Directories map[string]string      `json:"directories"`
	Files       map[string][]string    `json:"files"`
	Metadata    map[string]interface{} `json:"metadata"`
	// contains filtered or unexported fields
}

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

type WorkspaceStats struct {
	TotalFiles     int            `json:"total_files"`
	TotalSize      int64          `json:"total_size"`
	DirectoryCount int            `json:"directory_count"`
	FilesByType    map[string]int `json:"files_by_type"`
	CreatedAt      time.Time      `json:"created_at"`
	LastModified   time.Time      `json:"last_modified"`
}

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