compliance

type AISystemDefinition struct {
	SystemID     string
	Name         string
	Description  string
	ModelType    string
	UseCase      string
	Domain       string
	Parameters   int64
	ComputeUsed  float64
	UserBase     int64
	DataSources  []string
	Capabilities []string
	Limitations  []string
}

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

type AISystemRiskLevel int

type AdversarialTester struct{}

type ArticleComplianceResult struct {
	Article           EUAIActArticle
	Status            ComplianceStatus
	Requirements      map[string]*RequirementResult
	TestResults       []*TestResult
	NonCompliantItems []NonComplianceItem
	Evidence          []Evidence
}

type AssessmentCriterion struct {
	CriterionID   string
	Name          string
	Weight        float64
	Score         float64
	Evidence      []string
	Justification string
}

type AssessmentEngine interface {
	Assess(control *Control, evidence []Evidence) (*AssessmentResult, error)
	CalculateCompliance(results []*AssessmentResult) float64
}

type AssessmentResult struct {
	ControlID       string                 `json:"controlId"`
	Status          string                 `json:"status"`
	ComplianceScore float64                `json:"complianceScore"`
	Findings        []Finding              `json:"findings"`
	Recommendations []string               `json:"recommendations"`
	AssessmentDate  time.Time              `json:"assessmentDate"`
	NextReviewDate  time.Time              `json:"nextReviewDate"`
	Details         map[string]interface{} `json:"details"`
}

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

type BiasMetric interface {
	CalculateBias(predictions, groundTruth []interface{}, demographics map[string]interface{}) (*BiasResult, error)
	GetBiasThreshold() float64
	GetMetricName() string
}

type BiasResult struct {
	MetricName      string
	BiasScore       float64
	IsCompliant     bool
	Demographics    map[string]float64
	Recommendations []string
	Evidence        []string
}

type CategoryCoverage struct {
	Category             OWASPLLMCategory
	Name                 string
	Status               string // "full", "partial", "not_covered"
	TemplatesCount       int
	SubcategoriesCovered int
	SubcategoriesTotal   int
	Templates            []TemplateSummary
	MissingSubcategories []OWASPLLMSubcategory
}

type CategoryInfo struct {
	ID            OWASPLLMCategory
	Name          string
	Description   string
	Subcategories []SubcategoryInfo
}

type Clause struct {
	ID           string        `json:"id"`
	Number       string        `json:"number"`
	Title        string        `json:"title"`
	Description  string        `json:"description"`
	Controls     []Control     `json:"controls"`
	Requirements []Requirement `json:"requirements"`
}

type CompletenessChecker struct{}

type ComplianceGap struct {
	Category             OWASPLLMCategory      `json:"category"`
	Name                 string                `json:"name"`
	Status               string                `json:"status"`
	MissingSubcategories []OWASPLLMSubcategory `json:"missing_subcategories"`
	Recommendation       string                `json:"recommendation"`
}

type ComplianceMapping struct {
	OWASPLLM []OWASPLLMMapping      `json:"owasp-llm,omitempty"`
	Other    map[string]interface{} `json:"-"`
}

type ComplianceRecommendation struct {
	RecommendationID string
	Priority         string
	Category         string
	Description      string
	ActionItems      []string
	Timeline         string
	ResponsibleParty string
}

type ComplianceReport struct {
	Standard          string                       `json:"standard"`
	AssessmentDate    time.Time                    `json:"assessmentDate"`
	Results           map[string]*AssessmentResult `json:"results"`
	OverallCompliance float64                      `json:"overallCompliance"`
	Recommendations   []Recommendation             `json:"recommendations"`
	ExecutiveSummary  string                       `json:"executiveSummary"`
}

type ComplianceRequirement struct {
	Article      EUAIActArticle
	Title        string
	Description  string
	Requirements []string
	TestCriteria []TestCriterion
	Mandatory    bool
	RiskLevels   []AISystemRiskLevel
}

type ComplianceStatus int

type ComplianceSummary struct {
	TotalCategories   int     `json:"total_categories"`
	CategoriesCovered int     `json:"categories_covered"`
	TotalTemplates    int     `json:"total_templates"`
	ComplianceScore   float64 `json:"compliance_score"`
	GapsIdentified    int     `json:"gaps_identified"`
}

type ConsentManager struct{}

type ConstraintType int

type Control struct {
	ID              string                 `json:"id"`
	ClauseNumber    string                 `json:"clauseNumber"`
	Title           string                 `json:"title"`
	Description     string                 `json:"description"`
	Type            string                 `json:"type"` // technical, organizational, documentation
	Implementation  ImplementationStatus   `json:"implementation"`
	Evidence        []Evidence             `json:"evidence"`
	Gaps            []Gap                  `json:"gaps"`
	Recommendations []string               `json:"recommendations"`
	Metadata        map[string]interface{} `json:"metadata"`
}

