platform

type AdaptationRules struct{}

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

type AlertManager struct{}

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

type AnalysisResult struct {
	CoverageAnalysis      *CoverageAnalysis
	EffectivenessAnalysis *EffectivenessAnalysis
	VulnerabilityAnalysis *VulnerabilityAnalysis
	RiskAnalysis          *RiskAnalysis
}

type AnomalyDetector struct{}

type ArchiveManager struct{}

type AttackCampaign struct {
	CampaignID      string
	Name            string
	Description     string
	TargetModels    []string
	AttackScenarios []AttackScenario
	ComplianceReqs  []ComplianceRequirement
	ExecutionPlan   *ExecutionPlan
	Progress        *CampaignProgress
	Results         *CampaignResults
	Metadata        *CampaignMetadata
}

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

type AttackEngine interface {
	ExecuteAttack(ctx context.Context, params AttackParameters) (*AttackResult, error)
	ValidateParameters(params AttackParameters) error
	GetCapabilities() []Capability
	GetResourceRequirements(params AttackParameters) *ResourceRequirements
}

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

type AttackParameters struct {
	AttackType          AttackType
	TargetModel         string
	Payload             string
	Configuration       map[string]interface{}
	TimeConstraints     *TimeConstraints
	QualityRequirements *QualityRequirements
}

type AttackPattern struct{}

type AttackResult struct {
	ResultID                string
	AttackType              AttackType
	Success                 bool
	EffectivenessScore      float64
	ExecutionTime           time.Duration
	ResourcesUsed           *ResourceUsage
	BypassedDefenses        []string
	DetectedVulnerabilities []Vulnerability
	Artifacts               map[string][]byte
	Metadata                map[string]interface{}
}

type AttackScenario struct {
	ScenarioID      string
	Name            string
	AttackChain     []AttackStep
	SuccessCriteria []SuccessCriterion
	RiskLevel       RiskLevel
	Dependencies    []string
}

type AttackStep struct {
	StepID          string
	AttackType      AttackType
	Parameters      map[string]interface{}
	Timing          StepTiming
	Preconditions   []Condition
	Postconditions  []Condition
	FailureHandling FailureStrategy
}

type AttackTaxonomy struct{}

type AttackType int

type AudioVisualAttackEngine struct{}

type AuditTracker struct{}

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

type BehaviorAnalyzer struct{}

type BenchmarkEngine struct{}

type BiologicalAttackEngine struct{}

type CampaignExecution struct {
	ExecutionID   string
	Campaign      *AttackCampaign
	ExecutionPlan *ExecutionPlan
	StartTime     time.Time
	EndTime       time.Time
	Duration      time.Duration
	Status        ExecutionStatus
	Results       *ExecutionResults
	ErrorMessage  string
	Metadata      map[string]interface{}
}

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

type CampaignMetadata struct{}

type CampaignProgress struct{}

type CampaignResults struct{}

type CampaignScheduler struct{}

type CampaignTemplate struct {
	TemplateID           string
	Name                 string
	Category             string
	AttackTypes          []AttackType
	Complexity           int
	EstimatedDuration    time.Duration
	ResourceRequirements *ResourceRequirements
	ComplianceMapping    []string
}

type Capability struct{}

type CategoryDefinition struct{}

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

type ClassificationRule struct{}

type CognitiveAttackEngine struct{}

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

type ComplianceFramework interface {
	ValidateCompliance(campaign *AttackCampaign) (*ComplianceResult, error)
	GetRequirements() []ComplianceRequirement
	GenerateReport(results []*AttackResult) (*ComplianceReport, error)
	GetFrameworkInfo() *FrameworkInfo
}

type ComplianceReport struct{}

type ComplianceReportGenerator struct{}

type ComplianceRequirement struct {
	RequirementID   string
	Framework       string
	Category        string
	Description     string
	Mandatory       bool
	ValidationRules []ValidationRule
	Evidence        []EvidenceType
}

type ComplianceResult struct {
	FrameworkID        string
	OverallStatus      ComplianceStatus
	RequirementResults []RequirementResult
	Recommendations    []Recommendation
	NonCompliantItems  []NonComplianceItem
}

type ComplianceSettings struct {
	EnabledFrameworks  []string
	AutomaticReporting bool
	ReportingSchedule  *Schedule
	RetentionPolicy    *RetentionPolicy
}

type ComplianceStatus int

type Condition struct{}

type CoverageAnalysis struct {
	ExecutionID      string
	TotalAttacks     int
	CategoryCoverage map[string]float64
	OwaspCoverage    map[string]float64
	GapAnalysis      []CoverageGap
	Recommendations  []Recommendation
}

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

