templates

type AMIConfig struct {
	// AMI deployment strategy
	Strategy AMIStrategy `yaml:"strategy,omitempty" json:"strategy,omitempty"` // ami_preferred, ami_required, ami_fallback

	// Direct AMI mappings (highest priority resolution)
	AMIMappings map[string]string `yaml:"ami_mappings,omitempty" json:"ami_mappings,omitempty"` // region -> AMI ID

	// Dynamic AMI search configuration (second priority)
	AMISearch *AMISearchConfig `yaml:"ami_search,omitempty" json:"ami_search,omitempty"`

	// AWS Marketplace search configuration (third priority)
	MarketplaceSearch *MarketplaceSearchConfig `yaml:"marketplace_search,omitempty" json:"marketplace_search,omitempty"`

	// Fallback behavior when no AMI available
	FallbackStrategy string `yaml:"fallback_strategy,omitempty" json:"fallback_strategy,omitempty"` // script_provisioning, error, cross_region
	FallbackTimeout  string `yaml:"fallback_timeout,omitempty" json:"fallback_timeout,omitempty"`   // Max time for AMI resolution (e.g. "10m")

	// Cost and performance optimization
	PreferredArchitecture    string   `yaml:"preferred_architecture,omitempty" json:"preferred_architecture,omitempty"`         // arm64, x86_64
	InstanceFamilyPreference []string `yaml:"instance_family_preference,omitempty" json:"instance_family_preference,omitempty"` // ["t4g", "m6i", "c6i"]

	// Legacy compatibility (maintains backwards compatibility)
	AMIs           map[string]map[string]string `yaml:"amis,omitempty" json:"amis,omitempty"`                         // region -> arch -> AMI ID (legacy)
	InstanceTypes  map[string]string            `yaml:"instance_types,omitempty" json:"instance_types,omitempty"`     // arch -> instance type (legacy)
	UserDataScript string                       `yaml:"user_data_script,omitempty" json:"user_data_script,omitempty"` // Optional customization script
	SSHUser        string                       `yaml:"ssh_user,omitempty" json:"ssh_user,omitempty"`                 // SSH username for AMI
}

type AMIConfigValidator struct {
	// Known AWS regions for validation
	ValidRegions map[string]bool

	// Known AWS account IDs for trusted sources
	TrustedAccounts map[string]string // account_id -> description

	// AMI ID pattern validation
	AMIPattern *regexp.Regexp
}

type AMIDiscoveryService interface {
	// GetAMIWithFallback attempts dynamic discovery first, then falls back to static AMI
	GetAMIWithFallback(ctx context.Context, distro, version, region, arch, staticFallback string) (ami string, source string, err error)
}

type AMISearchConfig struct {
	Owner           string            `yaml:"owner,omitempty" json:"owner,omitempty"`                         // AWS account ID or alias
	NamePattern     string            `yaml:"name_pattern,omitempty" json:"name_pattern,omitempty"`           // AMI name pattern (e.g. "prism-python-ml-*")
	VersionTag      string            `yaml:"version_tag,omitempty" json:"version_tag,omitempty"`             // Specific version tag
	Architecture    []string          `yaml:"architecture,omitempty" json:"architecture,omitempty"`           // ["x86_64", "arm64"]
	MinCreationDate string            `yaml:"min_creation_date,omitempty" json:"min_creation_date,omitempty"` // ISO date string
	RequiredTags    map[string]string `yaml:"required_tags,omitempty" json:"required_tags,omitempty"`         // Tags that must be present
}

type AMIStrategy string

type AppliedTemplate struct {
	Name               string    `json:"name"`
	AppliedAt          time.Time `json:"applied_at"`
	PackageManager     string    `json:"package_manager"`
	PackagesInstalled  []string  `json:"packages_installed"`
	ServicesConfigured []string  `json:"services_configured"`
	UsersCreated       []string  `json:"users_created"`
	RollbackCheckpoint string    `json:"rollback_checkpoint"`
}

type ApplyRequest struct {
	InstanceName   string    `json:"instance_name"`
	Template       *Template `json:"template"`
	PackageManager string    `json:"package_manager,omitempty"` // Override template default
	DryRun         bool      `json:"dry_run"`
	Force          bool      `json:"force"` // Override conflicts
}

type ApplyResponse struct {
	Success            bool          `json:"success"`
	Message            string        `json:"message"`
	PackagesInstalled  int           `json:"packages_installed"`
	ServicesConfigured int           `json:"services_configured"`
	UsersCreated       int           `json:"users_created"`
	RollbackCheckpoint string        `json:"rollback_checkpoint"`
	Warnings           []string      `json:"warnings"`
	ExecutionTime      time.Duration `json:"execution_time"`
}

type ApplyResult struct {
	PackagesInstalled  int      `json:"packages_installed"`
	ServicesConfigured int      `json:"services_configured"`
	UsersCreated       int      `json:"users_created"`
	Warnings           []string `json:"warnings"`
}

type BackupFile struct {
	OriginalPath string `json:"original_path"`
	BackupPath   string `json:"backup_path"`
	Checksum     string `json:"checksum"`
}

type BestPracticeViolation struct {
	Practice   string `json:"practice"`
	Violation  string `json:"violation"`
	Impact     string `json:"impact"`
	Suggestion string `json:"suggestion"`
}

type BestPracticesRule struct{}

type CVEDatabase interface {
	QueryVulnerabilities(ctx context.Context, packages []string) ([]VulnerabilityInfo, error)
}

type CacheEntry struct {
	Template     *Template `json:"template"`
	CachedAt     time.Time `json:"cached_at"`
	SourceURL    string    `json:"source_url"`
	SourceBranch string    `json:"source_branch"`
	TemplatePath string    `json:"template_path"`
}

type CacheOptions struct {
	CacheDir string        // Directory for cache storage
	TTL      time.Duration // Time-to-live for cached templates
}

type CachedAMIMapping struct {
	Mapping  map[string]map[string]string // region -> arch -> AMI ID
	CachedAt time.Time
	Region   string
	Arch     string
}

type CachedTemplate struct {
	Template *Template
	CachedAt time.Time
	Hash     string
}

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

