scanner

type BaseRule struct {
	ID           string        `json:"id"`
	RuleType     RuleType      `json:"type"`
	RuleInputs   []Input       `json:"inputs"`
	RuleMetadata *RuleMetadata `json:"metadata,omitempty"`
}

type CelRule interface {
	Rule

	// Expression returns the CEL expression to evaluate
	Expression() string
}

type CelRuleImpl struct {
	BaseRule
	CelExpr string `json:"expression"`
}

type CelVariable interface {
	// Name returns the variable name
	Name() string

	// Namespace returns the namespace context
	Namespace() string

	// Value returns the variable value
	Value() string

	// GroupVersionKind returns the Kubernetes GVK for this variable
	GroupVersionKind() schema.GroupVersionKind
}

type CheckResult struct {
	ID           string              `json:"id"`
	Status       CheckResultStatus   `json:"status"`
	Metadata     CheckResultMetadata `json:"metadata"`
	Warnings     []string            `json:"warnings"`
	ErrorMessage string              `json:"errorMessage"`
}

type CheckResultMetadata struct {
	Environment ScanEnvironment        `json:"environment,omitempty"`
	Extensions  map[string]interface{} `json:"extensions,omitempty"`
}

type CheckResultStatus string

type DefaultLogger struct{}

type FileInput struct {
	FilePath    string `json:"path"`
	FileFormat  string `json:"format,omitempty"`
	IsRecursive bool   `json:"recursive,omitempty"`
	CheckPerms  bool   `json:"checkPermissions,omitempty"`
}

type FileInputSpec interface {
	InputSpec

	// Path returns the file or directory path
	Path() string

	// Format returns the expected file format (json, yaml, text, etc.)
	Format() string

	// Recursive indicates if directory traversal should be recursive
	Recursive() bool

	// CheckPermissions indicates if file permissions should be included
	CheckPermissions() bool
}

type HTTPInput struct {
	Endpoint    string            `json:"url"`
	HTTPMethod  string            `json:"method,omitempty"`
	HTTPHeaders map[string]string `json:"headers,omitempty"`
	HTTPBody    []byte            `json:"body,omitempty"`
}

type HTTPInputSpec interface {
	InputSpec

	// URL returns the HTTP endpoint URL
	URL() string

	// Method returns the HTTP method (GET, POST, etc.)
	Method() string

	// Headers returns HTTP headers
	Headers() map[string]string

	// Body returns the request body
	Body() []byte
}

type Input interface {
	// Name returns the name to bind this input to in the CEL context
	Name() string

	// Type returns the type of input (kubernetes, file, system, etc.)
	Type() InputType

	// Spec returns the input specification
	Spec() InputSpec
}

type InputFetcher interface {
	// FetchInputs retrieves data for the specified inputs
	FetchInputs(inputs []Input, variables []CelVariable) (map[string]interface{}, error)

	// SupportsInputType returns whether this fetcher supports the given input type
	SupportsInputType(inputType InputType) bool
}

type InputImpl struct {
	InputName string    `json:"name"`
	InputType InputType `json:"type"`
	InputSpec InputSpec `json:"spec"`
}

type InputSpec interface {
	// Validate checks if the input specification is valid
	Validate() error
}

type InputType string

type IssueLocation struct {
	// Line number in the expression (1-based)
	Line int `json:"line,omitempty"`

	// Column number in the expression (1-based)
	Column int `json:"column,omitempty"`

	// Offset is the character offset in the expression
	Offset int `json:"offset,omitempty"`
}

type KubernetesInput struct {
	Group   string `json:"group"`
	Ver     string `json:"version"`
	ResType string `json:"resourceType"`
	Ns      string `json:"namespace,omitempty"`
	ResName string `json:"name,omitempty"`
}

type KubernetesInputSpec interface {
	InputSpec

	// ApiGroup returns the API group (e.g., "apps", "")
	ApiGroup() string

	// Version returns the API version (e.g., "v1", "v1beta1")
	Version() string

	// ResourceType returns the resource type (e.g., "pods", "configmaps")
	ResourceType() string

	// Namespace returns the namespace to search in (empty for cluster-scoped)
	Namespace() string

	// Name returns the specific resource name (empty for all resources)
	Name() string
}

type Logger interface {
	Debug(msg string, args ...interface{})
	Info(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
	Error(msg string, args ...interface{})
}

type ResourceFetcher interface {
	FetchResources(ctx context.Context, rule Rule, variables []CelVariable) (map[string]interface{}, []string, error)
}

type Rule interface {
	// Identifier returns a unique identifier for this rule
	Identifier() string

	// Type returns the rule type (CEL, Rego, etc.)
	Type() RuleType

	// Inputs returns the list of inputs needed for evaluation
	Inputs() []Input

	// Metadata returns optional rule metadata for compliance reporting
	Metadata() *RuleMetadata

	// Content returns the rule-specific content (expression, policy, etc.)
	Content() interface{}
}

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

type RuleMetadata struct {
	Name        string                 `json:"name,omitempty"`
	Description string                 `json:"description,omitempty"`
	Extensions  map[string]interface{} `json:"extensions,omitempty"`
}

type RuleType string

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

type ScanConfig struct {
	Rules                   []Rule        `json:"rules"`
	Variables               []CelVariable `json:"variables"`
	ApiResourcePath         string        `json:"apiResourcePath"`
	EnableDebugLogging      bool          `json:"enableDebugLogging"`
	ValidateBeforeExecution bool          `json:"validateBeforeExecution"` // Validate rules before running them
}

type ScanEnvironment struct {
}

type ScanLogger interface {
	// Debug logs debug information
	Debug(msg string, args ...interface{})

	// Info logs informational messages
	Info(msg string, args ...interface{})

	// Error logs error messages
	Error(msg string, args ...interface{})
}

type ScanResult struct {
	// RuleID is the identifier of the rule that was evaluated
	RuleID string

	// Status indicates the result of the evaluation
	Status ScanStatus

	// Message provides additional context about the result
	Message string

	// Details contains any additional result data
	Details map[string]interface{}
}

type ScanStatus string

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

type SystemInput struct {
	Service string   `json:"service,omitempty"`
	Cmd     string   `json:"command,omitempty"`
	CmdArgs []string `json:"args,omitempty"`
}

type SystemInputSpec interface {
	InputSpec

	// ServiceName returns the system service name
	ServiceName() string

	// Command returns the command to execute (alternative to service)
	Command() string

	// Args returns command arguments
	Args() []string
}

type ValidationErrorType string

type ValidationIssue struct {
	// Type is the type of validation error
	Type ValidationErrorType `json:"type"`

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

	// Details provides additional context about the error
	Details string `json:"details,omitempty"`

	// Location provides position information if available
	Location *IssueLocation `json:"location,omitempty"`
}

type ValidationResult struct {
	// Valid indicates whether the rule is valid
	Valid bool `json:"valid"`

	// Issues contains any validation issues found
	Issues []ValidationIssue `json:"issues,omitempty"`

	// Warnings contains non-fatal warnings
	Warnings []string `json:"warnings,omitempty"`
}