tflint

type BuiltinRuleSet struct {
	// Name is the ruleset name (e.g., "azurerm").
	Name string
	// Version is the ruleset version (e.g., "0.1.0").
	Version string
	// Constraint is the tfbreak version constraint (e.g., ">= 0.1.0").
	Constraint string
	// Rules is the list of rules in this ruleset.
	Rules []Rule
	// contains filtered or unexported fields
}

type Config struct {
	// Rules maps rule names to their configuration.
	Rules map[string]*RuleConfig
	// DisabledByDefault indicates if rules are disabled by default.
	// When true, rules must be explicitly enabled.
	DisabledByDefault bool
	// Only enables only these rules if set.
	// Takes precedence over individual rule configurations.
	Only []string
	// PluginDir is the directory where plugins are installed.
	PluginDir string
}

type DefaultRule struct{}

type ExpandMode int

type GetModuleContentHint struct {
	// ResourceType hints at the expected resource type for optimization.
	ResourceType string
}

type GetModuleContentOption struct {
	// ModuleCtx specifies which module context to use.
	ModuleCtx ModuleCtxType
	// ExpandMode specifies how to handle dynamic blocks.
	ExpandMode ExpandMode
	// Hint provides hints for optimization.
	Hint GetModuleContentHint
}

type ModuleCtxType int

type Rule interface {
	// Name returns the unique name of the rule.
	// Convention: lowercase with underscores (e.g., "azurerm_force_new").
	Name() string

	// Enabled returns whether the rule is enabled by default.
	// Most rules return true; embed DefaultRule for this behavior.
	Enabled() bool

	// Severity returns the default severity level for issues.
	// Most rules return ERROR; embed DefaultRule for this behavior.
	Severity() Severity

	// Link returns a URL to documentation about the rule.
	// Should explain what the rule checks and how to resolve issues.
	Link() string

	// Check executes the rule against the configurations accessible via runner.
	// Call runner.EmitIssue() for each finding.
	// Return an error only for unexpected failures, not for findings.
	Check(runner Runner) error
}

type RuleConfig struct {
	// Name is the rule name.
	Name string
	// Enabled indicates if the rule is enabled.
	Enabled bool
	// Body is the raw HCL body for rule-specific configuration.
	// Rules can decode this using runner.DecodeRuleConfig().
	Body hcl.Body
}

type RuleSet interface {
	// RuleSetName returns the name of the ruleset (e.g., "azurerm").
	RuleSetName() string

	// RuleSetVersion returns the version of the ruleset (e.g., "0.1.0").
	RuleSetVersion() string

	// RuleNames returns the names of all rules in this ruleset.
	RuleNames() []string

	// VersionConstraint returns the tfbreak version constraint (e.g., ">= 0.1.0").
	VersionConstraint() string

	// ConfigSchema returns the schema for plugin-specific configuration.
	// Return nil if no configuration is needed.
	ConfigSchema() *hclext.BodySchema

	// ApplyGlobalConfig applies global tfbreak configuration.
	// Called before ApplyConfig.
	ApplyGlobalConfig(*Config) error

	// ApplyConfig applies plugin-specific configuration.
	// The content matches the schema from ConfigSchema().
	ApplyConfig(*hclext.BodyContent) error

	// NewRunner optionally wraps the runner with custom behavior.
	// Return the runner unchanged if no customization is needed.
	NewRunner(Runner) (Runner, error)

	// BuiltinImpl returns the embedded BuiltinRuleSet.
	// Used internally for rule iteration.
	BuiltinImpl() *BuiltinRuleSet
}

type Runner interface {
	// GetOldModuleContent retrieves module content from the OLD (baseline) configuration.
	// Use this to access the state before the change.
	GetOldModuleContent(schema *hclext.BodySchema, opts *GetModuleContentOption) (*hclext.BodyContent, error)

	// GetNewModuleContent retrieves module content from the NEW configuration.
	// Use this to access the state after the change.
	GetNewModuleContent(schema *hclext.BodySchema, opts *GetModuleContentOption) (*hclext.BodyContent, error)

	// GetOldResourceContent retrieves resources of a specific type from the OLD configuration.
	// This is a convenience method that filters module content for a specific resource type.
	//
	// Example:
	//
	//	content, err := runner.GetOldResourceContent("azurerm_resource_group", &hclext.BodySchema{
	//	    Attributes: []hclext.AttributeSchema{
	//	        {Name: "location", Required: true},
	//	    },
	//	}, nil)
	GetOldResourceContent(resourceType string, schema *hclext.BodySchema, opts *GetModuleContentOption) (*hclext.BodyContent, error)

	// GetNewResourceContent retrieves resources of a specific type from the NEW configuration.
	// This is a convenience method that filters module content for a specific resource type.
	//
	// Example:
	//
	//	content, err := runner.GetNewResourceContent("azurerm_resource_group", &hclext.BodySchema{
	//	    Attributes: []hclext.AttributeSchema{
	//	        {Name: "location", Required: true},
	//	    },
	//	}, nil)
	GetNewResourceContent(resourceType string, schema *hclext.BodySchema, opts *GetModuleContentOption) (*hclext.BodyContent, error)

	// EmitIssue reports a finding from the rule.
	// The issueRange should point to the relevant location in the NEW configuration.
	// For breaking changes, this is typically where the problematic change was made.
	//
	// Example:
	//
	//	if oldLocation != newLocation {
	//	    runner.EmitIssue(rule, "location: ForceNew attribute changed", newAttr.Range)
	//	}
	EmitIssue(rule Rule, message string, issueRange hcl.Range) error

	// DecodeRuleConfig retrieves and decodes the rule's configuration.
	// The target should be a pointer to a struct with hcl tags.
	// Returns nil if no configuration is provided for the rule.
	//
	// Example:
	//
	//	type MyRuleConfig struct {
	//	    IgnorePatterns []string `hcl:"ignore_patterns,optional"`
	//	}
	//	var config MyRuleConfig
	//	if err := runner.DecodeRuleConfig("my_rule", &config); err != nil {
	//	    return err
	//	}
	DecodeRuleConfig(ruleName string, target any) error
}

type Severity int