common

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

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

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

type ConflictError struct {
	ConflictType string      // Type of conflict (e.g., "duplicate", "concurrent_modification")
	ConflictWith string      // What this entity conflicts with
	Metadata     interface{} // Additional conflict details
	// contains filtered or unexported fields
}

type DeploymentSyncedEvent struct {
	*BaseEvent
	Repository   string    // Repository in "owner/name" format
	PRNumber     int       // Pull request number
	Cluster      string    // Cluster where sync completed
	Application  string    // Application name
	Revision     string    // Deployed git revision
	HealthStatus string    // Application health status
	SyncedAt     time.Time // When sync completed
}

type DeploymentUnhealthyEvent struct {
	*BaseEvent
	Repository    string    // Repository in "owner/name" format
	PRNumber      int       // Pull request number
	Cluster       string    // Cluster with unhealthy deployment
	Application   string    // Application name
	HealthStatus  string    // Current health status
	HealthMessage string    // Health check failure details
	DetectedAt    time.Time // When unhealthy status was detected
}

type DomainError interface {
	error

	// Domain returns the domain context where this error occurred (e.g., "pr", "qualification", "drift")
	Domain() string

	// Code returns a machine-readable error code for programmatic handling
	Code() string

	// IsPermanent returns true if this error represents a permanent failure
	// that will not resolve with retries (e.g., validation failures, business rule violations)
	IsPermanent() bool

	// Unwrap returns the underlying error if any, enabling error chain traversal
	Unwrap() error
}

type DomainEvent interface {
	// EventID returns the unique identifier for this event instance
	EventID() string

	// EventType returns the type/name of this event (e.g., "pr.discovered", "drift.detected")
	EventType() string

	// AggregateID returns the ID of the aggregate that produced this event
	AggregateID() string

	// AggregateType returns the type of aggregate (e.g., "PullRequest", "DriftMonitor")
	AggregateType() string

	// OccurredAt returns when this event occurred
	OccurredAt() time.Time

	// Version returns the event schema version for evolution/compatibility
	Version() int

	// Metadata returns additional event metadata (correlation IDs, causation IDs, etc.)
	Metadata() map[string]string
}

type DriftDetectedEvent struct {
	*BaseEvent
	Repository       string    // Repository in "owner/name" format
	PRNumber         int       // Pull request number
	Cluster          string    // Cluster where drift was detected
	Application      string    // Application name with drift
	ExpectedRevision string    // Expected git revision (from merged PR)
	ActualRevision   string    // Actual deployed revision
	DriftType        string    // Type of drift (revision, config, etc.)
	DetectedAt       time.Time // When drift was detected
}

type DriftResolvedEvent struct {
	*BaseEvent
	Repository       string    // Repository in "owner/name" format
	PRNumber         int       // Pull request number
	Cluster          string    // Cluster where drift was resolved
	Application      string    // Application name
	NewRevision      string    // New deployed revision that resolved drift
	ResolvedAt       time.Time // When drift was resolved
	ResolutionMethod string    // How drift was resolved (auto-sync, manual, etc.)
}

type EntityStatus string

type EventBus interface {
	// Publish publishes a single domain event
	Publish(ctx interface{}, event DomainEvent) error

	// PublishBatch publishes multiple events in a single operation
	PublishBatch(ctx interface{}, events []DomainEvent) error

	// Subscribe registers a handler for specific event types
	Subscribe(eventType string, handler EventHandler) error

	// Unsubscribe removes a handler for specific event types
	Unsubscribe(eventType string, handler EventHandler) error
}

type EventHandler func(ctx interface{}, event DomainEvent) error

type EventStore interface {
	// Append appends events to an aggregate's event stream
	Append(ctx interface{}, aggregateID string, events []DomainEvent) error

	// Load loads all events for an aggregate in order
	Load(ctx interface{}, aggregateID string) ([]DomainEvent, error)

	// LoadFromVersion loads events from a specific version onwards
	LoadFromVersion(ctx interface{}, aggregateID string, version int) ([]DomainEvent, error)
}

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

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

