copilot

type Action struct {
	// Action type (execute_attack, analyze_target, generate_report, etc.)
	Type ActionType

	// Action description
	Description string

	// Action parameters
	Parameters map[string]interface{}

	// Expected outcome
	ExpectedOutcome string

	// Risk level (low, medium, high)
	RiskLevel string

	// Requires user confirmation
	RequiresConfirmation bool
}

type ActionType string

type Alternative struct {
	Option      string
	Pros        []string
	Cons        []string
	Suitability float64
	Rationale   string
}

type Analysis struct {
	// Analysis identification
	ID        string
	Timestamp time.Time

	// Key insights
	Insights []Insight

	// Pattern recognition
	Patterns []Pattern

	// Recommendations for improvement
	Improvements []Improvement

	// Target vulnerability assessment
	Vulnerabilities []VulnerabilityAssessment

	// Defense effectiveness
	DefenseAnalysis *DefenseAnalysis

	// Future recommendations
	FutureTests []FutureTestRecommendation
}

type AttackConfiguration struct {
	TechniqueID     string
	Parameters      map[string]interface{}
	TargetProfile   *TargetProfile
	ExecutionMode   string
	TimeoutSettings map[string]time.Duration
	ResourceLimits  ResourceLimits
	SafetyOverrides []string
}

type AttackExecution struct {
	// Execution identification
	ExecutionID string
	AttackID    string
	AttackType  string

	// Execution details
	StartTime time.Time
	EndTime   time.Time
	Duration  time.Duration

	// Target information
	TargetID      string
	Configuration map[string]interface{}

	// Results
	Success    bool
	Confidence float64
	Response   string
	Evidence   []string

	// Metrics
	TokensUsed   int
	RequestsMade int
	Cost         float64

	// Learning data
	FailureReasons []string
	SuccessFactors []string
	Insights       []string

	// Context
	Environment  string
	UserFeedback string
	Metadata     map[string]interface{}
}

type AttackExecutor interface {
	Execute(ctx context.Context, config AttackConfiguration) (*AttackResult, error)
	ValidateConfig(config AttackConfiguration) error
	EstimateResourceUsage(config AttackConfiguration) ResourceEstimate
}

type AttackRecommendation struct {
	// Attack identification
	AttackID   string
	AttackType string
	AttackName string

	// Recommendation details
	Rationale  string
	Confidence float64
	Priority   int

	// Execution parameters
	Configuration map[string]interface{}

	// Expected outcomes
	ExpectedResults    []string
	SuccessProbability float64

	// Dependencies
	Prerequisites []string
	Dependencies  []string

	// Risk factors
	RiskLevel   string
	Mitigations []string

	// Learning potential
	LearningValue float64
	NoveltyScore  float64
}

type AttackRecommendations struct {
	// Primary recommendations
	Primary []AttackRecommendation

	// Alternative approaches
	Alternatives []AttackRecommendation

	// Experimental techniques
	Experimental []AttackRecommendation

	// Overall strategy
	Strategy *RecommendationStrategy

	// Success probability estimates
	SuccessProbability float64

	// Risk assessment
	RiskAssessment *RiskAssessment
}

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

type AttackResult struct {
	ConfigurationID string
	Success         bool
	Confidence      float64
	Evidence        []Evidence
	Metrics         ExecutionMetrics
	Learnings       []Insight
	Recommendations []string
	NextSteps       []string
}

type AttackTechnique struct {
	ID                   string
	Name                 string
	Category             string
	Description          string
	Complexity           int
	SuccessRate          float64
	RequiredCapabilities []string
	Executor             AttackExecutor
	ConfigGenerator      ConfigGenerator
}

type CLIConfig struct {
	ShowDebugInfo  bool
	SaveSession    bool
	SessionPath    string
	MaxHistorySize int
	PromptPrefix   string
	WelcomeMessage string
	ExitCommands   []string
	HelpCommands   []string
}

type CLISession struct {
	ID                string
	StartTime         time.Time
	QueryCount        int
	SuccessfulQueries int
	UserProfile       *UserProfile
	SessionData       map[string]interface{}
}

type ConfidenceFactor struct {
	Factor      string
	Impact      float64 // positive or negative
	Description string
}

type ConfidenceTrend struct {
	Timestamp time.Time
	Average   float64
	Count     int
}

type ConfigGenerator interface {
	GenerateConfig(target *TargetProfile, objective string, constraints *ExecutionConstraints) (*AttackConfiguration, error)
	OptimizeConfig(config *AttackConfiguration, feedback *ExecutionFeedback) (*AttackConfiguration, error)
}

type ContextAnalyzer struct{}

type ContingencyPlan struct {
	TriggerConditions []string
	Actions           []string
	Timeline          time.Duration
	Resources         []string
}

