bundle

type AESGCMHandler struct{}

type AddOperation struct {
	Path string `json:"path"`
	Type string `json:"type"`
	Size int64  `json:"size"`
	Hash string `json:"hash"`
	Mode uint32 `json:"mode,omitempty"`
}

type AuthInfo struct {
	Username string `json:"username"`
	Password string `json:"password"`
	Token    string `json:"token"`
	KeyFile  string `json:"keyFile"`
}

type Author struct {
	Name  string `json:"name"`
	Email string `json:"email"`
	URL   string `json:"url,omitempty"`
	KeyID string `json:"key_id,omitempty"`
}

type Backup struct {
	Version   string                `json:"version"`
	Timestamp time.Time             `json:"timestamp"`
	Files     map[string]FileBackup `json:"files"`
}

type BackupManager interface {
	// CreateBackup creates a backup of the specified directory
	CreateBackup(ctx context.Context, sourceDir, backupDir, description string, tags []string) (string, error)
	// CreateBundleBackup creates a backup before importing a bundle
	CreateBundleBackup(ctx context.Context, sourceDir, backupDir string, bundle *Bundle) (string, error)
	// RestoreBackup restores a backup to the specified directory
	RestoreBackup(ctx context.Context, backupPath, targetDir string) error
	// ListBackups lists all backups in the specified directory
	ListBackups(ctx context.Context, backupDir string) ([]BackupMetadata, error)
	// GetBackupMetadata gets the metadata for a backup
	GetBackupMetadata(ctx context.Context, backupPath string) (*BackupMetadata, error)
	// DeleteBackup deletes a backup
	DeleteBackup(ctx context.Context, backupPath string) error
	// PruneBackups deletes old backups, keeping the specified number of most recent backups
	PruneBackups(ctx context.Context, backupDir string, keepCount int) (int, error)
}

type BackupMetadata struct {
	// ID is the unique identifier for the backup
	ID string `json:"id"`
	// CreatedAt is the time the backup was created
	CreatedAt time.Time `json:"created_at"`
	// Description is a human-readable description of the backup
	Description string `json:"description"`
	// BundleID is the ID of the bundle that was being imported when the backup was created
	BundleID string `json:"bundle_id,omitempty"`
	// BundleName is the name of the bundle that was being imported when the backup was created
	BundleName string `json:"bundle_name,omitempty"`
	// BundleVersion is the version of the bundle that was being imported when the backup was created
	BundleVersion string `json:"bundle_version,omitempty"`
	// ContentPaths contains the paths of the content items in the backup
	ContentPaths []string `json:"content_paths,omitempty"`
	// Tags contains tags for the backup
	Tags []string `json:"tags,omitempty"`
	// AutoGenerated indicates whether the backup was automatically generated
	AutoGenerated bool `json:"auto_generated"`
}

type BehaviorOptions struct {
	ContinueOnError   bool // Continue export on non-fatal errors
	ValidateContent   bool // Validate content before export
	GenerateChecksums bool // Generate checksums for all files
	CreateBackup      bool // Create backup before export
	DryRun            bool // Perform dry run only
	Verbose           bool // Verbose output
	ParallelExport    bool // Use parallel processing
	MaxParallelJobs   int  // Maximum parallel jobs
}

type BreakingChange struct {
	Version        string `json:"version"`
	Description    string `json:"description"`
	MigrationGuide string `json:"migrationGuide"`
}

type Bundle struct {
	Manifest   BundleManifest
	BundlePath string
	IsVerified bool
}

type BundleChecksums struct {
	Algorithm string            `json:"algorithm"`
	Manifest  string            `json:"manifest,omitempty"`
	Content   map[string]string `json:"content"`
}

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

type BundleConverter struct {
	// Creator is the offline bundle creator
	Creator *OfflineBundleCreator
	// Logger is the logger for conversion operations
	Logger io.Writer
	// AuditTrail is the audit trail manager for logging operations
	AuditTrail *trail.AuditTrailManager
}

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

type BundleImporter interface {
	// Import imports a bundle with the specified options
	Import(context.Context, string, ImportOptions) (*ImportResult, error)
	// ValidateBeforeImport validates a bundle before importing
	ValidateBeforeImport(context.Context, string, ValidationLevel) (*ValidationResult, error)
	// CreateBackup creates a backup of the target directory
	CreateBackup(context.Context, string, string) (string, error)
	// RestoreBackup restores a backup
	RestoreBackup(context.Context, string, string) error
}

type BundleManifest struct {
	SchemaVersion   string                 `json:"schema_version"`
	ManifestVersion string                 `json:"manifest_version,omitempty"`
	BundleID        string                 `json:"bundle_id"`
	BundleType      BundleType             `json:"bundle_type"`
	Name            string                 `json:"name"`
	Description     string                 `json:"description"`
	Version         string                 `json:"version"`
	BundleVersion   string                 `json:"bundle_version,omitempty"`
	CreatedAt       time.Time              `json:"created_at"`
	Author          Author                 `json:"author"`
	Content         []ContentItem          `json:"content"`
	Checksums       Checksums              `json:"checksums"`
	Compatibility   Compatibility          `json:"compatibility"`
	Signature       string                 `json:"signature,omitempty"`
	Dependencies    map[string][]string    `json:"dependencies,omitempty"`
	Metadata        map[string]interface{} `json:"metadata,omitempty"`
}

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

type BundleSignature struct {
	Version     string            `json:"version"`
	Algorithm   string            `json:"algorithm"`
	KeyID       string            `json:"keyId"`
	Timestamp   time.Time         `json:"timestamp"`
	ContentHash string            `json:"contentHash"`
	Signature   string            `json:"signature"`
	Metadata    SignatureMetadata `json:"metadata"`
}

