qualification

type ApprovalValidatorConfig struct {
	// MinApprovals is the minimum number of approvals required
	MinApprovals int `json:"minApprovals" yaml:"minApprovals"`

	// RequiredReviewers are users who must review the PR
	RequiredReviewers []string `json:"requiredReviewers,omitempty" yaml:"requiredReviewers,omitempty"`

	// RequiredTeams are teams that must have at least one member review
	RequiredTeams []string `json:"requiredTeams,omitempty" yaml:"requiredTeams,omitempty"`

	// IgnoreBotApprovals when true excludes bot approvals from the count
	IgnoreBotApprovals bool `json:"ignoreBotApprovals" yaml:"ignoreBotApprovals"`
}

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

type ChecksGitHubClient interface {
	ListStatuses(ctx context.Context, repo github.Repository, ref string) ([]github.Status, error)
}

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

type ChecksValidatorConfig struct {
	// RequiredChecks are status checks that must pass
	RequiredChecks []string `json:"requiredChecks" yaml:"requiredChecks"`

	// OptionalChecks are checks that may be present but don't affect validation
	OptionalChecks []string `json:"optionalChecks,omitempty" yaml:"optionalChecks,omitempty"`

	// AllowedFailures are checks that are allowed to fail
	AllowedFailures []string `json:"allowedFailures,omitempty" yaml:"allowedFailures,omitempty"`

	// Timeout is the maximum time to wait for checks to complete
	Timeout time.Duration `json:"timeout,omitempty" yaml:"timeout,omitempty"`
}

type CompositeStrategy string

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

type ConfigLoader struct{}

type DynamicLabelConfig struct {
	// FilePath is the file path in the PR to read
	FilePath string `json:"filePath" yaml:"filePath"`

	// Key is the simple YAML/JSON key to extract (mutually exclusive with JSONPath)
	Key string `json:"key,omitempty" yaml:"key,omitempty"`

	// JSONPath is the JSONPath expression to extract complex values
	JSONPath string `json:"jsonPath,omitempty" yaml:"jsonPath,omitempty"`

	// LabelName is the name of the label to create (e.g., "cd/version")
	LabelName string `json:"labelName" yaml:"labelName"`

	// Required indicates whether this extraction must succeed for qualification
	Required bool `json:"required" yaml:"required"`

	// DefaultValue is used if extraction fails and not required
	DefaultValue string `json:"defaultValue,omitempty" yaml:"defaultValue,omitempty"`

	// ValueTransform is an optional transformation to apply to extracted values
	ValueTransform string `json:"valueTransform,omitempty" yaml:"valueTransform,omitempty"`
}

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

type DynamicLabelValidatorConfig struct {
	// Extractors configuration
	Extractors []extraction.ExtractorConfig `json:"extractors" yaml:"extractors"`

	// LabelTemplates for rendering labels
	LabelTemplates []extraction.LabelTemplate `json:"labelTemplates" yaml:"labelTemplates"`

	// Timeout for extraction operations
	Timeout time.Duration `json:"timeout" yaml:"timeout"`

	// FailOnExtractionError determines if validator fails when required extraction fails
	FailOnExtractionError bool `json:"failOnExtractionError" yaml:"failOnExtractionError"`

	// CacheEnabled controls whether file caching is enabled
	CacheEnabled bool `json:"cacheEnabled" yaml:"cacheEnabled"`

	// CacheTTL is the cache time-to-live duration
	CacheTTL time.Duration `json:"cacheTTL" yaml:"cacheTTL"`

	// MaxCacheSize is the maximum number of files to cache
	MaxCacheSize int `json:"maxCacheSize" yaml:"maxCacheSize"`
}

type FilePatternGitHubClient interface {
	ListPRFiles(ctx context.Context, repo github.Repository, number int) ([]github.PRFile, error)
}

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

type FilePatternValidatorConfig struct {
	// RestrictedPatterns are file patterns that are not allowed to be modified
	RestrictedPatterns []string `json:"restrictedPatterns" yaml:"restrictedPatterns"`

	// AllowedPatterns are file patterns that are allowed (whitelist approach)
	AllowedPatterns []string `json:"allowedPatterns,omitempty" yaml:"allowedPatterns,omitempty"`

	// Mode determines whether to use blacklist (restricted) or whitelist (allowed) approach
	Mode string `json:"mode" yaml:"mode"` // "blacklist" or "whitelist"

	// MaxFileSize is the maximum allowed size for individual files in bytes
	MaxFileSize int64 `json:"maxFileSize,omitempty" yaml:"maxFileSize,omitempty"`
}