type ConversationFlowConfigGenerator struct{}

type ConversationFlowExecutor struct{}

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

type ConversationTracker struct{}

type ConversationTurn struct {
	UserMessage     string
	CopilotResponse string
	Timestamp       time.Time
	Actions         []string
	Results         []string
}

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

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

type CopilotMetrics struct{}

type CrossModalConfigGenerator struct{}

type CrossModalExecutor struct{}

type DefenseAnalysis struct {
	OverallEffectiveness float64
	DefenseTypes         []string
	Strengths            []string
	Weaknesses           []string
	Bypasses             []string
	Recommendations      []string
}

type Deliverable struct {
	Name         string
	Description  string
	Type         string
	DueDate      time.Time
	Owner        string
	Dependencies []string
}

type Dependency struct {
	Type        string
	Description string
	Impact      string
	Mitigation  string
}

type EngineConfig struct {
	// Natural language processing
	NLPModelEndpoint    string
	LanguageModels      map[string]string
	ConfidenceThreshold float64

	// Attack capabilities
	EnabledTechniques    []string
	MaxConcurrentAttacks int
	DefaultTimeouts      map[string]time.Duration

	// Knowledge management
	KnowledgeRetention time.Duration
	LearningRate       float64
	ContextWindow      int

	// Security constraints
	SafetyChecks      bool
	EthicalBoundaries []string
	AuditAllQueries   bool

	// Performance tuning
	CacheSize         int
	ResponseTimeout   time.Duration
	MaxTokensPerQuery int
}

type EntityExtractor struct{}

type Evidence struct {
	Type        string
	Content     string
	Confidence  float64
	Explanation string
}

type ExecutionConstraints struct {
	// Maximum number of attacks to suggest
	MaxAttacks int

	// Time budget for execution
	TimeLimit time.Duration

	// Resource limits
	MaxConcurrency     int
	MaxTokensPerAttack int

	// Safety constraints
	SafetyLevel          string
	ProhibitedTechniques []string

	// Target restrictions
	AllowedTargets   []string
	ForbiddenTargets []string
}

type ExecutionFeedback struct {
	Success     bool
	Performance map[string]float64
	Errors      []string
}

type ExecutionMetrics struct {
	Duration   time.Duration
	TokensUsed int
	MemoryUsed int64
	Cost       float64
}

type Explanation struct {
	// Summary explanation
	Summary string

	// Detailed reasoning
	Reasoning *Reasoning

	// Supporting evidence
	Evidence []string

	// Alternative considerations
	Alternatives []Alternative

	// Confidence factors
	ConfidenceFactors []ConfidenceFactor
}

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

type FutureTestRecommendation struct {
	TestType      string
	Description   string
	Priority      string
	Timeline      time.Duration
	Prerequisites []string
	ExpectedValue float64
}

type HouYiConfigGenerator struct{}

type HouYiExecutor struct{}

type IdentifiedRisk struct {
	ID          string
	Description string
	Probability float64
	Impact      string
	RiskLevel   string
	Owner       string
}

type Improvement struct {
	Area        string
	Description string
	Priority    string
	Difficulty  string
	Impact      string
	Steps       []string
}

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

type InfrastructureRequirement struct {
	Type           string
	Specifications map[string]interface{}
	Duration       time.Duration
	Cost           float64
}

type Insight struct {
	Type         string
	Description  string
	Confidence   float64
	Evidence     []string
	Implications []string
	Actionable   bool
}

type IntentClassifier struct{}

type Knowledge struct {
	ID         string
	Type       KnowledgeType
	Content    string
	Source     string
	Timestamp  time.Time
	Confidence float64
	Tags       []string
	Metadata   map[string]interface{}
}

type KnowledgeBase interface {
	// Store learned information
	Store(ctx context.Context, knowledge *Knowledge) error

	// Retrieve relevant knowledge
	Retrieve(ctx context.Context, query *KnowledgeQuery) ([]*Knowledge, error)

	// Update existing knowledge
	Update(ctx context.Context, knowledge *Knowledge) error

	// Delete knowledge
	Delete(ctx context.Context, id string) error

	// Search knowledge
	Search(ctx context.Context, query string) ([]*Knowledge, error)
}

type KnowledgeConfig struct {
	MaxItems         int
	RetentionPeriod  time.Duration
	AutoPersist      bool
	PersistInterval  time.Duration
	IndexingEnabled  bool
	FullTextSearch   bool
	CompressionLevel int
}

type KnowledgeQuery struct {
	Type          KnowledgeType
	Tags          []string
	Content       string
	MinConfidence float64
	MaxResults    int
	SortBy        string
}

type KnowledgeStatistics struct {
	TotalItems    int
	TypeCounts    map[KnowledgeType]int
	TagCounts     map[string]int
	ConfidenceAvg float64
	OldestItem    time.Time
	NewestItem    time.Time
}