type BundleStructure struct {
	// RootDirectories defines the directories that should exist in the bundle root
	RootDirectories map[string]DirectorySpec
	// FileNamingRules defines the rules for naming files in the bundle
	FileNamingRules map[string][]string
	// TemplateCategories defines the standard categories for organizing templates
	TemplateCategories []string
	// ModuleTypes defines the standard types for organizing modules
	ModuleTypes []string
}

type BundleStructureValidator struct {
	// Structure is the bundle structure specification
	Structure *BundleStructure
}

type BundleType string

type BundleValidator interface {
	// Validate validates a bundle with the specified validation level
	Validate(bundle *Bundle, level ValidationLevel) (*ValidationResult, error)
	// ValidateManifest validates a bundle manifest
	ValidateManifest(manifest *BundleManifest) (*ValidationResult, error)
	// ValidateSignature validates a bundle signature
	ValidateSignature(bundle *Bundle, publicKey ed25519.PublicKey) (*ValidationResult, error)
	// ValidateChecksums validates bundle checksums
	ValidateChecksums(bundle *Bundle) (*ValidationResult, error)
	// ValidateCompatibility validates bundle compatibility with current versions
	ValidateCompatibility(bundle *Bundle, currentVersions map[string]*version.SemVersion) (*ValidationResult, error)
}

type ChaCha20Handler struct{}

type ChangelogEntry struct {
	// Version is the version associated with this changelog entry
	Version string `json:"version"`
	// Date is when the version was released
	Date time.Time `json:"date"`
	// Changes is a list of changes in this version
	Changes []string `json:"changes"`
}

type Checksums struct {
	Manifest string            `json:"manifest"`
	Content  map[string]string `json:"content"`
}

type ComparisonSummary struct {
	TotalChanges  int `json:"totalChanges"`
	AddedCount    int `json:"addedCount"`
	RemovedCount  int `json:"removedCount"`
	ModifiedCount int `json:"modifiedCount"`
}

type Compatibility struct {
	MinVersion   string   `json:"min_version"`
	MaxVersion   string   `json:"max_version,omitempty"`
	Dependencies []string `json:"dependencies,omitempty"`
	Incompatible []string `json:"incompatible,omitempty"`
}

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

type CompatibilityConfig struct {
	EnforceStrict         bool                   `json:"enforceStrict"`
	AllowDowngrade        bool                   `json:"allowDowngrade"`
	AllowPrerelease       bool                   `json:"allowPrerelease"`
	CheckVersion          bool                   `json:"checkVersion"`
	CheckComponents       bool                   `json:"checkComponents"`
	CheckEnvironment      bool                   `json:"checkEnvironment"`
	UpgradePaths          []UpgradePath          `json:"upgradePaths"`
	ComponentRequirements map[string]Requirement `json:"componentRequirements"`
	EnvironmentReqs       EnvironmentRequirement `json:"environmentRequirements"`
}

type CompatibilityIssue struct {
	Type        string `json:"type"`
	Severity    string `json:"severity"` // error, warning, info
	Message     string `json:"message"`
	Component   string `json:"component,omitempty"`
	Action      string `json:"action,omitempty"`
	CanOverride bool   `json:"canOverride"`
}

type CompatibilityResult struct {
	Compatible bool                   `json:"compatible"`
	Issues     []CompatibilityIssue   `json:"issues"`
	Warnings   []string               `json:"warnings"`
	Metadata   map[string]interface{} `json:"metadata"`
}

type ComplianceMapping struct {
	// ContentID is the ID of the content item
	ContentID string `json:"content_id"`
	// OwaspLLMCategories lists the OWASP LLM Top 10 categories this item addresses
	OwaspLLMCategories []string `json:"owasp_llm_categories,omitempty"`
	// ISOIECControls lists the ISO/IEC 42001 controls this item addresses
	ISOIECControls []string `json:"iso_iec_controls,omitempty"`
	// Description provides additional context about the compliance mapping
	Description string `json:"description,omitempty"`
}

type CompressOptions struct {
	Format      ExportFormat
	Compression CompressionType
	Encryption  *EncryptionOptions
	Level       int // Compression level
}

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

type CompressionHandler interface {
	Compress(src io.Reader, dst io.Writer) error
	Decompress(src io.Reader, dst io.Writer) error
	GetExtension() string
}

type CompressionType string

type Conflict struct {
	// Type is the type of conflict
	Type ConflictType
	// Path is the path of the conflicting item
	Path string
	// SourcePath is the path of the source item
	SourcePath string
	// TargetPath is the path of the target item
	TargetPath string
	// ContentItem is the content item from the bundle manifest
	ContentItem *ContentItem
	// Message is a human-readable message about the conflict
	Message string
	// ResolutionStrategy is the strategy for resolving the conflict
	ResolutionStrategy ConflictResolutionStrategy
	// ResolutionPath is the path where the item was resolved (if applicable)
	ResolutionPath string
	// Resolved indicates whether the conflict has been resolved
	Resolved bool
}

type ConflictDetector interface {
	// DetectConflicts detects conflicts between the bundle and the target directory
	DetectConflicts(ctx context.Context, bundle *Bundle, targetDir string) ([]*Conflict, error)
	// DetectContentConflicts detects content conflicts between the bundle and the target directory
	DetectContentConflicts(ctx context.Context, bundle *Bundle, targetDir string) ([]*Conflict, error)
	// DetectVersionConflicts detects version conflicts between the bundle and the target directory
	DetectVersionConflicts(ctx context.Context, bundle *Bundle, targetDir string) ([]*Conflict, error)
}

type ConflictResolution struct {
	// Conflict is the conflict being resolved
	Conflict *Conflict
	// Strategy is the strategy used to resolve the conflict
	Strategy ConflictResolutionStrategy
	// Path is the path where the item was resolved (if applicable)
	Path string
	// Success indicates whether the resolution was successful
	Success bool
	// Error is the error that occurred during resolution (if any)
	Error error
}