type GitHubClient interface {
	ListReviews(ctx context.Context, repo github.Repository, number int) ([]github.Review, error)
}

type LabelValidatorConfig struct {
	// RequiredLabels are labels that must be present on the PR
	RequiredLabels []string `json:"requiredLabels" yaml:"requiredLabels"`

	// ForbiddenLabels are labels that must not be present on the PR
	ForbiddenLabels []string `json:"forbiddenLabels,omitempty" yaml:"forbiddenLabels,omitempty"`

	// RequiredLabelPattern is a regex pattern that at least one label must match
	RequiredLabelPattern string `json:"requiredLabelPattern,omitempty" yaml:"requiredLabelPattern,omitempty"`
}

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

type LayoutConfig struct {
	// Layouts defines the supported layout patterns with their configurations
	Layouts []LayoutDefinition `json:"layouts" yaml:"layouts"`

	// StrictMode when true requires exact pattern match, when false allows partial matches
	StrictMode bool `json:"strictMode" yaml:"strictMode"`
}

type LayoutDefinition struct {
	// Name is the human-readable name of this layout
	Name string `json:"name" yaml:"name"`

	// Type is the layout type (standard, tmc, etc.)
	Type LayoutType `json:"type" yaml:"type"`

	// Patterns are the file path patterns that define this layout
	// Supports placeholders like <app>, <cluster>, <env>
	Patterns []string `json:"patterns" yaml:"patterns"`

	// MaxChangedFiles limits the number of files that can be modified in this layout
	MaxChangedFiles int `json:"maxChangedFiles" yaml:"maxChangedFiles"`

	// RequiredFiles are files that must be present for this layout
	RequiredFiles []string `json:"requiredFiles,omitempty" yaml:"requiredFiles,omitempty"`

	// ForbiddenFiles are files that must not be present for this layout
	ForbiddenFiles []string `json:"forbiddenFiles,omitempty" yaml:"forbiddenFiles,omitempty"`

	// Description provides human-readable explanation of this layout
	Description string `json:"description,omitempty" yaml:"description,omitempty"`
}

type LayoutType = domainQual.LayoutType

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

type Logger interface {
	Debug(msg string, fields ...zap.Field)
	Info(msg string, fields ...zap.Field)
	Warn(msg string, fields ...zap.Field)
	Error(msg string, fields ...zap.Field)
}

type MatchResult struct {
	// Matched indicates whether the pattern was matched
	Matched bool

	// Pattern is the pattern that was matched
	Pattern string

	// LayoutType is the layout type this pattern belongs to
	LayoutType LayoutType

	// MatchedFiles are the files that matched the pattern
	MatchedFiles []string

	// ExtractedVariables contains extracted placeholder values (e.g., app name)
	ExtractedVariables map[string]string
}

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

type QualificationConfig struct {
	// Validators contains configuration for each validator
	Validators []ValidatorConfig

	// Strategy determines how multiple validators are combined
	Strategy CompositeStrategy

	// StopOnFirstFailure determines whether to halt on the first validation failure
	StopOnFirstFailure bool

	// DefaultTimeout is the timeout for individual validator operations
	DefaultTimeout string
}

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

type QualificationResult struct {
	// Qualified indicates whether the PR passed all validations
	Qualified bool

	// LayoutType is the detected layout type
	LayoutType LayoutType

	// Results contains individual validation results
	Results []Result

	// Failures contains only the failed validation results
	Failures []Result

	// Summary provides a human-readable summary of the qualification
	Summary string

	// ExtractedLabels contains dynamic labels extracted during qualification
	ExtractedLabels map[string]string

	// ExtractedMetadata contains raw metadata extracted during qualification
	ExtractedMetadata map[string]string

	// ProcessingTime is how long qualification took
	ProcessingTime time.Duration
}

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

type Result = domainQual.Result

type Severity = domainQual.Severity

type ValidationError struct {
	ValidatorName string
	Cause         error
}

type Validator interface {
	// Name returns the unique name of this validator (used for configuration and logging)
	Name() string

	// Validate performs the validation check on a pull request.
	// Returns a Result indicating success/failure with detailed information.
	Validate(ctx context.Context, pr github.PullRequest) (Result, error)
}

type ValidatorConfig struct {
	// Name is the validator name
	Name string

	// Enabled controls whether the validator is active
	Enabled bool

	// Config contains validator-specific configuration
	Config map[string]interface{}
}