type CoverageGap struct {
	Category    string
	GapType     string
	Severity    string
	Description string
}

type CoverageMetrics struct{}

type CrossModalAttackEngine struct{}

type CustomCategory struct{}

type DashboardManager struct{}

type DistributionEngine struct{}

type EUAIActFramework struct{}

type EconomicAttackEngine struct{}

type EffectivenessAnalysis struct{}

type EffectivenessPredictionModel struct{}

type EffectivenessTracker struct{}

type Entity struct {
	Text       string
	Label      string
	Confidence float64
	StartPos   int
	EndPos     int
}

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

type EvidenceType struct{}

type ExecutionPhase struct {
	PhaseID      string
	Name         string
	Description  string
	AttackSteps  []AttackStep
	Duration     time.Duration
	Dependencies []string
	CriticalPath bool
}

type ExecutionPlan struct {
	PlanID             string
	Phases             []ExecutionPhase
	ParallelExecutions []ParallelGroup
	ResourceAllocation *ResourceAllocation
	TimingConstraints  *TimingConstraints
	RollbackStrategy   *RollbackStrategy
}

type ExecutionQueue struct{}

type ExecutionResults struct {
	PhaseResults     []*PhaseResult
	AnalysisResult   *AnalysisResult
	ComplianceReport *ComplianceReport
}

type ExecutionStatus int

type ExploitabilityAnalyzer struct{}

type FailureHandler struct{}

type FailureStrategy struct{}

type FeedbackProcessor struct{}

type FrameworkInfo struct{}

type GapAnalyzer struct{}

type HouYiAttackEngine struct{}

type HyperdimensionalAttackEngine struct{}

type ISO42001Framework struct{}

type ImpactAnalyzer struct{}

type LearningEngine struct{}

type LoadBalancer struct{}

type MappingEngine struct{}

type MappingRule struct{}

type MetricsCollector struct{}

type MitigationEngine struct{}

type MonitoringConfig struct{}

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

type NERAnalysis struct {
	Categories    []string
	OwaspMappings []string
	Entities      []Entity
	Confidence    float64
}

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

type NERModel interface{}

type NISTAIRMFramework struct{}

type NonComplianceItem struct{}

type OwaspLLMFramework struct{}

type PAIRAttackEngine struct{}

type ParallelGroup struct {
	GroupID              string
	AttackSteps          []AttackStep
	SynchronizationPoint *SyncPoint
	MaxConcurrency       int
}

type PatternDetector struct{}

type PerformanceTracker struct{}

type PhaseResult struct {
	PhaseID              string
	StartTime            time.Time
	EndTime              time.Time
	Duration             time.Duration
	Status               PhaseStatus
	AttackResults        []*AttackResult
	OverallEffectiveness float64
	ErrorMessage         string
}

type PhaseStatus int

type PlatformConfiguration struct {
	MaxConcurrentCampaigns int
	DefaultTimeout         time.Duration
	ResourceLimits         *ResourceLimits
	ComplianceSettings     *ComplianceSettings
	MonitoringConfig       *MonitoringConfig
	SecuritySettings       *SecuritySettings
}

type QualityRequirements struct{}

type QuantumAttackEngine struct{}

type Recommendation struct {
	Type        string
	Priority    string
	Category    string
	Description string
	ActionItems []string
}

type RedQueenAttackEngine struct{}

type ReportGenerator interface{}

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

type RequirementResult struct{}

type ResourceAllocation struct{}

type ResourceLimits struct {
	MaxCPUUsage         float64
	MaxMemoryUsage      int64
	MaxStorageUsage     int64
	MaxNetworkBandwidth int64
	MaxExecutionTime    time.Duration
}

type ResourceManager struct{}

type ResourceRequirements struct{}

type ResourceUsage struct{}

type RetentionPolicy struct{}

type RiskAnalysis struct{}

type RiskAssessment struct{}

type RiskCalculator struct{}

type RiskLevel int

type RiskModel interface{}

type RollbackStrategy struct{}

type SOC2Framework struct{}

type Schedule struct{}

type SecuritySettings struct{}

type SeverityCalculator struct{}

type SignatureEngine struct{}

type StepTiming struct{}

type StrategyOptimizer struct{}

type SuccessCriterion struct{}

type SyncPoint struct{}

type TemplateManager struct{}

type TemporalAttackEngine struct{}

type TimeConstraints struct{}

type TrendAnalyzer struct{}

type ValidationRule struct{}

type Validator interface{}

type Vulnerability struct{}

type VulnerabilityAnalysis struct{}

type VulnerabilityDatabase struct{}

type VulnerabilityMapper struct{}