type ConflictResolutionStrategy string

type ConflictResolver interface {
	// ResolveConflict resolves a single conflict
	ResolveConflict(ctx context.Context, conflict *Conflict) (*ConflictResolution, error)
	// ResolveConflicts resolves multiple conflicts
	ResolveConflicts(ctx context.Context, conflicts []*Conflict) ([]*ConflictResolution, error)
	// GetDefaultStrategy gets the default resolution strategy for a conflict type
	GetDefaultStrategy(conflictType ConflictType) ConflictResolutionStrategy
	// SetDefaultStrategy sets the default resolution strategy for a conflict type
	SetDefaultStrategy(conflictType ConflictType, strategy ConflictResolutionStrategy)
}

type ConflictType string

type ContentChange struct {
	Path        string      `json:"path"`
	Type        ContentType `json:"type"`
	Size        int64       `json:"size,omitempty"`
	OldChecksum string      `json:"oldChecksum,omitempty"`
	NewChecksum string      `json:"newChecksum,omitempty"`
	SizeDelta   int64       `json:"sizeDelta,omitempty"`
}

type ContentItem struct {
	Path        string      `json:"path"`
	Type        ContentType `json:"type"`
	ID          string      `json:"id,omitempty"`
	Version     string      `json:"version,omitempty"`
	Description string      `json:"description,omitempty"`
	Checksum    string      `json:"checksum"`
	// BundleID is the ID of the bundle this item belongs to
	BundleID string `json:"bundle_id,omitempty"`
	// Metadata stores additional metadata for the item
	Metadata map[string]interface{} `json:"metadata,omitempty"`
	// Size is the file size in bytes
	Size int64 `json:"size,omitempty"`
}

type ContentManifest struct {
	Files []FileHash `json:"files"`
}

type ContentSanitizer interface {
	Sanitize(path string, content []byte) ([]byte, error)
	ShouldSanitize(path string) bool
}

type ContentTransformer interface {
	Transform(path string, content []byte) ([]byte, error)
	ShouldTransform(path string) bool
}

type ContentType string

type CreateRequest struct {
	Name        string   `json:"name"`
	Description string   `json:"description,omitempty"`
	Templates   []string `json:"templates,omitempty"`
	Categories  []string `json:"categories,omitempty"`
	Modules     []string `json:"modules,omitempty"`
}

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

type DateRange struct {
	Start time.Time `json:"start"`
	End   time.Time `json:"end"`
}

type DecompressOptions struct {
	Password string
	Validate bool // Validate checksums after decompression
}

type DefaultBackupManager struct {
	// Logger is the logger for backup operations
	Logger io.Writer
}

type DefaultBundleImporter struct {
	// Validator is the validator for bundle validation
	Validator BundleValidator
	// ReportManager is the report manager for generating reports
	ReportManager ReportManager
	// ReportingSystem is the reporting system for generating reports
	ReportingSystem ImportReportingSystem
	// Logger is the logger for import operations
	Logger io.Writer
	// AuditLogger is the logger for audit events
	AuditLogger *errors.AuditLogger
	// ErrorHandler is the error handler for import operations
	ErrorHandler errors.ErrorHandler
	// EnhancedErrorHandler is the enhanced error handler for advanced error handling
	EnhancedErrorHandler *errors.EnhancedErrorHandler
	// RecoveryManager is the recovery manager for error recovery
	RecoveryManager *errors.RecoveryManager
	// ErrorReporter is the error reporter for error reporting
	ErrorReporter errors.ErrorReporter
	// CollectedErrors tracks errors that occurred during import
	CollectedErrors []*errors.BundleError
}

type DefaultBundleValidator struct {
	// Logger is the logger for validation operations
	Logger io.Writer
}

type DefaultConflictDetector struct {
	// Logger is the logger for conflict detection operations
	Logger io.Writer
}

type DefaultConflictResolver struct {
	// Logger is the logger for conflict resolution operations
	Logger io.Writer
	// DefaultStrategies maps conflict types to default resolution strategies
	DefaultStrategies map[ConflictType]ConflictResolutionStrategy
	// PromptCallback is called when a conflict requires user input
	PromptCallback func(conflict *Conflict) (ConflictResolutionStrategy, error)
	// AuditLogger is used for logging audit events
	AuditLogger *errors.AuditLogger
}

type DefaultImportReportingSystem struct {
	// ReportManager is the report manager
	ReportManager ReportManager
	// Logger is the logger for import operations
	Logger io.Writer
	// LogEntries stores log entries by bundle ID
	LogEntries map[string][]string
	// PerformanceMetrics stores performance metrics by bundle ID
	PerformanceMetrics map[string]map[string]interface{}
	// ReportsDir is the directory where reports are stored
	ReportsDir string
}

type DefaultReportGenerator struct {
	// Logger is the logger for report generation operations
	Logger io.Writer
}

type DefaultReportManager struct {
	// Generator is the report generator
	Generator ReportGenerator
	// ReportsDir is the directory where reports are stored
	ReportsDir string
	// Logger is the logger for report management operations
	Logger io.Writer
}

type DefaultRollbackManager struct {
	// BackupManager is the backup manager to use for rollback operations
	BackupManager BackupManager
}

type DefaultStagedImporter struct {
	// Importer is the bundle importer
	Importer BundleImporter
	// Status is the current status of the import
	Status *StagedImportStatus
	// CancelCh is a channel for cancellation
	CancelCh chan struct{}
}

type DeleteOperation struct {
	Path string `json:"path"`
	Type string `json:"type"`
}

type DeltaBundle struct {
	Path     string
	Manifest *DeltaManifest
}

type DeltaDependencies struct {
	Required   []string `json:"required"`
	Compatible []string `json:"compatible"`
}