type CommunityMetadata struct {
	// Author information
	Author          string   `json:"author"`
	MaintainerEmail string   `json:"maintainer_email,omitempty"`
	Repository      string   `json:"repository"`
	License         string   `json:"license"`
	Keywords        []string `json:"keywords,omitempty"`

	// Versioning
	TemplateVersion string    `json:"template_version"`
	PrismMinVersion string    `json:"prism_min_version"`
	LastUpdated     time.Time `json:"last_updated"`
	Changelog       string    `json:"changelog,omitempty"`

	// Support and documentation
	DocumentationURL string `json:"documentation_url,omitempty"`
	IssuesURL        string `json:"issues_url,omitempty"`
	HomepageURL      string `json:"homepage_url,omitempty"`

	// Community engagement
	Downloads      int       `json:"downloads"`
	Stars          int       `json:"stars"`
	Rating         float64   `json:"rating"` // 0.0-5.0
	RatingCount    int       `json:"rating_count"`
	Featured       bool      `json:"featured"`
	Verified       bool      `json:"verified"`
	LastDownloaded time.Time `json:"last_downloaded,omitempty"`

	// Security
	SecurityScanned  bool      `json:"security_scanned"`
	SecurityScanDate time.Time `json:"security_scan_date,omitempty"`
	SecurityScore    int       `json:"security_score"` // 0-100
	TrustLevel       string    `json:"trust_level"`    // verified/community/unverified

	// Dependencies and compatibility
	Dependencies      []string `json:"dependencies,omitempty"`
	ConflictsWith     []string `json:"conflicts_with,omitempty"`
	RecommendedWith   []string `json:"recommended_with,omitempty"`
	CompatibleRegions []string `json:"compatible_regions,omitempty"`

	// Usage statistics
	UsageStats UsageStatistics `json:"usage_stats,omitempty"`
}

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

type CommunitySource struct {
	Name       string    `json:"name"`
	URL        string    `json:"url"`    // GitHub repo URL
	Branch     string    `json:"branch"` // main/master/etc
	Enabled    bool      `json:"enabled"`
	TrustLevel string    `json:"trust_level"` // verified/community/unverified
	Added      time.Time `json:"added"`
	LastSync   time.Time `json:"last_sync,omitempty"`
}

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

type ConfigurationAnalysis struct {
	SecurityMisconfigurations []SecurityMisconfiguration `json:"security_misconfigurations,omitempty"`
	BestPracticeViolations    []BestPracticeViolation    `json:"best_practice_violations,omitempty"`
	NetworkSecurityIssues     []NetworkSecurityIssue     `json:"network_security_issues,omitempty"`
	PrivilegeEscalations      []PrivilegeEscalation      `json:"privilege_escalations,omitempty"`
}

type ConfigurationScanner interface {
	ScanConfiguration(ctx context.Context, template *Template) (*ConfigurationAnalysis, error)
}

type ConflictDiff struct {
	Type        string `json:"type"` // "package", "service", "user", "port"
	Description string `json:"description"`
	Resolution  string `json:"resolution"` // "skip", "force", "merge"
}

type ConnectionType = types.ConnectionType

type ContentAnalysis struct {
	// Template structure
	TemplateSize     int64   `json:"template_size_bytes"`
	ComplexityScore  float64 `json:"complexity_score"`
	MaintenanceScore float64 `json:"maintenance_score"`

	// Content quality
	DocumentationScore   float64 `json:"documentation_score"`
	DescriptionQuality   string  `json:"description_quality"` // excellent, good, adequate, poor
	MetadataCompleteness float64 `json:"metadata_completeness"`

	// Technical analysis
	PackageAnalysis       PackageAnalysis       `json:"package_analysis"`
	ConfigurationAnalysis ConfigurationAnalysis `json:"configuration_analysis"`

	// Security content analysis
	SecretsFound       []SecretFinding `json:"secrets_found,omitempty"`
	SuspiciousPatterns []PatternMatch  `json:"suspicious_patterns,omitempty"`
}

type CostOptimizationRule struct{}

type DependencyAnalysis struct {
	Name             string            `json:"name"`
	Version          string            `json:"version,omitempty"`
	Type             string            `json:"type"` // package, template, system
	Source           string            `json:"source,omitempty"`
	SecurityFindings []SecurityFinding `json:"security_findings,omitempty"`
	LicenseInfo      LicenseInfo       `json:"license_info,omitempty"`
	Status           string            `json:"status"` // safe, vulnerable, unknown
}

type DependencyChecker interface {
	CheckDependencies(ctx context.Context, dependencies []TemplateDependency) ([]DependencyAnalysis, error)
}

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

type DesktopConfig struct {
	// Desktop environment to install
	Environment string `yaml:"environment" json:"environment"` // "mate", "xfce", "gnome", "kde"

	// Nice DCV configuration
	DCVPort    int    `yaml:"dcv_port,omitempty" json:"dcv_port,omitempty"`       // DCV server port (default: 8443)
	DCVVersion string `yaml:"dcv_version,omitempty" json:"dcv_version,omitempty"` // DCV version to install (default: "latest")

	// Hardware requirements
	GPURequired bool `yaml:"gpu_required,omitempty" json:"gpu_required,omitempty"` // Require GPU for visualization

	// Session configuration
	SessionType string `yaml:"session_type,omitempty" json:"session_type,omitempty"` // "console" or "virtual" (default: "virtual")
	SessionUser string `yaml:"session_user,omitempty" json:"session_user,omitempty"` // User for DCV session (default: template user)

	// Authentication
	AuthMethod string `yaml:"auth_method,omitempty" json:"auth_method,omitempty"` // "password" or "none" (default: "password")
}

type DesktopConfigRule struct{}

type DiffRequest struct {
	InstanceName string    `json:"instance_name"`
	Template     *Template `json:"template"`
}

type EnabledPlugin struct {
	Name          string                 `yaml:"name" json:"name"`
	Version       string                 `yaml:"version,omitempty" json:"version,omitempty"`
	Conditional   string                 `yaml:"conditional,omitempty" json:"conditional,omitempty"` // Template condition (e.g., "{{.install_plugin}}")
	Configuration map[string]interface{} `yaml:"configuration,omitempty" json:"configuration,omitempty"`
}

type EnhancedTemplate struct {
	*Template
	Community *CommunityMetadata `json:"community,omitempty"`
}

type ExecutionResult struct {
	ExitCode int           `json:"exit_code"`
	Stdout   string        `json:"stdout"`
	Stderr   string        `json:"stderr"`
	Duration time.Duration `json:"duration"`
}

type ExistingUser struct {
	Name   string   `json:"name"`
	Groups []string `json:"groups"`
	Shell  string   `json:"shell"`
	Source string   `json:"source"` // "template" or "manual"
}

