errors

type AuditLogger struct {
	// Writer is the writer for audit logs
	Writer io.Writer
	// User is the user performing the operation
	User string
}

type BackupRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
	// BackupDir is the directory for backups
	BackupDir string
}

type BundleError struct {
	// ErrorID is a unique identifier for this error instance
	ErrorID string `json:"error_id"`

	// Code is the error code
	Code ErrorCode `json:"code"`

	// Category is the error category
	Category ErrorCategory `json:"category"`

	// Severity is the error severity
	Severity ErrorSeverity `json:"severity"`

	// Recoverability indicates if the error is recoverable
	Recoverability ErrorRecoverability `json:"recoverability"`

	// Message is the human-readable error message
	Message string `json:"message"`

	// Details contains additional error details
	Details map[string]interface{} `json:"details,omitempty"`

	// Context contains contextual information
	Context map[string]interface{} `json:"context,omitempty"`

	// Timestamp is when the error occurred
	Timestamp time.Time `json:"timestamp"`

	// StackTrace contains the stack trace
	StackTrace string `json:"stack_trace,omitempty"`

	// RetryAttempt is the current retry attempt
	RetryAttempt int `json:"retry_attempt"`

	// MaxRetries is the maximum number of retries
	MaxRetries int `json:"max_retries"`

	// Cause is the underlying error
	Cause error `json:"-"`
}

type CircuitBreaker struct {
	// State is the current state
	State string
	// FailureCount tracks failures
	FailureCount int
	// SuccessCount tracks successes
	SuccessCount int
	// LastFailureTime is the time of last failure
	LastFailureTime time.Time
	// Threshold is the failure threshold
	Threshold int
	// Timeout is the timeout duration
	Timeout time.Duration
	// contains filtered or unexported fields
}

type ConflictRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
	// Force indicates whether to force resolution
	Force bool
}

type DefaultErrorCategorizer struct {
	// Logger is the logger for categorization events
	Logger io.Writer
}

type DefaultErrorHandler struct {
	// Logger is the logger for error events
	Logger interface{}
	// Metrics is the metrics collector
	Metrics interface{}
	// RecoveryStrategy is the strategy for recovering from errors
	RecoveryStrategy RecoveryStrategy
}

type DefaultErrorReporter struct {
	Writer      io.Writer
	AuditLogger *AuditLogger
}

type EnhancedErrorHandler struct {
	// ErrorCategorizer categorizes errors
	ErrorCategorizer ErrorCategorizer
	// RecoveryManager manages recovery strategies
	RecoveryManager *RecoveryManager
	// CircuitBreaker provides circuit breaking functionality
	CircuitBreaker *CircuitBreaker
	// RetryPolicy defines retry behavior
	RetryPolicy *RetryPolicy
	// RateLimiter limits error handling rate
	RateLimiter *TokenBucketRateLimiter
	// Metrics tracks error metrics
	Metrics map[string]int
	// ErrorMetrics tracks detailed error metrics
	ErrorMetrics *ErrorMetrics
	// contains filtered or unexported fields
}

type ErrorCategorizer interface {
	// CategorizeError categorizes an error
	CategorizeError(err error) (ErrorCategory, ErrorSeverity, ErrorRecoverability)
}

type ErrorCategory string

type ErrorCode string

type ErrorHandler interface {
	HandleError(ctx context.Context, err error) error
}

type ErrorLogger interface {
	// LogEvent logs an event
	LogEvent(event, component, id string, details map[string]interface{})
	// LogEventWithStatus logs an event with a status
	LogEventWithStatus(event, component, id, status string, details map[string]interface{})
}

type ErrorMetrics struct {
	TotalErrors       int `json:"total_errors"`
	RecoveredErrors   int `json:"recovered_errors"`
	UnrecoveredErrors int `json:"unrecovered_errors"`
	RetryAttempts     int `json:"retry_attempts"`
}

type ErrorRecoverability string

type ErrorReport struct {
	GeneratedAt time.Time      `json:"generated_at"`
	TotalErrors int            `json:"total_errors"`
	Statistics  ErrorStats     `json:"statistics"`
	Errors      []*BundleError `json:"errors"`
}

type ErrorReporter interface {
	Report(ctx context.Context, err *BundleError) error
	GenerateReport(ctx context.Context, errors []*BundleError) (*ErrorReport, error)
	GenerateErrorReport(ctx context.Context, errors []*BundleError, outputPath string) error
}

type ErrorSeverity string

type ErrorStats struct {
	BySeverity       map[string]int `json:"by_severity"`
	ByCategory       map[string]int `json:"by_category"`
	ByRecoverability map[string]int `json:"by_recoverability"`
}

type FileSystemRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
}

type NetworkRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
	// MaxRetries is the maximum number of retries
	MaxRetries int
}

type RecoveryManager struct {
	// Strategies is a list of recovery strategies
	Strategies []RecoveryStrategy
	// Logger is the logger for recovery events
	Logger io.Writer
	// AuditLogger is the logger for audit events
	AuditLogger *AuditLogger
}

type RecoveryStrategy interface {
	// Recover attempts to recover from an error
	Recover(ctx context.Context, err *BundleError) (bool, error)
	// CanRecover determines if the strategy can recover from an error
	CanRecover(err *BundleError) bool
}

type RetryPolicy struct {
	// MaxRetries is the maximum number of retries
	MaxRetries int
	// InitialDelay is the initial delay between retries
	InitialDelay time.Duration
	// MaxDelay is the maximum delay between retries
	MaxDelay time.Duration
	// Multiplier is the delay multiplier
	Multiplier float64
	// Jitter adds randomness to delays
	Jitter bool
}

type TokenBucketRateLimiter struct {
	// Capacity is the bucket capacity
	Capacity int
	// RefillRate is the token refill rate
	RefillRate int
	// Tokens is the current token count
	Tokens int
	// LastRefill is the last refill time
	LastRefill time.Time
	// contains filtered or unexported fields
}