type DeltaManifest struct {
	Version      string            `json:"version"`
	DeltaType    string            `json:"deltaType"`
	FromVersion  string            `json:"fromVersion"`
	ToVersion    string            `json:"toVersion"`
	Timestamp    time.Time         `json:"timestamp"`
	Size         DeltaSize         `json:"size"`
	Operations   DeltaOperations   `json:"operations"`
	Dependencies DeltaDependencies `json:"dependencies"`
	Rollback     RollbackInfo      `json:"rollback"`
}

type DeltaOperations struct {
	Add    []AddOperation    `json:"add"`
	Update []UpdateOperation `json:"update"`
	Delete []DeleteOperation `json:"delete"`
	Patch  []PatchOperation  `json:"patch"`
}

type DeltaSize struct {
	Compressed   int64 `json:"compressed"`
	Uncompressed int64 `json:"uncompressed"`
}

type DependencyHandling struct {
	ResolutionStrategy DependencyStrategy // How to resolve dependencies
	MaxDepth           int                // Maximum dependency depth
	IncludeOptional    bool               // Include optional dependencies
	IncludeDevDeps     bool               // Include development dependencies
	ExcludePatterns    []string           // Patterns to exclude
	ForceInclude       []string           // Force include specific dependencies
}

type DependencyInfo struct {
	Type         string   `json:"type"`         // hard, soft, optional
	Required     bool     `json:"required"`     // Is this dependency required
	Version      string   `json:"version"`      // Version constraint
	Alternatives []string `json:"alternatives"` // Alternative dependencies
}

type DependencyStrategy string

type DeprecatedFeature struct {
	Name           string `json:"name"`
	DeprecatedIn   string `json:"deprecatedIn"`
	RemovalVersion string `json:"removalVersion"`
	Alternative    string `json:"alternative"`
}

type DirectorySpec struct {
	// Required indicates whether the directory is required
	Required bool
	// Description provides a description of the directory
	Description string
	// Subdirectories defines the subdirectories that should exist
	Subdirectories map[string]DirectorySpec
	// FileExtensions defines the allowed file extensions in this directory
	FileExtensions []string
	// NamingConvention defines the naming convention for files in this directory
	NamingConvention string
}

type DocumentationMetadataExtractor struct{}

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

type EncryptionHandler interface {
	Encrypt(data []byte, password string) ([]byte, error)
	Decrypt(data []byte, password string) ([]byte, error)
	EncryptStream(src io.Reader, dst io.Writer, password string) error
	DecryptStream(src io.Reader, dst io.Writer, password string) error
}

type EncryptionHeader struct {
	Algorithm  string `json:"algorithm"`
	HeaderSize int    `json:"headerSize"`
	Version    string `json:"version"`
}

type EncryptionOptions struct {
	Algorithm string // aes-256-gcm, chacha20-poly1305
	Password  string // Encryption password
	KeyFile   string // Path to key file
}

type EnhancedBundleManifest struct {
	BundleManifest
	// Compliance contains compliance mapping information
	Compliance struct {
		// OwaspLLMTop10 maps OWASP LLM Top 10 categories to content items
		OwaspLLMTop10 map[string][]string `json:"owasp_llm_top10,omitempty"`
		// ISOIEC42001 maps ISO/IEC 42001 controls to content items
		ISOIEC42001 map[string][]string `json:"iso_iec_42001,omitempty"`
	} `json:"compliance,omitempty"`
	// Changelog contains version history information
	Changelog []ChangelogEntry `json:"changelog,omitempty"`
	// Documentation contains paths to documentation files
	Documentation map[string]string `json:"documentation,omitempty"`
	// IsIncremental indicates whether this is an incremental bundle
	IsIncremental bool `json:"is_incremental,omitempty"`
	// BaseVersion is the base version for incremental bundles
	BaseVersion string `json:"base_version,omitempty"`
}

type EnhancedImportReport struct {
	// Base report information
	*ImportReport `json:",inline"`
	// Statistics contains statistics about the import operation
	Statistics *ImportStatistics `json:"statistics,omitempty"`
	// SystemImpact contains information about the impact of the import on the system
	SystemImpact *SystemImpactAssessment `json:"system_impact,omitempty"`
	// ValidationDetails contains detailed information about validation results
	ValidationDetails map[string]interface{} `json:"validation_details,omitempty"`
	// ConflictDetails contains detailed information about conflicts
	ConflictDetails map[string]interface{} `json:"conflict_details,omitempty"`
	// PerformanceMetrics contains detailed performance metrics
	PerformanceMetrics map[string]interface{} `json:"performance_metrics,omitempty"`
	// LogEntries contains log entries related to the import
	LogEntries []string `json:"log_entries,omitempty"`
	// ReportingLevel is the level of detail in the report
	ReportingLevel ReportLevel `json:"reporting_level"` // Using ReportLevel from report.go for consistency
}

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

type EntityInfo struct {
	ID              string                 `json:"id"`
	Path            string                 `json:"path"`
	Type            string                 `json:"type"`
	Name            string                 `json:"name"`
	Version         string                 `json:"version"`
	Category        string                 `json:"category"`
	Tags            []string               `json:"tags"`
	Dependencies    []string               `json:"dependencies"`
	Size            int64                  `json:"size"`
	Modified        time.Time              `json:"modified"`
	Author          string                 `json:"author"`
	Metadata        map[string]interface{} `json:"metadata"`
	Selected        bool                   `json:"selected"`
	SelectionReason string                 `json:"selectionReason"`
}

type EntitySearchCriteria struct {
	Query         string            // Search query
	Type          []string          // Entity types to search
	Category      []string          // Categories to include
	Tags          []string          // Required tags
	Author        string            // Filter by author
	DateRange     *DateRange        // Created/modified date range
	VersionRange  *VersionRange     // Version constraints
	CustomFilters map[string]string // Additional filters
}