type FileConfig struct {
	// Source S3 location
	S3Bucket string `yaml:"s3_bucket" json:"s3_bucket"` // S3 bucket name
	S3Key    string `yaml:"s3_key" json:"s3_key"`       // S3 object key

	// Destination on instance
	DestinationPath string `yaml:"destination_path" json:"destination_path"` // Target path on instance

	// File properties
	Owner       string `yaml:"owner,omitempty" json:"owner,omitempty"`             // File owner (default: current user)
	Group       string `yaml:"group,omitempty" json:"group,omitempty"`             // File group (default: current user's group)
	Permissions string `yaml:"permissions,omitempty" json:"permissions,omitempty"` // File permissions (e.g., "0644")

	// Transfer options
	Checksum    bool `yaml:"checksum,omitempty" json:"checksum,omitempty"`         // Enable MD5 checksum verification (default: true)
	AutoCleanup bool `yaml:"auto_cleanup,omitempty" json:"auto_cleanup,omitempty"` // Delete from S3 after successful download (default: false)

	// Conditional provisioning
	Required bool   `yaml:"required,omitempty" json:"required,omitempty"` // Fail template launch if file transfer fails (default: true)
	OnlyIf   string `yaml:"only_if,omitempty" json:"only_if,omitempty"`   // Conditional expression (e.g., "arch == 'x86_64'")

	// Description for documentation
	Description string `yaml:"description,omitempty" json:"description,omitempty"` // Human-readable description
}

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

type IdleDetectionConfig = types.IdleDetectionConfig

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

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

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

type InstalledPackage struct {
	Name           string `json:"name"`
	Version        string `json:"version"`
	PackageManager string `json:"package_manager"`
	Source         string `json:"source"` // "template" or "manual"
}

type InstanceDefaults struct {
	Type                 string             `yaml:"type,omitempty" json:"type,omitempty"` // Default instance type
	Ports                []int              `yaml:"ports,omitempty" json:"ports,omitempty"`
	RootVolumeGB         int                `yaml:"root_volume_gb,omitempty" json:"root_volume_gb,omitempty"`                   // Root volume size in GB (default: 20)
	EstimatedCostPerHour map[string]float64 `yaml:"estimated_cost_per_hour,omitempty" json:"estimated_cost_per_hour,omitempty"` // arch -> cost
}

type InstanceState struct {
	Packages         []InstalledPackage `json:"packages"`
	Services         []RunningService   `json:"services"`
	Users            []ExistingUser     `json:"users"`
	Ports            []int              `json:"ports"`
	PackageManager   string             `json:"package_manager"`
	AppliedTemplates []AppliedTemplate  `json:"applied_templates"`
	LastInspected    time.Time          `json:"last_inspected"`
}

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

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

type LicenseChecker interface {
	ValidateLicenses(ctx context.Context, template *Template) ([]LicenseConflict, error)
}

type LicenseConflict struct {
	Package1 string `json:"package1"`
	License1 string `json:"license1"`
	Package2 string `json:"package2"`
	License2 string `json:"license2"`
	Conflict string `json:"conflict_reason"`
}

type LicenseInfo struct {
	License      string   `json:"license"`
	Compatible   bool     `json:"compatible"`
	Restrictions []string `json:"restrictions,omitempty"`
}

type LicenseRegistry interface {
	GetLicenseInfo(ctx context.Context, license string) (*LicenseInfo, error)
}

type MarketplaceBadge struct {
	Type        string     `yaml:"type" json:"type"`   // verified, trending, editor_choice, community_favorite
	Label       string     `yaml:"label" json:"label"` // Display text
	Description string     `yaml:"description,omitempty" json:"description,omitempty"`
	EarnedAt    *time.Time `yaml:"earned_at,omitempty" json:"earned_at,omitempty"`
}

type MarketplaceConfig struct {
	// Registry information
	Registry     string `yaml:"registry,omitempty" json:"registry,omitempty"`           // Registry URL or identifier (community, institutional, private)
	RegistryType string `yaml:"registry_type,omitempty" json:"registry_type,omitempty"` // community, institutional, private, official

	// Publication metadata
	PublishedAt      *time.Time `yaml:"published_at,omitempty" json:"published_at,omitempty"`
	Publisher        string     `yaml:"publisher,omitempty" json:"publisher,omitempty"`   // Organization or user who published
	License          string     `yaml:"license,omitempty" json:"license,omitempty"`       // Template license (MIT, Apache-2.0, etc.)
	SourceURL        string     `yaml:"source_url,omitempty" json:"source_url,omitempty"` // Git repository or source location
	DocumentationURL string     `yaml:"documentation_url,omitempty" json:"documentation_url,omitempty"`

	// Community metrics
	Downloads   int64   `yaml:"downloads,omitempty" json:"downloads,omitempty"`       // Download/usage count
	Rating      float64 `yaml:"rating,omitempty" json:"rating,omitempty"`             // Average user rating (0-5)
	RatingCount int     `yaml:"rating_count,omitempty" json:"rating_count,omitempty"` // Number of ratings

	// Security and validation
	SecurityScan    *MarketplaceSecurityScanResult `yaml:"security_scan,omitempty" json:"security_scan,omitempty"`
	ValidationTests []ValidationTest               `yaml:"validation_tests,omitempty" json:"validation_tests,omitempty"`

	// Marketplace categories and discoverability
	Keywords   []string           `yaml:"keywords,omitempty" json:"keywords,omitempty"`     // Search keywords
	Categories []string           `yaml:"categories,omitempty" json:"categories,omitempty"` // Marketplace categories
	Badges     []MarketplaceBadge `yaml:"badges,omitempty" json:"badges,omitempty"`         // Quality badges
	Verified   bool               `yaml:"verified,omitempty" json:"verified,omitempty"`     // Official verification status

	// Dependency information
	Dependencies  []TemplateDependency `yaml:"dependencies,omitempty" json:"dependencies,omitempty"`   // Other templates this depends on
	Dependents    []string             `yaml:"dependents,omitempty" json:"dependents,omitempty"`       // Templates that depend on this
	Compatibility []string             `yaml:"compatibility,omitempty" json:"compatibility,omitempty"` // Compatible Prism versions
}

