renderer

type AffectedResourcesSummary struct {
	Total       int `json:"total"`
	WithChanges int `json:"withChanges"`
	Unchanged   int `json:"unchanged"`
	WithErrors  int `json:"withErrors"`
	// FilteredByPolicy counts XRs excluded because of a Manual compositionUpdatePolicy
	// (FilterReasonManualPolicy).
	FilteredByPolicy int `json:"filteredByPolicy,omitempty"`
	// FilteredBySelector counts XRs excluded because their compositionRevisionSelector does not match
	// the diffed composition's labels (FilterReasonRevisionSelectorMismatch). Kept separate from
	// FilteredByPolicy so the breakdown is visible even in default-discovery mode, where individual
	// XR impacts are not surfaced.
	FilteredBySelector int `json:"filteredBySelector,omitempty"`
}

type ChangeDetail struct {
	Type       string         `json:"type"`
	APIVersion string         `json:"apiVersion"`
	Kind       string         `json:"kind"`
	Name       string         `json:"name"`
	Namespace  string         `json:"namespace,omitempty"`
	Diff       map[string]any `json:"diff"`
}

type CompDiffOutput struct {
	Compositions []CompositionDiff
	Errors       []dt.OutputError // top-level errors (e.g., XRs that failed impact analysis)
}

type CompDiffRenderer interface {
	// RenderCompDiff renders the complete composition diff output.
	// Top-level and tool errors go to DiffOptions.Stderr and are included in
	// structured output payloads. Per-composition messages (diffs, "no changes",
	// per-composition errors) go to DiffOptions.Stdout as part of the diff narrative.
	RenderCompDiff(output *CompDiffOutput) error
}

type CompactDiffFormatter struct{}

type CompositionDiff struct {
	Name              string
	Error             error            // per-composition error (nil if successful)
	CompositionDiff   *dt.ResourceDiff // the actual composition diff (nil if unchanged)
	AffectedResources AffectedResourcesSummary
	ImpactAnalysis    []XRImpact
}

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

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

type DiffFormatter interface {
	Format(diffs []diffmatchpatch.Diff, options DiffOptions) string
}

type DiffOptions struct {
	// Stdout is the writer for diff output (defaults to os.Stdout)
	Stdout io.Writer

	// Stderr is the writer for error output (defaults to os.Stderr)
	// Errors are written here following Unix conventions (errors to stderr, output to stdout)
	Stderr io.Writer

	// Format specifies the output format (diff, json, yaml)
	Format OutputFormat

	// UseColors determines whether to colorize the output
	UseColors bool

	// AddPrefix is the prefix for added lines (default "+")
	AddPrefix string

	// DeletePrefix is the prefix for deleted lines (default "-")
	DeletePrefix string

	// ContextPrefix is the prefix for unchanged lines (default " ")
	ContextPrefix string

	// ContextLines is the number of unchanged lines to show before/after changes in compact mode
	ContextLines int

	// ChunkSeparator is the string used to separate chunks in compact mode
	ChunkSeparator string

	// Compact determines whether to show a compact diff
	Compact bool

	// IgnorePaths is a list of paths to ignore when calculating diffs
	// Supports both simple paths (e.g., "metadata.annotations") and
	// map key paths (e.g., "metadata.annotations[key.name/value]")
	IgnorePaths []string

	// MinimizeComposition collapses composition changes to a single marker line
	// per composition, omitting the full YAML diff body. Only consumed by the
	// human-readable composition diff renderer; structured output is unaffected.
	MinimizeComposition bool
}

type DiffRenderer interface {
	// RenderDiffs formats and outputs diffs, grouped by input XR.
	// Diff output goes to DiffOptions.Stdout, errors go to DiffOptions.Stderr.
	// The errs parameter contains the union of resource processing errors to
	// include in output (the top-level/global error list).
	RenderDiffs(groups []dt.XRDiffGroup, errs []dt.OutputError) error
}

type DownstreamChanges struct {
	Summary Summary        `json:"summary"`
	Changes []ChangeDetail `json:"changes"`
}

type FilterReason string

type FullDiffFormatter struct{}

type OutputError = dt.OutputError

type OutputFormat string

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

type StructuredDiffOutput struct {
	// Summary is the aggregate change count across every input XR.
	Summary Summary `json:"summary"`

	// Changes is the flat, ungrouped list of all resource changes across every
	// input XR.
	//
	// Deprecated: use Xrs for per-input-XR grouping. This field is retained for
	// backward compatibility and will be removed in a future major release.
	Changes []ChangeDetail `json:"changes"`

	// Errors is the union of resource-processing errors across all input XRs
	// (the top-level/global error list). Each errored XR also surfaces its
	// error inside its own Xrs entry; this list stays complete for consumers
	// that read errors here.
	Errors []dt.OutputError `json:"errors,omitempty"`

	// Xrs groups changes by the input XR/claim that produced them, one entry
	// per input in input order. This is the recommended view; the flat Changes
	// field above is deprecated.
	Xrs []xrDiffWire `json:"xrs"`
}

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

type Summary struct {
	Added    int `json:"added"`
	Modified int `json:"modified"`
	Removed  int `json:"removed"`
}

type XRImpact struct {
	corev1.ObjectReference

	Status XRStatus
	// FilterReason explains a Status == XRStatusFiltered outcome; empty otherwise.
	FilterReason FilterReason
	// FilterDetail is an optional human-readable explanation for a filtered outcome (e.g. which
	// selector failed to match which labels), surfaced to help users self-diagnose the exclusion.
	FilterDetail string
	Error        error                       // store actual error, not string
	Diffs        map[string]*dt.ResourceDiff // downstream diffs (nil if unchanged/error)
}

type XRStatus string