type EntitySummary struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	Type     string `json:"type"`
	Size     int64  `json:"size"`
	Reason   string `json:"reason"`
	Selected bool   `json:"selected"`
}

type Environment struct {
	OS                 string
	Arch               string
	Version            string
	AvailableDiskSpace int64
	AvailableMemory    int64
	IsProduction       bool
	InstalledPackages  map[string]string
}

type EnvironmentConfig struct {
	SourceEnvironment string                 // Source environment name
	TargetEnvironment string                 // Target environment name
	ConfigOverrides   map[string]interface{} // Configuration overrides
	SecretHandling    SecretHandlingType     // How to handle secrets
	VariableMapping   map[string]string      // Environment variable mapping
}

type EnvironmentRequirement struct {
	Platforms    []Platform        `json:"platforms"`
	MinDiskSpace int64             `json:"minDiskSpace"`
	MinMemory    int64             `json:"minMemory"`
	RuntimeDeps  map[string]string `json:"runtimeDeps"`
}

type ExportCustomization struct {
	// Scope selection
	ScopeOptions       *ScopeOptions       // Business object scope selection
	EnvironmentConfig  *EnvironmentConfig  // Environment-specific configurations
	DependencyHandling *DependencyHandling // How to handle dependencies

	// Filtering options
	TemplateFilters *TemplateFilterOptions // Template filtering
	ModuleFilters   *ModuleFilterOptions   // Module filtering
	FileFilters     *FileFilterOptions     // General file filtering

	// Transformation options
	Transformations *TransformationOptions // Content transformations

	// Hotfix generation
	HotfixOptions *HotfixOptions // Hotfix script generation

	// Export behavior
	BehaviorOptions *BehaviorOptions // Export behavior customization
}

type ExportFilters struct {
	TemplateCategories []string   // Filter templates by category
	ModuleTypes        []string   // Filter modules by type
	MinVersion         string     // Minimum version to include
	MaxVersion         string     // Maximum version to include
	CreatedAfter       *time.Time // Include items created after this date
	CreatedBefore      *time.Time // Include items created before this date
	Tags               []string   // Filter by tags
	ExcludePatterns    []string   // Glob patterns to exclude
	IncludeList        []string   // Explicit list of paths to include
	ExcludeList        []string   // Explicit list of paths to exclude
}

type ExportFormat string

type ExportOptions struct {
	OutputPath       string                 // Path to save the bundle
	Format           ExportFormat           // Bundle format (tar.gz, zip, etc.)
	IncludeBinary    bool                   // Include the tool binary
	IncludeTemplates bool                   // Include templates
	IncludeModules   bool                   // Include modules
	IncludeDocs      bool                   // Include documentation
	Compression      CompressionType        // Compression type
	Encryption       *EncryptionOptions     // Optional encryption
	Filters          *ExportFilters         // Filters for selective export
	ProgressHandler  ExportProgressHandler  // Progress callback
	Metadata         map[string]interface{} // Additional metadata
}

type ExportPreview struct {
	TotalEntities   int                 `json:"totalEntities"`
	TotalSize       int64               `json:"totalSize"`
	EntityBreakdown map[string]int      `json:"entityBreakdown"`
	Entities        []EntitySummary     `json:"entities"`
	DependencyGraph map[string][]string `json:"dependencyGraph"`
}

type ExportProgressHandler func(progress ProgressInfo)

type ExportRequest struct {
	Name        string   `json:"name"`
	Description string   `json:"description,omitempty"`
	Templates   []string `json:"templates,omitempty"`
	Categories  []string `json:"categories,omitempty"`
	Modules     []string `json:"modules,omitempty"`
	Format      string   `json:"format,omitempty"` // "zip", "tar.gz"
	Compress    bool     `json:"compress,omitempty"`
}

type ExportScope string

type FileBackup struct {
	Path       string `json:"path"`
	Hash       string `json:"hash"`
	Size       int64  `json:"size"`
	Mode       uint32 `json:"mode"`
	BackupPath string `json:"backupPath"`
}

type FileFilterFunc func(path string, info FileInfo) bool

type FileFilterOptions struct {
	IncludePatterns  []string       // Include files matching these patterns
	ExcludePatterns  []string       // Exclude files matching these patterns
	MinSize          int64          // Minimum file size
	MaxSize          int64          // Maximum file size (0 = no limit)
	ModifiedAfter    *time.Time     // Files modified after this date
	ModifiedBefore   *time.Time     // Files modified before this date
	FileTypes        []string       // Include only these file types
	ExcludeFileTypes []string       // Exclude these file types
	CustomFilter     FileFilterFunc // Custom filter function
}

type FileHash struct {
	Path string `json:"path"`
	Hash string `json:"hash"`
	Size int64  `json:"size"`
	Mode uint32 `json:"mode"`
}

type FileInfo struct {
	Path        string
	Size        int64
	Modified    time.Time
	IsDirectory bool
	Permissions uint32
}

type GzipHandler struct {
	Level int
}

type HotfixOptions struct {
	GenerateHotfix  bool         // Generate hotfix scripts
	TargetPlatforms []string     // Target platforms for scripts
	ScriptFormat    ScriptFormat // Script format
	IncludeRollback bool         // Include rollback scripts
	TestMode        bool         // Generate in test mode
	CustomTemplate  string       // Custom script template
}

type ImportConflict struct {
	// Path is the path to the conflicting file
	Path string `json:"path"`
	// BundleChecksum is the checksum of the file in the bundle
	BundleChecksum string `json:"bundle_checksum,omitempty"`
	// ExistingChecksum is the checksum of the existing file
	ExistingChecksum string `json:"existing_checksum,omitempty"`
	// Type is the type of conflict
	Type string `json:"type,omitempty"`
}