type MarketplaceSearchConfig struct {
	ProductCode       string `yaml:"product_code,omitempty" json:"product_code,omitempty"`             // Marketplace product code
	VersionConstraint string `yaml:"version_constraint,omitempty" json:"version_constraint,omitempty"` // Version constraint (e.g. ">=2.0.0")
	Publisher         string `yaml:"publisher,omitempty" json:"publisher,omitempty"`                   // Publisher filter
}

type MarketplaceSearchResult struct {
	Templates     []MarketplaceTemplateRegistryEntry `json:"templates"`
	TotalCount    int                                `json:"total_count"`
	FilteredCount int                                `json:"filtered_count"`
	Query         SearchFilter                       `json:"query"`
	ExecutionTime time.Duration                      `json:"execution_time"`
}

type MarketplaceSecurityScanResult struct {
	Status    string            `yaml:"status" json:"status"` // passed, failed, warning, pending
	ScanDate  time.Time         `yaml:"scan_date" json:"scan_date"`
	Scanner   string            `yaml:"scanner" json:"scanner"` // Tool used for scanning
	Findings  []SecurityFinding `yaml:"findings,omitempty" json:"findings,omitempty"`
	Score     float64           `yaml:"score,omitempty" json:"score,omitempty"`           // Security score (0-100)
	ReportURL string            `yaml:"report_url,omitempty" json:"report_url,omitempty"` // Detailed report link
}

type MarketplaceTemplateRegistry struct {
	Name        string
	URL         string
	Type        RegistryType
	Credentials *RegistryCredentials
	Client      *http.Client
}

type MarketplaceTemplateRegistryEntry struct {
	*Template

	// Registry-specific metadata
	RegistryName string    `json:"registry_name"`
	RegistryType string    `json:"registry_type"`
	LastSynced   time.Time `json:"last_synced"`

	// Enhanced search metadata
	SearchTags     []string `json:"search_tags"`     // Computed from template content
	PopularityRank int      `json:"popularity_rank"` // Registry-specific ranking
}

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

type MarketplaceValidationError struct {
	Code    string `json:"code"`
	Message string `json:"message"`
	Field   string `json:"field,omitempty"`
	Value   any    `json:"value,omitempty"`
}

type MarketplaceValidationResult struct {
	// Overall validation status
	Status      ValidationStatus `json:"status"`
	Score       float64          `json:"score"` // 0-100 overall quality score
	ValidatedAt time.Time        `json:"validated_at"`
	ValidatorID string           `json:"validator_id"`

	// Security analysis
	SecurityScan MarketplaceSecurityScanResult `json:"security_scan"`

	// Quality analysis
	QualityChecks []QualityCheck `json:"quality_checks"`

	// Dependency analysis
	Dependencies []DependencyAnalysis `json:"dependencies"`

	// Content analysis
	ContentAnalysis ContentAnalysis `json:"content_analysis"`

	// Recommendations
	Recommendations []Recommendation `json:"recommendations"`

	// Errors and warnings
	Errors   []MarketplaceValidationError   `json:"errors,omitempty"`
	Warnings []MarketplaceValidationWarning `json:"warnings,omitempty"`
}

type MarketplaceValidationWarning struct {
	Code    string `json:"code"`
	Message string `json:"message"`
	Field   string `json:"field,omitempty"`
	Impact  string `json:"impact"` // low, medium, high
}

type MarketplaceValidator struct {
	// Security scanners
	PackageScanner PackageSecurityScanner
	SecretsScanner SecretsScanner
	ConfigScanner  ConfigurationScanner

	// Quality checkers
	DependencyChecker DependencyChecker
	LicenseChecker    LicenseChecker

	// External integrations
	CVEDatabase     CVEDatabase
	LicenseRegistry LicenseRegistry

	// Validation configuration
	Config *ValidationConfig
}

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

type NetworkSecurityIssue struct {
	Type        string `json:"type"`
	Description string `json:"description"`
	Risk        string `json:"risk"`
	Ports       []int  `json:"ports,omitempty"`
}

type OptimizedResolver struct {
	*TemplateResolver
	// contains filtered or unexported fields
}

type OutdatedPackage struct {
	Package        string `json:"package"`
	CurrentVersion string `json:"current_version"`
	LatestVersion  string `json:"latest_version"`
	SecurityRisk   string `json:"security_risk"` // high, medium, low
}

type PackageAnalysis struct {
	TotalPackages        int                 `json:"total_packages"`
	KnownVulnerabilities []VulnerabilityInfo `json:"known_vulnerabilities,omitempty"`
	UnknownPackages      []string            `json:"unknown_packages,omitempty"`
	OutdatedPackages     []OutdatedPackage   `json:"outdated_packages,omitempty"`
	LicenseConflicts     []LicenseConflict   `json:"license_conflicts,omitempty"`
}

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

type PackageDefinitions struct {
	System []string `yaml:"system,omitempty" json:"system,omitempty"` // apt/dnf packages
	Conda  []string `yaml:"conda,omitempty" json:"conda,omitempty"`   // conda packages
	Spack  []string `yaml:"spack,omitempty" json:"spack,omitempty"`   // spack packages
	Pip    []string `yaml:"pip,omitempty" json:"pip,omitempty"`       // pip packages (when conda used)

	// Additional captures all other package groups (e.g., r_dependencies, latex, databases)
	// This allows templates to organize packages into logical groups
	Additional map[string][]string `yaml:",inline" json:"-"`
}

type PackageDiff struct {
	Name           string `json:"name"`
	CurrentVersion string `json:"current_version,omitempty"`
	TargetVersion  string `json:"target_version"`
	Action         string `json:"action"` // "install", "upgrade", "remove"
	PackageManager string `json:"package_manager"`
}

type PackageManagerRule struct{}

type PackageManagerRules struct {
	// If template has HPC/scientific computing packages -> spack
	HPCIndicators []string

	// If template has Python data science packages -> conda
	PythonDataScienceIndicators []string

	// If template has R packages -> conda (better R ecosystem)
	RIndicators []string

	// Default fallback -> apt (system packages)
	DefaultManager PackageManagerType
}

type PackageManagerStrategy struct {
	Template *Template

	// Selection rules for "auto" mode
	Rules PackageManagerRules
}

type PackageManagerType string

type PackageManagerValidator struct{}

type PackageSecurityScanner interface {
	ScanPackages(ctx context.Context, packages PackageDefinitions) (*PackageAnalysis, error)
}

type ParameterHelper struct{}

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

type ParameterRule struct{}