type KnowledgeType string

type Logger interface {
	LogSecurityEvent(event string, data map[string]interface{})
}

type Milestone struct {
	Name         string
	Date         time.Time
	Description  string
	Deliverables []string
	Criteria     []string
}

type MitigationPlan struct {
	RiskID        string
	Strategy      string
	Actions       []string
	Timeline      time.Duration
	Cost          float64
	Effectiveness float64
}

type MockLogger struct{}

type MonitoringPlan struct {
	Metrics    []string
	Frequency  time.Duration
	Thresholds map[string]float64
	Alerts     []string
}

type ObjectiveConstraints struct {
	// Time constraints
	MaxDuration time.Duration

	// Resource constraints
	MaxCost   float64
	MaxTokens int

	// Technical constraints
	AllowedAttacks   []string
	ForbiddenAttacks []string

	// Risk constraints
	MaxRiskLevel string

	// Compliance constraints
	RequiredFrameworks []string
}

type ObjectiveType string

type ParsedQuery struct {
	Intent     string
	Entities   map[string]interface{}
	Context    map[string]interface{}
	Confidence float64
}

type Pattern struct {
	Type        string
	Description string
	Frequency   float64
	Conditions  []string
	Outcomes    []string
	Reliability float64
}

type PatternAnalysis struct {
	CommonTags       map[string]int
	TypeDistribution map[KnowledgeType]float64
	ConfidenceTrends []ConfidenceTrend
	TemporalPatterns []TemporalPattern
}

type PersistenceLayer interface {
	Save(ctx context.Context, knowledge map[string]*Knowledge) error
	Load(ctx context.Context) (map[string]*Knowledge, error)
	Backup(ctx context.Context, filename string) error
	Restore(ctx context.Context, filename string) error
}

type PersonnelRequirement struct {
	Role           string
	Skillset       []string
	Experience     string
	TimeCommitment time.Duration
}

type PreviousTest struct {
	Date        time.Time
	TestType    string
	AttacksUsed []string
	Results     string
	Findings    []string
	Remediation []string
}

type QueryNormalizer struct{}

type QueryOptions struct {
	// Context for the query
	Context map[string]interface{}

	// Previous conversation history
	History []ConversationTurn

	// User preferences
	Preferences *UserPreferences

	// Execution constraints
	Constraints *ExecutionConstraints
}

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

type QueryResponse struct {
	// Unique response ID
	ID string

	// Natural language response
	Response string

	// Structured actions to take
	Actions []Action

	// Attack recommendations
	Recommendations *AttackRecommendations

	// Follow-up questions
	FollowUpQuestions []string

	// Confidence in the response (0.0-1.0)
	Confidence float64

	// Reasoning explanation
	Reasoning *Reasoning

	// Additional metadata
	Metadata map[string]interface{}
}

type RateLimitInfo struct {
	RequestsPerMinute  int
	RequestsPerHour    int
	RequestsPerDay     int
	TokensPerMinute    int
	ConcurrentRequests int
}

type Reasoning struct {
	// Logical steps
	Steps []ReasoningStep

	// Assumptions made
	Assumptions []string

	// Data sources used
	DataSources []string

	// Methodology
	Methodology string
}

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

type ReasoningStep struct {
	StepNumber  int
	Description string
	Input       []string
	Process     string
	Output      string
	Confidence  float64
}

type RecommendationStrategy struct {
	// Strategy name
	Name string

	// Strategy description
	Description string

	// Strategic phases
	Phases []StrategyPhase

	// Success criteria
	SuccessCriteria []string

	// Risk mitigation
	RiskMitigation []string

	// Expected timeline
	Timeline time.Duration
}

type RedQueenConfigGenerator struct{}

type RedQueenExecutor struct{}

type ResourceEstimate struct {
	CPUTime    time.Duration
	Memory     int64
	TokenUsage int
	Cost       float64
}

type ResourceLimits struct {
	MaxMemory   int64
	MaxTokens   int
	MaxDuration time.Duration
	MaxCost     float64
}

type ResourceRequirements struct {
	// Human resources
	Personnel []PersonnelRequirement

	// Technical resources
	Infrastructure []InfrastructureRequirement

	// Financial resources
	Budget float64

	// Time resources
	Timeline time.Duration
}

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

type RiskAssessment struct {
	// Overall risk level
	OverallRisk string

	// Specific risk factors
	RiskFactors []RiskFactor

	// Mitigation strategies
	Mitigations []string

	// Monitoring recommendations
	Monitoring []string

	// Rollback procedures
	RollbackPlan []string
}

type RiskFactor struct {
	Type        string
	Description string
	Severity    string
	Probability float64
	Impact      string
	Mitigation  string
}