type CoverageLevel string

type DataBiasDetection struct{}

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

type DataLineageTracker struct{}

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

type DecisionTracker struct{}

type DecisionTransparencyResult struct {
	IsTransparent     RequirementStatus
	TransparencyScore float64
	DecisionLogs      []string
}

type DemographicAnalyzer struct{}

type DocumentationValidator struct{}

type EUAIActArticle int

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

type EUAIActComplianceReport struct {
	ReportID          string
	AISystemID        string
	AssessmentDate    time.Time
	Assessor          string
	RiskLevel         AISystemRiskLevel
	OverallStatus     ComplianceStatus
	ComplianceResults map[EUAIActArticle]*ArticleComplianceResult
	Recommendations   []ComplianceRecommendation
	Evidence          map[string][]Evidence
	NextAssessment    time.Time
}

type Evidence struct {
	ID          string                 `json:"id"`
	Type        string                 `json:"type"` // document, log, scan_result, test_result
	Title       string                 `json:"title"`
	Description string                 `json:"description"`
	Location    string                 `json:"location"`
	Date        time.Time              `json:"date"`
	Status      string                 `json:"status"`
	Metadata    map[string]interface{} `json:"metadata"`
}

type EvidenceStore interface {
	Store(evidence Evidence) error
	Retrieve(controlID string) ([]Evidence, error)
	Search(criteria map[string]interface{}) ([]Evidence, error)
}

type ExplainabilityMethod interface {
	GenerateExplanation(input interface{}, model interface{}) (*Explanation, error)
	ValidateExplanation(explanation *Explanation) (*ValidationResult, error)
	GetFidelity() float64
	GetComprehensibility() float64
}

type ExplainabilityResult struct {
	MeetsRequirements   RequirementStatus
	AverageScore        float64
	ExplanationExamples []string
}

type ExplainabilityTestSuite struct{}

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

type Explanation struct {
	ExplanationID     string
	Type              ExplanationType
	Content           interface{}
	Confidence        float64
	Fidelity          float64
	Completeness      float64
	Understandability float64
	Metadata          map[string]interface{}
}

type ExplanationType int

type FairnessResult struct {
	Demographic string
	Score       float64
	IsCompliant bool
	Violations  []string
	Mitigation  []string
}

type FairnessTest struct {
	TestID       string
	Name         string
	Description  string
	TestMethod   string
	PassCriteria []string
	Demographics []string
	Results      map[string]*FairnessResult
}

type Finding struct {
	ID          string    `json:"id"`
	Severity    string    `json:"severity"`
	Description string    `json:"description"`
	Impact      string    `json:"impact"`
	ControlID   string    `json:"controlId"`
	Timestamp   time.Time `json:"timestamp"`
}

type Gap struct {
	ID          string    `json:"id"`
	ControlID   string    `json:"controlId"`
	Description string    `json:"description"`
	Severity    string    `json:"severity"` // critical, high, medium, low
	DueDate     time.Time `json:"dueDate"`
	Status      string    `json:"status"` // open, in_progress, closed
}

type HumanCompetencyValidator struct{}

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

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

type ISO42001Standard struct {
	Name        string
	Version     string
	Description string
	Clauses     []Clause
}

type ISO42001Summary struct {
	TotalControls        int `json:"totalControls"`
	CompliantControls    int `json:"compliantControls"`
	PartialControls      int `json:"partialControls"`
	NonCompliantControls int `json:"nonCompliantControls"`
	CriticalGaps         int `json:"criticalGaps"`
	HighGaps             int `json:"highGaps"`
	MediumGaps           int `json:"mediumGaps"`
	LowGaps              int `json:"lowGaps"`
}

type ImpactAssessment struct{}

type ImplementationStatus struct {
	Status         string    `json:"status"` // not_implemented, partial, implemented, verified
	Percentage     float64   `json:"percentage"`
	LastAssessed   time.Time `json:"lastAssessed"`
	AssessedBy     string    `json:"assessedBy"`
	EffectiveDate  time.Time `json:"effectiveDate"`
	ExpirationDate time.Time `json:"expirationDate,omitempty"`
}

type IncidentTracker struct{}

type InterventionPoint struct {
	PointID           string
	Name              string
	TriggerConditions []string
	InterventionType  string
	ResponseTime      time.Duration
	Effectiveness     float64
}