type PatternMatch struct {
	Pattern     string `json:"pattern"`
	Location    string `json:"location"`
	Match       string `json:"match"`
	Risk        string `json:"risk"` // high, medium, low
	Description string `json:"description"`
}

type PerformanceRule struct{}

type PluginAlternative struct {
	Plugin string `yaml:"plugin" json:"plugin"`
	Reason string `yaml:"reason" json:"reason"`
}

type PluginCapability struct {
	Name string `yaml:"name" json:"name"`
	Type string `yaml:"type" json:"type"` // capability, feature, service
}

type PluginCompatibility struct {
	Tools map[string]ToolVersionConstraint `yaml:"tools,omitempty" json:"tools,omitempty"`
}

type PluginConfigFile struct {
	File    string `yaml:"file" json:"file"`
	Path    string `yaml:"path" json:"path"`
	Content string `yaml:"content" json:"content"`
}

type PluginConfiguration struct {
	Parameters map[string]TemplateParameter `yaml:"parameters,omitempty" json:"parameters,omitempty"`
}

type PluginConflict struct {
	Plugin string `yaml:"plugin" json:"plugin"`
	Reason string `yaml:"reason" json:"reason"`
}

type PluginDependencies struct {
	Required []PluginDependency `yaml:"required,omitempty" json:"required,omitempty"`
	Optional []PluginDependency `yaml:"optional,omitempty" json:"optional,omitempty"`
}

type PluginDependency struct {
	Plugin  string `yaml:"plugin" json:"plugin"`
	Version string `yaml:"version" json:"version"` // Semantic version constraint (e.g., ">=2.0.0")
}

type PluginInstallSpec struct {
	PackageManager string             `yaml:"package_manager" json:"package_manager"`
	Packages       []PluginPackage    `yaml:"packages" json:"packages"`
	Config         []PluginConfigFile `yaml:"config,omitempty" json:"config,omitempty"`
	PostInstall    string             `yaml:"post_install,omitempty" json:"post_install,omitempty"`
}

type PluginInstaller interface {
	// Name returns the installer name (e.g., "r", "vscode", "vim")
	Name() string

	// Install installs a plugin with specified version and configuration
	Install(ctx context.Context, plugin *PluginManifest, version string, params map[string]interface{}) error

	// Uninstall removes a plugin
	Uninstall(ctx context.Context, plugin *PluginManifest) error

	// Validate checks if plugin can be installed (prerequisites met)
	Validate(ctx context.Context, plugin *PluginManifest) error

	// GetInstalledVersion returns the installed version (empty string if not installed)
	GetInstalledVersion(ctx context.Context, plugin *PluginManifest) (string, error)

	// IsCompatible checks if plugin is compatible with the current environment
	IsCompatible(ctx context.Context, plugin *PluginManifest) (bool, error)
}

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

type PluginManifest struct {
	APIVersion string         `yaml:"apiVersion" json:"apiVersion"`
	Kind       string         `yaml:"kind" json:"kind"`
	Metadata   PluginMetadata `yaml:"metadata" json:"metadata"`
	Spec       PluginSpec     `yaml:"spec" json:"spec"`
}

type PluginMetadata struct {
	Name        string `yaml:"name" json:"name"`
	DisplayName string `yaml:"display_name" json:"display_name"`
	Description string `yaml:"description" json:"description"`
	Category    string `yaml:"category" json:"category"` // development, infrastructure, data, etc.
	Version     string `yaml:"version" json:"version"`
	Maintainer  string `yaml:"maintainer" json:"maintainer"`
}

type PluginPackage struct {
	Name           string `yaml:"name" json:"name"`
	VersionParam   string `yaml:"version_param,omitempty" json:"version_param,omitempty"`
	InstallCommand string `yaml:"install_command" json:"install_command"`
}

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

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

type PluginSecurityMetadata struct {
	Trusted           bool      `yaml:"trusted" json:"trusted"`
	VerifiedPublisher bool      `yaml:"verified_publisher" json:"verified_publisher"`
	CVEScanned        bool      `yaml:"cve_scanned" json:"cve_scanned"`
	LastSecurityScan  time.Time `yaml:"last_security_scan" json:"last_security_scan"`
}

type PluginSpec struct {
	Provides      []PluginCapability           `yaml:"provides,omitempty" json:"provides,omitempty"`
	Dependencies  PluginDependencies           `yaml:"dependencies,omitempty" json:"dependencies,omitempty"`
	Conflicts     []PluginConflict             `yaml:"conflicts,omitempty" json:"conflicts,omitempty"`
	Alternatives  []PluginAlternative          `yaml:"alternatives,omitempty" json:"alternatives,omitempty"`
	Installers    map[string]PluginInstallSpec `yaml:"installers" json:"installers"`
	Configuration PluginConfiguration          `yaml:"configuration,omitempty" json:"configuration,omitempty"`
	Compatibility PluginCompatibility          `yaml:"compatibility,omitempty" json:"compatibility,omitempty"`
	Security      PluginSecurityMetadata       `yaml:"security,omitempty" json:"security,omitempty"`
}

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

type PortValidator struct{}

type PrivilegeEscalation struct {
	Type        string `json:"type"`
	Description string `json:"description"`
	Severity    string `json:"severity"`
	Vector      string `json:"vector"`
}

type QualityCheck struct {
	Name       string         `json:"name"`
	Status     string         `json:"status"` // passed, failed, warning
	Score      float64        `json:"score"`  // 0-100
	Message    string         `json:"message"`
	Details    map[string]any `json:"details,omitempty"`
	Impact     string         `json:"impact"` // critical, high, medium, low
	ExecutedAt time.Time      `json:"executed_at"`
}

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

type Recommendation struct {
	Type        string `json:"type"`     // security, quality, performance, maintenance
	Priority    string `json:"priority"` // critical, high, medium, low
	Title       string `json:"title"`
	Description string `json:"description"`
	Action      string `json:"action"`
	Effort      string `json:"effort"` // low, medium, high
}

type RegistryCredentials struct {
	Type     string `json:"type"` // token, basic, ssh_key
	Token    string `json:"token,omitempty"`
	Username string `json:"username,omitempty"`
	Password string `json:"password,omitempty"`
	SSHKey   string `json:"ssh_key,omitempty"`
}

type RegistryType string