type RiskManagement struct {
	IdentifiedRisks  []IdentifiedRisk
	MitigationPlans  []MitigationPlan
	ContingencyPlans []ContingencyPlan
	MonitoringPlan   *MonitoringPlan
}

type SecurityCopilot interface {
	// ProcessQuery handles natural language security queries
	ProcessQuery(ctx context.Context, query string, options *QueryOptions) (*QueryResponse, error)

	// RecommendAttacks suggests appropriate attacks for a target
	RecommendAttacks(ctx context.Context, target *TargetProfile) (*AttackRecommendations, error)

	// AnalyzeResults learns from attack execution results
	AnalyzeResults(ctx context.Context, results []*AttackExecution) (*Analysis, error)

	// GenerateStrategy creates comprehensive testing strategies
	GenerateStrategy(ctx context.Context, objective *SecurityObjective) (*TestingStrategy, error)

	// ExplainReasoning provides explanations for recommendations
	ExplainReasoning(ctx context.Context, recommendation *AttackRecommendation) (*Explanation, error)
}

type SecurityObjective struct {
	// Objective identification
	ID          string
	Name        string
	Description string

	// Objective type (compliance, vulnerability_discovery, penetration_test, etc.)
	Type ObjectiveType

	// Target systems
	Targets []string

	// Success criteria
	SuccessCriteria []string

	// Constraints
	Constraints *ObjectiveConstraints

	// Timeline
	Deadline time.Time

	// Priority level
	Priority string

	// Stakeholders
	Stakeholders []string
}

type StrategyPhase struct {
	Name         string
	Description  string
	Duration     time.Duration
	Attacks      []string
	Objectives   []string
	Dependencies []string
}

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

type SuccessMetric struct {
	Name        string
	Description string
	Target      float64
	Measurement string
	Frequency   time.Duration
}

type TargetAnalysis struct {
	ModelType       string
	Capabilities    []string
	Vulnerabilities []string
	RiskLevel       string
}

type TargetProfile struct {
	// Basic identification
	ID          string
	Name        string
	Description string

	// Technical details
	ModelType    string
	Provider     string
	Version      string
	Capabilities []string

	// Deployment context
	Environment string // development, staging, production
	Industry    string
	UseCase     string

	// Security posture
	KnownDefenses        []string
	PreviousTests        []PreviousTest
	VulnerabilityHistory []VulnerabilityRecord

	// Compliance requirements
	ComplianceFrameworks  []string
	RegulatoryConstraints []string

	// Risk factors
	SensitivityLevel string
	DataTypes        []string
	UserBase         string

	// Technical constraints
	RateLimits             *RateLimitInfo
	AccessMethods          []string
	AuthenticationRequired bool
}

type TemporalPattern struct {
	Type        string
	Description string
	Value       float64
	Frequency   float64
}

type TestingPhase struct {
	ID          string
	Name        string
	Description string
	Duration    time.Duration

	// Attacks in this phase
	Attacks []string

	// Phase objectives
	Objectives []string

	// Dependencies
	Dependencies []string

	// Success criteria
	SuccessCriteria []string

	// Exit criteria
	ExitCriteria []string
}

type TestingStrategy struct {
	// Strategy identification
	ID          string
	Name        string
	Description string

	// Objective alignment
	ObjectiveID string

	// Strategy phases
	Phases []TestingPhase

	// Resource requirements
	Resources *ResourceRequirements

	// Timeline
	Timeline *Timeline

	// Risk management
	RiskManagement *RiskManagement

	// Success metrics
	SuccessMetrics []SuccessMetric

	// Deliverables
	Deliverables []Deliverable
}

type Timeline struct {
	StartDate    time.Time
	EndDate      time.Time
	Milestones   []Milestone
	Dependencies []Dependency
}

type UserPreferences struct {
	// Preferred attack categories
	PreferredCategories []string

	// Risk tolerance (conservative, moderate, aggressive)
	RiskTolerance string

	// Explanation detail level (brief, detailed, comprehensive)
	ExplanationLevel string

	// Automation level (manual, assisted, automated)
	AutomationLevel string

	// Industry context
	Industry string

	// Compliance requirements
	ComplianceFrameworks []string
}

type UserProfile struct {
	Username        string
	ExperienceLevel string
	Preferences     *UserPreferences
	ActiveTargets   []*TargetProfile
}

type VulnerabilityAssessment struct {
	VulnerabilityType string
	Severity          string
	Exploitability    float64
	Impact            string
	Remediation       []string
	Timeline          time.Duration
}

type VulnerabilityRecord struct {
	ID            string
	Type          string
	Severity      string
	Description   string
	Status        string // open, mitigated, fixed
	DiscoveryDate time.Time
	CVENumber     string
}