type MitigationMeasuresResult struct {
	IsEffective         RequirementStatus
	EffectivenessScore  float64
	ImplementedMeasures []string
}

type MitigationPlanner struct{}

type NonComplianceItem struct{}

type OWASPComplianceReport struct {
	ReportID    string             `json:"report_id"`
	GeneratedAt string             `json:"generated_at"`
	Framework   string             `json:"framework"`
	Summary     ComplianceSummary  `json:"summary"`
	Categories  []CategoryCoverage `json:"categories"`
	Gaps        []ComplianceGap    `json:"gaps"`
}

type OWASPLLMCategory string

type OWASPLLMMapping struct {
	Category    OWASPLLMCategory    `json:"category"`
	Subcategory OWASPLLMSubcategory `json:"subcategory,omitempty"`
	Coverage    CoverageLevel       `json:"coverage,omitempty"`
}

type OWASPLLMSubcategory string

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

type OutcomeFairnessValidator struct{}

type OversightMechanism struct {
	MechanismID    string
	Name           string
	Type           OversightType
	Effectiveness  float64
	Implementation string
	Requirements   []string
	Validation     *OversightValidation
}

type OversightType int

type OversightValidation struct{}

type PrivacyValidator struct{}

type ProbabilityEngine struct{}

type QualityIssue struct {
	IssueType    string
	Severity     Severity
	Description  string
	AffectedData []string
	Mitigation   string
}

type QualityManagementValidator struct{}

type QualityMetric interface {
	AssessQuality(dataset interface{}) (*QualityResult, error)
	GetMetricName() string
	GetImportance() float64
}

type QualityResult struct {
	MetricName      string
	Score           float64
	Issues          []QualityIssue
	Recommendations []string
	IsCompliant     bool
}

type Recommendation struct {
	ID          string   `json:"id"`
	Priority    string   `json:"priority"`
	Description string   `json:"description"`
	Actions     []string `json:"actions"`
	Timeline    string   `json:"timeline"`
}

type RepresentativenessAnalyzer struct{}

type Requirement struct {
	ID          string `json:"id"`
	Description string `json:"description"`
	Mandatory   bool   `json:"mandatory"`
	Verifiable  bool   `json:"verifiable"`
}

type RequirementResult struct {
	RequirementID string
	Status        RequirementStatus
	Score         float64
	Evidence      []string
	Issues        []string
	Mitigation    []string
}

type RequirementStatus int

type ResponsibilityTracker struct{}

type RiskAnalysisResult struct {
	IsAdequate        RequirementStatus
	CompletenessScore float64
	Documentation     []string
}

type RiskCategory struct {
	CategoryID         string
	Name               string
	Description        string
	RiskFactors        []RiskFactor
	AssessmentCriteria []AssessmentCriterion
	Probability        float64
	Impact             float64
	RiskScore          float64
}

type RiskFactor struct {
	FactorID          string
	Name              string
	Weight            float64
	CurrentValue      float64
	TargetValue       float64
	MitigationActions []string
}

type RiskManagementSystemResult struct {
	HasRMS             RequirementStatus
	EffectivenessScore float64
	Evidence           []string
}

type RobustnessResult struct {
	Score           float64
	PassedTests     []string
	FailedTests     []string
	Vulnerabilities []Vulnerability
	Recommendations []string
}

type RobustnessTest struct {
	TestID        string
	Name          string
	TestType      RobustnessTestType
	Configuration map[string]interface{}
	PassThreshold float64
	Results       *RobustnessResult
}

type RobustnessTestType int

type SafetyConstraint struct {
	ConstraintID   string
	Name           string
	Type           ConstraintType
	Threshold      float64
	CurrentValue   float64
	IsViolated     bool
	ViolationCount int
	Severity       Severity
}

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

type Severity int

type SubcategoryInfo struct {
	ID          OWASPLLMSubcategory
	Name        string
	Description string
}

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

type TemplateSummary struct {
	ID          string
	Name        string
	Subcategory OWASPLLMSubcategory
	Coverage    CoverageLevel
}

type TestCriterion struct {
	CriterionID   string
	Name          string
	Description   string
	TestMethod    string
	PassThreshold float64
	FailThreshold float64
	Automated     bool
}

type TestResult struct {
	TestID    string
	TestName  string
	Status    TestStatus
	Score     float64
	Details   map[string]interface{}
	Timestamp time.Time
}

type TestStatus int

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

type UserInformationResult struct {
	IsAdequate          RequirementStatus
	CompletenessScore   float64
	ProvidedInformation []string
}

type UserInformationValidator struct{}

type ValidationResult struct{}

type Vulnerability struct{}