type RemoteExecutor interface {
	Execute(ctx context.Context, instanceName string, command string) (*ExecutionResult, error)
	ExecuteScript(ctx context.Context, instanceName string, script string) (*ExecutionResult, error)
	CopyFile(ctx context.Context, instanceName string, localPath, remotePath string) error
	GetFile(ctx context.Context, instanceName string, remotePath, localPath string) error
}

type RepositoryInfo struct {
	Owner       string
	Name        string
	Description string
	Stars       int
	LastUpdated time.Time
}

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

type RequiredFieldsRule struct{}

type ResolvedDependencies struct {
	BaseOS           string // Resolved base OS (e.g., "ubuntu")
	Version          string // Resolved version (e.g., "24.04")
	ResolvedAMI      string // Resolved AMI ID
	VersionSource    string // How version was determined (user_override, template_requirement, default)
	SatisfiesRequest bool   // Whether resolution satisfied user's request
}

type RollbackCheckpoint struct {
	ID              string             `json:"id"`
	CreatedAt       time.Time          `json:"created_at"`
	InstanceName    string             `json:"instance_name"`
	Description     string             `json:"description"`
	PackageSnapshot []InstalledPackage `json:"package_snapshot"`
	ServiceSnapshot []RunningService   `json:"service_snapshot"`
	UserSnapshot    []ExistingUser     `json:"user_snapshot"`
	FilesBackedUp   []BackupFile       `json:"files_backed_up"`
	EnvironmentVars map[string]string  `json:"environment_vars"`
}

type RunningService struct {
	Name    string `json:"name"`
	Status  string `json:"status"` // "running", "stopped", "error"
	Port    int    `json:"port"`
	Enabled bool   `json:"enabled"`
	Source  string `json:"source"` // "template" or "manual"
}

type RuntimeTemplate = types.RuntimeTemplate

type S3ClientInterface interface {
	PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error)
	GetObject(ctx context.Context, params *s3.GetObjectInput, optFns ...func(*s3.Options)) (*s3.GetObjectOutput, error)
	DeleteObject(ctx context.Context, params *s3.DeleteObjectInput, optFns ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)
}

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

type SSMClientInterface interface {
	SendCommand(ctx context.Context, params *ssm.SendCommandInput, optFns ...func(*ssm.Options)) (*ssm.SendCommandOutput, error)
	GetCommandInvocation(ctx context.Context, params *ssm.GetCommandInvocationInput, optFns ...func(*ssm.Options)) (*ssm.GetCommandInvocationOutput, error)
}

type ScriptData struct {
	Template           *Template
	PackageManager     string
	Packages           []string
	Users              []UserData
	Services           []ServiceConfig
	WebInterfaceBindIP string // Dynamic IP binding for web interfaces (0.0.0.0 or 127.0.0.1)
	PluginScript       string // Plugin installation script (optional, Phase 2A+)
}

type ScriptGenerator struct {
	// Script templates for each package manager
	AptTemplate   string
	DnfTemplate   string
	CondaTemplate string
	SpackTemplate string
	AMITemplate   string
	PipTemplate   string

	// Plugin support (Phase 2A+)
	PluginScriptGenerator *PluginScriptGenerator
	PluginRegistry        *PluginRegistry
}

type SearchFilter struct {
	// Text search
	Query    string   `json:"query,omitempty"`
	Keywords []string `json:"keywords,omitempty"`

	// Classification filters
	Categories []string             `json:"categories,omitempty"`
	Domains    []string             `json:"domains,omitempty"`
	Complexity []TemplateComplexity `json:"complexity,omitempty"`

	// Quality filters
	MinRating     float64 `json:"min_rating,omitempty"`
	VerifiedOnly  bool    `json:"verified_only,omitempty"`
	ValidatedOnly bool    `json:"validated_only,omitempty"`

	// Registry filters
	Registries    []string       `json:"registries,omitempty"`
	RegistryTypes []RegistryType `json:"registry_types,omitempty"`

	// Feature filters
	ResearchUserSupport bool     `json:"research_user_support,omitempty"`
	ConnectionTypes     []string `json:"connection_types,omitempty"`
	PackageManagers     []string `json:"package_managers,omitempty"`

	// Sorting and pagination
	SortBy    string `json:"sort_by,omitempty"`    // popularity, rating, updated, name
	SortOrder string `json:"sort_order,omitempty"` // asc, desc
	Limit     int    `json:"limit,omitempty"`
	Offset    int    `json:"offset,omitempty"`
}

type SearchOptions struct {
	Query         string   // Text search query
	Category      string   // Filter by category
	Domain        string   // Filter by domain
	Complexity    string   // Filter by complexity
	Tags          []string // Filter by tags
	Popular       *bool    // Filter by popular status
	Featured      *bool    // Filter by featured status
	HasGPU        *bool    // Filter by GPU support
	MaxLaunchTime int      // Maximum launch time in minutes
}

type SearchResult struct {
	Template *Template
	Score    float64  // Relevance score for ranking
	Matches  []string // What matched in the search
}

type SecretFinding struct {
	Type     string  `json:"type"`     // api_key, password, private_key, etc.
	Location string  `json:"location"` // field or section where found
	Severity string  `json:"severity"` // critical, high, medium
	Masked   string  `json:"masked"`   // partially masked secret for identification
	Entropy  float64 `json:"entropy"`  // randomness score
}

type SecretsScanner interface {
	ScanForSecrets(ctx context.Context, content string) ([]SecretFinding, error)
}

type SecurityFinding struct {
	Severity    string `yaml:"severity" json:"severity"` // critical, high, medium, low, info
	Category    string `yaml:"category" json:"category"` // vulnerability, misconfiguration, secret, etc.
	Description string `yaml:"description" json:"description"`
	Remediation string `yaml:"remediation,omitempty" json:"remediation,omitempty"`
	CVEID       string `yaml:"cve_id,omitempty" json:"cve_id,omitempty"`
}

type SecurityIssue struct {
	Severity    string // critical, high, medium, low
	Category    string
	Description string
	Location    string
	Remediation string
}

type SecurityMisconfiguration struct {
	Type        string `json:"type"`
	Description string `json:"description"`
	Severity    string `json:"severity"`
	Remediation string `json:"remediation"`
}

type SecurityRule struct{}

type SecurityScanResult struct {
	TemplateName string
	Passed       bool
	Issues       []SecurityIssue
	Warnings     []SecurityWarning
	Score        int // 0-100, higher is better
}

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

type SecurityWarning struct {
	Category    string
	Description string
	Location    string
	Suggestion  string
}