type ImportOptions struct {
	// ValidationLevel is the level of validation to perform
	ValidationLevel ValidationLevel
	// TargetDir is the directory to import the bundle to
	TargetDir string
	// BackupDir is the directory to store backups in
	BackupDir string
	// Force indicates whether to force import even if there are conflicts
	Force bool
	// Logger is the logger for import operations
	Logger io.Writer
	// VerboseReporting indicates whether to generate verbose reports
	VerboseReporting bool
	// ProgressCallback is called with progress updates
	ProgressCallback ProgressCallback
	// User is the user performing the import operation
	User string
	// AuditLogger is the logger for audit events
	AuditLogger *errors.AuditLogger
}

type ImportReport struct {
	// ID is the unique identifier for the report
	ID string `json:"id"`
	// Result is the result of the import
	Result *ImportResult `json:"result"`
	// Level is the level of detail in the report
	Level ReportLevel `json:"level"`
	// Format is the format of the report
	Format ReportFormat `json:"format"`
	// GeneratedAt is the time the report was generated
	GeneratedAt time.Time `json:"generated_at"`
}

type ImportReportingSystem interface {
	// CreateReport creates a report for an import operation
	CreateReport(result *ImportResult, level ReportLevel) (*EnhancedImportReport, error)
	// SaveReport saves a report to a file
	SaveReport(report *EnhancedImportReport, path string) error
	// GenerateStatistics generates statistics for an import operation
	GenerateStatistics(result *ImportResult) *ImportStatistics
	// AssessSystemImpact assesses the impact of an import on the system
	AssessSystemImpact(result *ImportResult) *SystemImpactAssessment
	// LogImportEvent logs an event during the import process
	LogImportEvent(bundleID, event string, args ...interface{})
	// GetLogEntries gets the log entries for an import
	GetLogEntries(bundleID string) []string
	// AddPerformanceMetric adds a performance metric for an import
	AddPerformanceMetric(bundleID string, metricName string, value interface{})
	// GenerateUserFriendlySummary creates a human-readable summary of an import operation
	GenerateUserFriendlySummary(report *EnhancedImportReport) string
}

type ImportRequest struct {
	Source        string `json:"source"` // file path or URL
	ValidateOnly  bool   `json:"validate_only,omitempty"`
	Overwrite     bool   `json:"overwrite,omitempty"`
	SkipConflicts bool   `json:"skip_conflicts,omitempty"`
}

type ImportResult struct {
	// Success indicates whether the import was successful
	Success bool `json:"success"`
	// Message contains a human-readable message about the import
	Message string `json:"message"`
	// BundleID is the ID of the imported bundle
	BundleID string `json:"bundle_id"`
	// BundleName is the name of the imported bundle
	BundleName string `json:"bundle_name"`
	// BundleVersion is the version of the imported bundle
	BundleVersion string `json:"bundle_version"`
	// BundleType is the type of the imported bundle
	BundleType BundleType `json:"bundle_type"`
	// ImportTime is the time the import was performed
	ImportTime time.Time `json:"import_time,omitempty"`
	// StartTime is the time the import started
	StartTime time.Time `json:"start_time"`
	// EndTime is the time the import ended
	EndTime time.Time `json:"end_time"`
	// Duration is the duration of the import
	Duration time.Duration `json:"duration"`
	// Errors contains any errors encountered during import
	Errors []string `json:"errors,omitempty"`
	// Warnings contains any warnings that occurred during import
	Warnings []string `json:"warnings,omitempty"`
	// ImportedItems contains the items that were imported
	ImportedItems []ContentItem `json:"imported_items,omitempty"`
	// ValidationResult contains the result of the validation
	ValidationResult *ValidationResult `json:"validation_result,omitempty"`
	// ValidationResults contains the results of validation
	ValidationResults []*ValidationResult `json:"validation_results,omitempty"`
	// ErrorReportPath is the path to the error report
	ErrorReportPath string `json:"error_report_path,omitempty"`
	// Conflicts contains the conflicts that were detected
	Conflicts []*Conflict `json:"conflicts,omitempty"`
	// ConflictResolutions contains the resolutions for conflicts
	ConflictResolutions []*ConflictResolution `json:"conflict_resolutions,omitempty"`
	// BackupID is the ID of the backup created during import
	BackupID string `json:"backup_id,omitempty"`
	// BackupPath is the path to the backup created during import
	BackupPath string `json:"backup_path,omitempty"`
	// ImportedFiles is a list of files that were imported
	ImportedFiles []string `json:"imported_files,omitempty"`
	// SkippedFiles is a list of files that were skipped
	SkippedFiles []string `json:"skipped_files,omitempty"`
	// ErrorMessage contains the error message if the import failed
	ErrorMessage string `json:"error_message,omitempty"`
}

type ImportStatistics struct {
	// TotalFiles is the total number of files in the bundle
	TotalFiles int `json:"total_files"`
	// ImportedFiles is the number of files that were imported
	ImportedFiles int `json:"imported_files"`
	// SkippedFiles is the number of files that were skipped
	SkippedFiles int `json:"skipped_files"`
	// ConflictFiles is the number of files that had conflicts
	ConflictFiles int `json:"conflict_files"`
	// ResolvedConflicts is the number of conflicts that were resolved
	ResolvedConflicts int `json:"resolved_conflicts"`
	// ValidationErrors is the number of validation errors
	ValidationErrors int `json:"validation_errors"`
	// ValidationWarnings is the number of validation warnings
	ValidationWarnings int `json:"validation_warnings"`
	// TotalSize is the total size of the imported files in bytes
	TotalSize int64 `json:"total_size"`
	// ProcessingTime is the time spent processing the import
	ProcessingTime time.Duration `json:"processing_time"`
	// ValidationTime is the time spent validating the bundle
	ValidationTime time.Duration `json:"validation_time"`
	// ExtractionTime is the time spent extracting the bundle
	ExtractionTime time.Duration `json:"extraction_time"`
	// InstallationTime is the time spent installing the bundle
	InstallationTime time.Duration `json:"installation_time"`
}