type NotFoundError struct {
	EntityType string      // Type of entity (e.g., "PullRequest", "DriftMonitor")
	EntityID   string      // Identifier of the missing entity
	Metadata   interface{} // Additional context (e.g., repository, filters)
	// contains filtered or unexported fields
}

type OperationError struct {
	Operation string            // Name of the operation that failed
	Context   map[string]string // Additional operation context
	// contains filtered or unexported fields
}

type PRDiscoveredEvent struct {
	*BaseEvent
	Repository   string // Repository in "owner/name" format
	PRNumber     int    // Pull request number
	PRTitle      string // Pull request title
	Author       string // PR author username
	SourceBranch string // Source branch name
	TargetBranch string // Target branch name
}

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

type PRMergeFailedEvent struct {
	*BaseEvent
	Repository    string // Repository in "owner/name" format
	PRNumber      int    // Pull request number
	FailureReason string // Why the merge failed
	Retryable     bool   // Whether merge can be retried
}

type PRMergedEvent struct {
	*BaseEvent
	Repository     string    // Repository in "owner/name" format
	PRNumber       int       // Pull request number
	MergeCommitSHA string    // SHA of the merge commit
	MergedBy       string    // Username who/what merged the PR
	MergedAt       time.Time // When the PR was merged
	TargetBranch   string    // Branch the PR was merged into
}

type PRQualificationFailedEvent struct {
	*BaseEvent
	Repository      string   // Repository in "owner/name" format
	PRNumber        int      // Pull request number
	FailedValidator string   // Primary validator that failed
	FailureReasons  []string // Detailed failure reasons
	Retryable       bool     // Whether qualification can be retried after changes
}

type PRQualifiedEvent struct {
	*BaseEvent
	Repository      string            // Repository in "owner/name" format
	PRNumber        int               // Pull request number
	LayoutType      string            // Detected layout type (standard, tmc, etc.)
	Validators      []string          // List of validators that passed
	ExtractedLabels map[string]string // Dynamic labels extracted during qualification
}

type ProcessResult[T any] struct {
	// Success indicates whether the processing completed without errors.
	// True means the operation succeeded; false means it failed.
	Success bool

	// Error contains any error that occurred during processing.
	// Nil if Success is true.
	Error error

	// Duration is how long the processing took from start to completion.
	Duration time.Duration

	// Data contains domain-specific result data for this pipeline.
	// The type of data depends on which pipeline produced the result:
	//   - PR Pipeline: includes action, PR, state transition, next actions
	//   - Drift Pipeline: includes drift detection details, deployed SHA, health status
	Data T

	// Metadata contains additional contextual information about the processing.
	// This can include debugging info, timestamps, resource IDs, etc.
	// Keys should be descriptive strings (e.g., "retry_count", "cluster_name").
	Metadata map[string]interface{}
}

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

type StateTransitionError struct {
	FromState string // The current state
	ToState   string // The attempted target state
	Reason    string // Why the transition is invalid
	// contains filtered or unexported fields
}

type StateTransitionEvent struct {
	*BaseEvent
	Repository     string    // Repository in "owner/name" format
	PRNumber       int       // Pull request number
	FromState      string    // Previous state
	ToState        string    // New state
	Reason         string    // Why the transition occurred
	Actor          string    // Who/what triggered the transition (user, system, etc.)
	TransitionedAt time.Time // When the transition occurred
}

type ValidationError struct {
	ValidatorName string            // Name of the validator that failed
	FieldName     string            // Field that failed validation (if applicable)
	Value         interface{}       // The invalid value (if safe to include)
	Constraints   map[string]string // Violated constraints (e.g., "min": "5", "max": "100")
	// contains filtered or unexported fields
}