type ServiceConfig struct {
	Name   string   `yaml:"name" json:"name"`
	Port   int      `yaml:"port,omitempty" json:"port,omitempty"`
	Config []string `yaml:"config,omitempty" json:"config,omitempty"` // Config file lines
	Enable bool     `yaml:"enable,omitempty" json:"enable,omitempty"` // Default: true
}

type ServiceDiff struct {
	Name          string `json:"name"`
	CurrentStatus string `json:"current_status,omitempty"`
	TargetStatus  string `json:"target_status"`
	Action        string `json:"action"` // "configure", "start", "stop", "restart"
	Port          int    `json:"port"`
}

type ServicePortRule struct{}

type ServiceValidator struct{}

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

type StateManager interface {
	LoadState() (*types.State, error)
}

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

type Template struct {
	// Basic metadata
	Name            string `yaml:"name" json:"name"`
	Slug            string `yaml:"slug,omitempty" json:"slug,omitempty"` // Short dash-separated name for CLI
	Description     string `yaml:"description" json:"description"`
	LongDescription string `yaml:"long_description,omitempty" json:"long_description,omitempty"` // Detailed description for GUI
	Base            string `yaml:"base" json:"base"`                                             // Base OS (ubuntu-22.04, etc.) or parent template

	// Template inheritance
	Inherits []string `yaml:"inherits,omitempty" json:"inherits,omitempty"` // Parent templates to inherit from

	// Complexity and categorization
	Complexity TemplateComplexity `yaml:"complexity,omitempty" json:"complexity,omitempty"` // simple, moderate, advanced, complex
	Category   string             `yaml:"category,omitempty" json:"category,omitempty"`     // "Machine Learning", "Data Science", etc.
	Domain     string             `yaml:"domain,omitempty" json:"domain,omitempty"`         // "ml", "datascience", "bio", "web", "base"

	// Visual presentation
	Icon     string `yaml:"icon,omitempty" json:"icon,omitempty"`         // Unicode emoji or icon identifier
	Color    string `yaml:"color,omitempty" json:"color,omitempty"`       // Hex color for category theming
	Popular  bool   `yaml:"popular,omitempty" json:"popular,omitempty"`   // Popular badge display
	Featured bool   `yaml:"featured,omitempty" json:"featured,omitempty"` // Featured template (always visible)

	// Connection configuration
	ConnectionType ConnectionType `yaml:"connection_type,omitempty" json:"connection_type,omitempty"` // Explicit connection type (ssh, web, desktop, both)
	Desktop        *DesktopConfig `yaml:"desktop,omitempty" json:"desktop,omitempty"`                 // Desktop configuration (only for connection_type: desktop)

	// Package management strategy
	PackageManager string             `yaml:"package_manager,omitempty" json:"package_manager,omitempty"` // "auto", "apt", "dnf", "conda", "spack", "ami"
	Packages       PackageDefinitions `yaml:"packages,omitempty" json:"packages,omitempty"`

	// AMI configuration (for pre-built images)
	AMIConfig AMIConfig `yaml:"ami_config,omitempty" json:"ami_config,omitempty"`

	// Service configuration
	Services []ServiceConfig `yaml:"services,omitempty" json:"services,omitempty"`

	// User setup
	Users []UserConfig `yaml:"users,omitempty" json:"users,omitempty"`

	// Post-install script
	PostInstall string `yaml:"post_install,omitempty" json:"post_install,omitempty"`

	// File provisioning (S3-backed transfers) (v0.5.7)
	Files []FileConfig `yaml:"files,omitempty" json:"files,omitempty"`

	// User data script for instance initialization
	UserData string `yaml:"user_data,omitempty" json:"user_data,omitempty"`

	// Idle detection configuration
	IdleDetection *IdleDetectionConfig `yaml:"idle_detection,omitempty" json:"idle_detection,omitempty"`

	// Instance defaults
	InstanceDefaults InstanceDefaults `yaml:"instance_defaults,omitempty" json:"instance_defaults,omitempty"`

	// User guidance
	EstimatedLaunchTime int      `yaml:"estimated_launch_time,omitempty" json:"estimated_launch_time,omitempty"` // Launch time in minutes
	Prerequisites       []string `yaml:"prerequisites,omitempty" json:"prerequisites,omitempty"`                 // Required knowledge/skills
	LearningResources   []string `yaml:"learning_resources,omitempty" json:"learning_resources,omitempty"`       // Documentation links

	// Template parameterization
	Parameters map[string]TemplateParameter `yaml:"parameters,omitempty" json:"parameters,omitempty"` // User-configurable parameters
	Variables  map[string]string            `yaml:"variables,omitempty" json:"variables,omitempty"`   // Template-level variables

	// Research user integration (Phase 5A+)
	ResearchUser *research.ResearchUserTemplate `yaml:"research_user,omitempty" json:"research_user,omitempty"`

	// Universal plugin support (Phase 2A+)
	Plugins TemplatePlugins `yaml:"plugins,omitempty" json:"plugins,omitempty"`

	// Template metadata
	Version          string            `yaml:"version,omitempty" json:"version,omitempty"`
	ValidationStatus ValidationStatus  `yaml:"validation_status,omitempty" json:"validation_status,omitempty"` // validated, testing, experimental
	Tags             map[string]string `yaml:"tags,omitempty" json:"tags,omitempty"`
	Maintainer       string            `yaml:"maintainer,omitempty" json:"maintainer,omitempty"`
	LastUpdated      time.Time         `yaml:"last_updated,omitempty" json:"last_updated,omitempty"`

	// Marketplace integration (Phase 5B+)
	Marketplace *MarketplaceConfig `yaml:"marketplace,omitempty" json:"marketplace,omitempty"`
}

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

type TemplateApplicationRecord struct {
	InstanceName       string    `json:"instance_name"`
	TemplateName       string    `json:"template_name"`
	TemplateVersion    string    `json:"template_version"`
	AppliedAt          time.Time `json:"applied_at"`
	Checkpoint         string    `json:"checkpoint"`
	PackagesInstalled  int       `json:"packages_installed"`
	ServicesConfigured int       `json:"services_configured"`
	UsersCreated       int       `json:"users_created"`
	Warnings           []string  `json:"warnings,omitempty"`
}

type TemplateComplexity = types.TemplateComplexity