type Info struct {
	ID          string                 `json:"id"`
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	Version     string                 `json:"version"`
	Author      string                 `json:"author"`
	Tags        []string               `json:"tags,omitempty"`
	Templates   []string               `json:"templates"`
	Modules     []string               `json:"modules,omitempty"`
	Size        int64                  `json:"size"`
	Checksum    string                 `json:"checksum"`
	CreatedAt   time.Time              `json:"created_at"`
	UpdatedAt   time.Time              `json:"updated_at"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

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

type Manager interface {
	ListBundles() ([]Info, error)
	GetBundle(id string) (*Info, error)
	CreateBundle(request CreateRequest) (*Info, error)
	DeleteBundle(id string) error
	ExportBundle(request ExportRequest) (*OperationResult, error)
	ImportBundle(request ImportRequest) (*OperationResult, error)
}

type ManifestChanges struct {
	Added    []ContentChange `json:"added"`
	Removed  []ContentChange `json:"removed"`
	Modified []ContentChange `json:"modified"`
}

type ManifestComparison struct {
	OldVersion string            `json:"oldVersion"`
	NewVersion string            `json:"newVersion"`
	Changes    ManifestChanges   `json:"changes"`
	Summary    ComparisonSummary `json:"summary"`
}

type ManifestFormat string

type ManifestGenerator struct {
	// SigningKey is the key used to sign bundles
	SigningKey ed25519.PrivateKey
	// Author is the default author for generated manifests
	Author Author
}

type ManifestOptions struct {
	IncludeChecksums    bool                   // Include file checksums
	ChecksumAlgorithms  []string               // Checksum algorithms to use
	IncludePermissions  bool                   // Include file permissions
	IncludeTimestamps   bool                   // Include modification timestamps
	IncludeSize         bool                   // Include file sizes
	ResolveDependencies bool                   // Analyze and include dependencies
	IncludeMetadata     bool                   // Extract and include metadata
	CustomFields        map[string]interface{} // Custom fields to add
	PrettyPrint         bool                   // Format output for readability
	Format              ManifestFormat         // Output format
}

type MetadataEnricher interface {
	EnrichMetadata(path string, existing map[string]interface{}) map[string]interface{}
}

type MetadataExtractor interface {
	Extract(path string) (map[string]interface{}, error)
	Supports(path string) bool
}

type ModuleFilterFunc func(module *ModuleInfo) bool

type ModuleFilterOptions struct {
	Types            []ModuleType     // Include only these module types
	ExcludeTypes     []ModuleType     // Exclude these module types
	Providers        []string         // Include modules from these providers
	ExcludeProviders []string         // Exclude modules from these providers
	MinVersion       string           // Minimum module version
	MaxVersion       string           // Maximum module version
	Platforms        []string         // Target platforms
	Architectures    []string         // Target architectures
	CustomFilter     ModuleFilterFunc // Custom filter function
}

type ModuleInfo struct {
	Name         string
	Type         ModuleType
	Version      string
	Provider     string
	Platform     string
	Architecture string
	Dependencies []string
}

type ModuleMetadataExtractor struct{}

type ModuleType string

type NoCompressionHandler struct{}

type OfflineBundle struct {
	Bundle
	// EnhancedManifest contains the enhanced manifest information
	EnhancedManifest EnhancedBundleManifest
	// Format is the format specification for this bundle
	Format *OfflineBundleFormat
	// IsIncremental indicates whether this is an incremental bundle
	IsIncremental bool
	// ComplianceMappings contains detailed compliance mapping information
	ComplianceMappings []ComplianceMapping
}

type OfflineBundleCreator struct {
	// Generator is the manifest generator
	Generator *ManifestGenerator
	// Validator is the offline bundle validator
	Validator *OfflineBundleValidator
	// Format is the offline bundle format
	Format *OfflineBundleFormat
	// Logger is the logger for bundle creation operations
	Logger io.Writer
	// AuditTrail is the audit trail manager for logging operations
	AuditTrail *trail.AuditTrailManager
}

type OfflineBundleFormat struct {
	// SchemaVersion is the version of the bundle schema
	SchemaVersion string `json:"schema_version"`
	// FormatVersion is the version of the offline bundle format
	FormatVersion string `json:"format_version"`
	// SupportedTypes lists the supported bundle types
	SupportedTypes []BundleType `json:"supported_types"`
	// RequiredDirectories lists the required directories in the bundle
	RequiredDirectories []string `json:"required_directories"`
	// OptionalDirectories lists the optional directories in the bundle
	OptionalDirectories []string `json:"optional_directories"`
	// ManifestSchema defines the schema for the manifest file
	ManifestSchema map[string]interface{} `json:"manifest_schema"`
	// ValidationLevels lists the supported validation levels
	ValidationLevels []ValidationLevel `json:"validation_levels"`
	// SignatureAlgorithm specifies the algorithm used for signatures
	SignatureAlgorithm string `json:"signature_algorithm"`
	// ChecksumAlgorithm specifies the algorithm used for checksums
	ChecksumAlgorithm string `json:"checksum_algorithm"`
	// UpdatedAt is the timestamp when the format was last updated
	UpdatedAt time.Time `json:"updated_at"`
}

type OfflineBundleValidator struct {
	// BaseValidator is the underlying bundle validator
	BaseValidator BundleValidator
	// Logger is the logger for validation operations
	Logger io.Writer
}

type Operation struct {
	Type      string      `json:"type"`
	Path      string      `json:"path"`
	Details   interface{} `json:"details"`
	Completed bool        `json:"completed"`
}

type OperationResult struct {
	BundleID  string            `json:"bundle_id,omitempty"`
	Status    string            `json:"status"`
	Message   string            `json:"message,omitempty"`
	Templates []string          `json:"templates,omitempty"`
	Modules   []string          `json:"modules,omitempty"`
	Conflicts []string          `json:"conflicts,omitempty"`
	Errors    []string          `json:"errors,omitempty"`
	Metadata  map[string]string `json:"metadata,omitempty"`
}

type PartialBundleExporter struct {
	*BundleExporter
	// contains filtered or unexported fields
}

type PartialExportOptions struct {
	// Entity selection methods
	EntitySearch    *EntitySearchCriteria  // Search-based selection
	EntityCSV       string                 // CSV file with entity list
	EntityList      []string               // Direct list of entities
	RevisionControl *RevisionControlConfig // Git/SVN integration

	// Export scope
	ExportScope         ExportScope // What to export
	IncludeDependencies bool        // Include entity dependencies
	ResolveReferences   bool        // Resolve cross-references

	// Selection state
	PendingEntities  []EntityInfo          // Entities pending addition
	IncludedEntities map[string]EntityInfo // Currently included entities
	ExcludedEntities map[string]EntityInfo // Explicitly excluded entities
}

type PasswordStrengthChecker struct {
	MinLength      int
	RequireUpper   bool
	RequireLower   bool
	RequireNumbers bool
	RequireSpecial bool
}

type PatchOperation struct {
	Path      string `json:"path"`
	Type      string `json:"type"`
	PatchFile string `json:"patchFile"`
	Algorithm string `json:"algorithm"`
}

type Platform struct {
	OS   string   `json:"os"`
	Arch []string `json:"arch"`
}

type ProgressCallback func(progress float64, message string)

type ProgressEvent struct {
	Stage          ProgressStage          // Current stage of operation
	Operation      string                 // Current operation description
	Current        int64                  // Current progress value
	Total          int64                  // Total expected value
	Percentage     float64                // Percentage complete (0-100)
	BytesProcessed int64                  // Bytes processed so far
	BytesTotal     int64                  // Total bytes to process
	ItemsProcessed int                    // Number of items processed
	ItemsTotal     int                    // Total number of items
	TimeElapsed    time.Duration          // Time elapsed since start
	TimeRemaining  time.Duration          // Estimated time remaining
	Speed          float64                // Processing speed (bytes/sec)
	CurrentFile    string                 // Current file being processed
	Error          error                  // Error if any
	Metadata       map[string]interface{} // Additional metadata
}

type ProgressHandler func(event ProgressEvent)

type ProgressInfo struct {
	Stage          string  // Current stage
	Current        int     // Current item
	Total          int     // Total items
	Percentage     float64 // Completion percentage
	CurrentFile    string  // Current file being processed
	BytesProcessed int64   // Bytes processed
	TotalBytes     int64   // Total bytes to process
	TimeElapsed    time.Duration
	TimeRemaining  time.Duration
	Message        string // Status message
}

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

type ProgressStage string

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

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

type ReportFormat string

type ReportGenerator interface {
	// GenerateReport generates a report of an import operation
	GenerateReport(result *ImportResult, level ReportLevel, format ReportFormat) (*ImportReport, error)
	// WriteReport writes a report to a writer
	WriteReport(report *ImportReport, writer io.Writer) error
	// SaveReport saves a report to a file
	SaveReport(report *ImportReport, path string) error
}

type ReportLevel string

type ReportManager interface {
	// CreateImportReport creates a report for an import operation
	CreateImportReport(result *ImportResult, level ReportLevel, format ReportFormat) (*ImportReport, error)
	// SaveImportReport saves an import report to a file
	SaveImportReport(report *ImportReport, path string) error
	// GetReportPath gets the path for a report
	GetReportPath(bundleID string, format ReportFormat) string
	// ListReports lists all reports in a directory
	ListReports(dir string) ([]string, error)
}

type Requirement struct {
	MinVersion string `json:"minVersion"`
	MaxVersion string `json:"maxVersion,omitempty"`
	Required   bool   `json:"required"`
}

type RevisionControlConfig struct {
	Type            string    // git, svn, mercurial
	Repository      string    // Repository URL
	Branch          string    // Branch/tag to use
	CommitRange     string    // Commit range (e.g., HEAD~10..HEAD)
	IncludeModified bool      // Include uncommitted changes
	AuthConfig      *AuthInfo // Authentication details
}

type RollbackInfo struct {
	Supported        bool `json:"supported"`
	SnapshotRequired bool `json:"snapshotRequired"`
}

type RollbackManager interface {
	// CreateRollbackPoint creates a rollback point
	CreateRollbackPoint(ctx context.Context, targetDir, backupDir, description string) (string, error)
	// Rollback rolls back to a rollback point
	Rollback(ctx context.Context, rollbackPointPath, targetDir string) error
	// ListRollbackPoints lists all rollback points
	ListRollbackPoints(ctx context.Context, backupDir string) ([]BackupMetadata, error)
	// DeleteRollbackPoint deletes a rollback point
	DeleteRollbackPoint(ctx context.Context, rollbackPointPath string) error
}

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

type ScopeOptions struct {
	IncludeScopes     []string // Scopes to include
	ExcludeScopes     []string // Scopes to exclude
	ScopeDepth        int      // Maximum scope traversal depth
	IncludeOrphaned   bool     // Include orphaned objects
	IncludeDeprecated bool     // Include deprecated objects
}

type ScriptFormat string

type SecretHandlingType string

type SignatureAlgorithm string

type SignatureManager struct {
	// Algorithm is the signature algorithm used
	Algorithm SignatureAlgorithm
	// Generator is the signature generator
	Generator *update.SignatureGenerator
	// PublicKey is the public key used for verification
	PublicKey ed25519.PublicKey
}

type SignatureMetadata struct {
	Signer      string   `json:"signer"`
	Environment string   `json:"environment"`
	BuildID     string   `json:"buildId"`
	Tags        []string `json:"tags"`
}

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