type TemplateConfig struct {
	// Template directories to scan
	TemplateDirs []string `json:"template_dirs"`

	// Default package manager preference
	DefaultPackageManager string `json:"default_package_manager"`

	// Cache settings
	CacheEnabled    bool `json:"cache_enabled"`
	CacheTTLMinutes int  `json:"cache_ttl_minutes"`

	// Package manager paths
	PackageManagerPaths map[string]string `json:"package_manager_paths"`
}

type TemplateDependency struct {
	Name    string `yaml:"name" json:"name"`                           // Template name or slug
	Version string `yaml:"version,omitempty" json:"version,omitempty"` // Version requirement (semver)
	Source  string `yaml:"source,omitempty" json:"source,omitempty"`   // Registry or source location
	Type    string `yaml:"type,omitempty" json:"type,omitempty"`       // inherits, runtime, build
}

type TemplateDiff struct {
	PackagesToInstall   []PackageDiff  `json:"packages_to_install"`
	PackagesToRemove    []PackageDiff  `json:"packages_to_remove"`
	ServicesToConfigure []ServiceDiff  `json:"services_to_configure"`
	ServicesToStop      []ServiceDiff  `json:"services_to_stop"`
	UsersToCreate       []UserDiff     `json:"users_to_create"`
	UsersToModify       []UserDiff     `json:"users_to_modify"`
	PortsToOpen         []int          `json:"ports_to_open"`
	ConflictsFound      []ConflictDiff `json:"conflicts_found"`
}

type TemplateDiffCalculator struct{}

type TemplateParameter struct {
	// Basic parameter information
	Name        string `yaml:"name" json:"name"`
	Description string `yaml:"description" json:"description"`
	Type        string `yaml:"type" json:"type"` // string, int, bool, choice

	// Value constraints
	Default  interface{}   `yaml:"default,omitempty" json:"default,omitempty"`
	Choices  []interface{} `yaml:"choices,omitempty" json:"choices,omitempty"`   // For choice type
	Min      interface{}   `yaml:"min,omitempty" json:"min,omitempty"`           // For int type
	Max      interface{}   `yaml:"max,omitempty" json:"max,omitempty"`           // For int type
	Pattern  string        `yaml:"pattern,omitempty" json:"pattern,omitempty"`   // For string type (regex)
	Required bool          `yaml:"required,omitempty" json:"required,omitempty"` // Parameter is required

	// UI presentation
	DisplayName string `yaml:"display_name,omitempty" json:"display_name,omitempty"` // Human-readable name
	Group       string `yaml:"group,omitempty" json:"group,omitempty"`               // Parameter group for UI organization
	Order       int    `yaml:"order,omitempty" json:"order,omitempty"`               // Display order within group
	Hidden      bool   `yaml:"hidden,omitempty" json:"hidden,omitempty"`             // Hide from UI (internal use)

	// Advanced features
	Conditional string `yaml:"conditional,omitempty" json:"conditional,omitempty"` // Show only if condition is met
	Impact      string `yaml:"impact,omitempty" json:"impact,omitempty"`           // cost, performance, security
}

type TemplateParameterType string

type TemplateParameterValues map[string]interface{}

type TemplateParser struct {
	// Base AMI mappings for validation (hierarchical structure for version support)
	// Structure: distro -> version -> region -> arch -> AMI
	BaseAMIs map[string]map[string]map[string]map[string]string

	// Package manager strategy
	Strategy *PackageManagerStrategy
}

type TemplatePlugins struct {
	Enabled []EnabledPlugin `yaml:"enabled,omitempty" json:"enabled,omitempty"`
}

type TemplateRegistry struct {
	// Template directories to scan
	TemplateDirs []string

	// Cached templates (indexed by name)
	Templates map[string]*Template

	// Slug index for fast lookup (slug -> template name)
	SlugIndex map[string]string

	// Last scan time
	LastScan time.Time
}

type TemplateResolver struct {
	Parser       *TemplateParser
	ScriptGen    *ScriptGenerator
	AMIRegistry  map[string]map[string]map[string]string // template -> region -> arch -> AMI
	AMIDiscovery AMIDiscoveryService                     // Optional: Dynamic AMI lookup via SSM
}

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

type TemplateTest struct {
	Name        string
	Description string
	Template    string
	TestFunc    TestFunction
}

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

type TemplateUsage struct {
	TemplateName      string    `json:"template_name"`
	LaunchCount       int       `json:"launch_count"`
	LastUsed          time.Time `json:"last_used"`
	TotalLaunchTime   int       `json:"total_launch_time_seconds"`
	AverageLaunchTime int       `json:"average_launch_time_seconds"`
	SuccessRate       float64   `json:"success_rate"`
	SuccessCount      int       `json:"success_count"`
	FailureCount      int       `json:"failure_count"`
}

type TemplateValidationError struct {
	Field   string
	Message string
}

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

type TemplateValidator interface {
	Validate(template *Template) error
}

type TestFunction func(ctx context.Context, template *Template) TestResult

type TestReport struct {
	SuiteName   string
	StartTime   time.Time
	EndTime     time.Time
	TotalTests  int
	PassedTests int
	FailedTests int
	TestResults map[string]TestResult
}

type TestResult struct {
	Passed   bool
	Duration time.Duration
	Message  string
	Details  []string
}

type TestSuite struct {
	Name        string
	Description string
	Tests       []TemplateTest
}

type ToolVersionConstraint struct {
	MinVersion string `yaml:"min_version,omitempty" json:"min_version,omitempty"`
	MaxVersion string `yaml:"max_version,omitempty" json:"max_version,omitempty"`
}

type TrustConfig struct {
	DefaultTrustLevel string
	AutoVerify        bool
}

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

type UsageStatistics struct {
	TotalLaunches      int       `json:"total_launches"`
	SuccessfulLaunches int       `json:"successful_launches"`
	FailedLaunches     int       `json:"failed_launches"`
	AverageLaunchTime  int       `json:"average_launch_time"` // seconds
	LastUsed           time.Time `json:"last_used,omitempty"`
	PopularityScore    float64   `json:"popularity_score"` // Derived from usage
}

type UsageStats struct {
	Stats map[string]*TemplateUsage `json:"stats"`
	// contains filtered or unexported fields
}

type UserConfig struct {
	Name   string   `yaml:"name" json:"name"`
	Groups []string `yaml:"groups,omitempty" json:"groups,omitempty"`
	Shell  string   `yaml:"shell,omitempty" json:"shell,omitempty"` // Default: /bin/bash
}