events

type BecameLeaderEvent struct {
	Identity string
	// contains filtered or unexported fields
}

type ConfigAppliedToPodEvent struct {
	RuntimeConfigName      string
	RuntimeConfigNamespace string
	PodName                string
	PodNamespace           string
	PodUID                 string
	PodRuntimeID           string
	Checksum               string

	// IsDriftCheck indicates whether this was a drift prevention check (GET-only)
	// or an actual sync operation (POST/PUT/DELETE).
	//
	// True:  Drift check - no actual changes were made, just verified config is current
	// False: Actual sync - configuration was written to HAProxy
	IsDriftCheck bool

	// SyncMetadata contains detailed information about the sync operation.
	// Only populated for actual syncs (IsDriftCheck=false).
	SyncMetadata *SyncMetadata
	// contains filtered or unexported fields
}

type ConfigInvalidEvent struct {
	Version string

	// TemplateConfig is the original HAProxyTemplateConfig CRD.
	// Type: any to avoid circular dependencies.
	// Used by status updater to set validation errors on the CRD status.
	TemplateConfig any

	// ValidationErrors maps validator names to their error messages.
	ValidationErrors map[string][]string

	// VerdictSequence is as on ConfigValidatedEvent.
	VerdictSequence uint64

	// Sources names every config of the merged set, in merge order.
	Sources []ConfigSourceRef
	// contains filtered or unexported fields
}

type ConfigParsedEvent struct {
	// Config contains the parsed configuration.
	// Type: any to avoid circular dependencies.
	// Consumers should type-assert to their expected config type.
	Config any

	// TemplateConfig is the original HAProxyTemplateConfig CRD.
	// Type: any to avoid circular dependencies.
	// Needed by ConfigPublisher to extract Kubernetes metadata (name, namespace, UID).
	TemplateConfig any

	// Version is the resourceVersion of the HAProxyTemplateConfig CRD.
	Version string

	// SecretVersion is the resourceVersion of the credentials Secret.
	SecretVersion string

	// Sources names every config of the merged set, in merge order.
	Sources []ConfigSourceRef
	// contains filtered or unexported fields
}

type ConfigPublishedEvent struct {
	RuntimeConfigName      string
	RuntimeConfigNamespace string
	MapFileCount           int
	SecretCount            int
	// contains filtered or unexported fields
}

type ConfigResourceChangedEvent struct {
	// Resource contains the raw HAProxyTemplateConfig CRD resource.
	// Type: any to avoid circular dependencies.
	// Consumers should type-assert to *unstructured.Unstructured.
	Resource any
	// contains filtered or unexported fields
}

type ConfigSourceRef struct {
	Namespace       string
	Name            string
	Generation      int64
	UID             types.UID
	ResourceVersion string
}

type ConfigValidatedEvent struct {
	Config any

	// TemplateConfig is the original HAProxyTemplateConfig CRD.
	// Type: any to avoid circular dependencies.
	// Needed by ConfigPublisher to extract Kubernetes metadata (name, namespace, UID).
	TemplateConfig any

	Version       string
	SecretVersion string

	// CandidateGeneration identifies a live config-change validation owned by
	// ConfigChangeHandler. Zero denotes state published outside that handler.
	CandidateGeneration uint64

	// ActiveSnapshotRestore replays the running iteration's state after a newer
	// parsed generation retires an accepted candidate. State consumers apply it;
	// validation and reload consumers must not treat it as a new verdict.
	ActiveSnapshotRestore bool

	// VerdictSequence orders the verdicts one iteration reaches on the
	// configuration: a larger value is newer, and zero is not a verdict.
	VerdictSequence uint64

	// Sources names every config of the merged set, in merge order.
	Sources []ConfigSourceRef
	// contains filtered or unexported fields
}

type ConfigValidationInconclusiveEvent struct {
	Version        string
	TemplateConfig any
	// Reasons maps validator names to why they could not reach a verdict.
	Reasons map[string][]string
	RetryIn time.Duration
	// VerdictSequence is as on ConfigValidatedEvent.
	VerdictSequence uint64
	Sources         []ConfigSourceRef
	// contains filtered or unexported fields
}

type ConfigValidationRequest struct {

	// Config contains the configuration to validate.
	Config any

	// Version is the resourceVersion being validated.
	Version string
	// contains filtered or unexported fields
}

type ConfigValidationResponse struct {

	// ValidatorName identifies which validator produced this response (basic, template, jsonpath).
	ValidatorName string

	// Valid is true if this validator found no errors.
	Valid bool

	// Errors contains validation error messages, empty if Valid is true.
	Errors []string

	// Inconclusive means the validator could not judge the config (for
	// example, schemas were unavailable); Errors then say why. Never set
	// together with Valid.
	Inconclusive bool
	// contains filtered or unexported fields
}

type ConfigVerdict interface {
	busevents.Event
	// contains filtered or unexported methods
}

type ConfigVerdictReplayedEvent struct {
	Verdict ConfigVerdict
	// contains filtered or unexported fields
}

type CorrelatedEvent interface {
	// EventID returns a unique identifier for this specific event.
	// Each event instance has its own unique EventID.
	// This is used as the CausationID for downstream events.
	EventID() string

	// CorrelationID returns a unique identifier that links related events.
	// All events in the same reconciliation cycle share the same correlation ID.
	// Returns empty string if correlation is not set.
	CorrelationID() string

	// CausationID returns the EventID of the event that triggered this one.
	// This enables building causal chains for debugging.
	// Returns empty string if causation is not set.
	CausationID() string
}

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

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

type CredentialsUpdatedEvent struct {
	// Credentials contains the validated credentials.
	// Type: any to avoid circular dependencies.
	// Consumers should type-assert to their expected credentials type.
	Credentials any

	// SecretVersion is the resourceVersion of the Secret.
	SecretVersion string
	// contains filtered or unexported fields
}

type DeployPhases struct {
	Pod         string
	PrepareMs   int64 // the deployment before any pod was contacted
	SettleMs    int64 // the deployment after the last pod answered
	TotalMs     int64 // the whole apply, state read to result
	StateMs     int64 // reading the agent's state
	DiffMs      int64 // composing the decision
	SendMs      int64 // the apply round trips, upload included
	BlobWaitMs  int64 // waiting for the plan blob's encode before the apply that carries it
	UploadBytes int64 // file content sent, which the agent had not proved
	Agent       api.ApplyTiming
}

type DeployedConfigPublishRequest struct {
	CycleSnapshot          *rendercycle.Snapshot
	OutputSnapshot         *renderoutput.Snapshot
	RuntimeConfigName      string
	RuntimeConfigNamespace string
	Config                 string
	AuxiliaryFiles         *dataplane.AuxiliaryFiles
	ContentChecksum        string
	ConfirmedPod           *v1.PodDeploymentStatus
	// contains filtered or unexported fields
}

type DeploymentCancelRequestEvent struct {
	// DeploymentID identifies the exact DeploymentScheduledEvent to cancel.
	DeploymentID string

	// Reason describes why the deployment is being cancelled.
	Reason string

	Correlation
	// contains filtered or unexported fields
}

type DeploymentCompletedEvent struct {

	// CycleSnapshot is the exact render cycle this deployment applied.
	CycleSnapshot *rendercycle.Snapshot

	// OutputSnapshot is the exact render this deployment applied.
	OutputSnapshot *renderoutput.Snapshot

	// DeploymentID identifies the exact DeploymentScheduledEvent that finished.
	DeploymentID string

	Total              int // Total number of instances
	Succeeded          int // Number of successful deployments
	Failed             int // Number of failed deployments
	PendingReloads     int // Pods holding the render behind a paced reload
	PendingReloadUntil time.Time
	DurationMs         int64 // Total deployment duration in milliseconds
	ReloadsTriggered   int   // Count of instances that triggered HAProxy reload
	TotalAPIOperations int   // Sum of API operations across all instances
	// Phases is the slowest accepted pod's split of DurationMs; nil when no
	// pod accepted.
	Phases *DeployPhases

	// OperationBreakdown provides a generic breakdown of operations performed.
	// Keys are formatted as "section_type" (e.g., "backend_create", "server_update", "global_update").
	// Values are the count of operations of that type.
	// Aggregated across all successfully deployed instances.
	OperationBreakdown map[string]int

	// BackendDiffFields summarizes which BackendBase fields caused backend updates.
	// Empty when no backend attribute diffs were detected.
	// Example: "[GUID] (48 backends)" or "[Mode, Balance] (3 backends)"
	BackendDiffFields string

	// StatusPatches are the chart-rendered status patches that correspond to
	// the configuration this deployment carried. The StatusApplier reads them
	// from this event and applies the "deployed" variant — guaranteeing that
	// the status conditions it writes describe the config the data plane is
	// actually serving (no side-channel cache, no LATEST-vs-deployed race).
	//
	// Threaded through unchanged from the DeploymentScheduledEvent that
	// triggered this deployment.
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot carries the immutable patch set of this deployment.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// ContentChecksum is the checksum of the config + auxiliary files THIS
	// deployment actually pushed to the data plane. Threaded through
	// unchanged from the DeploymentScheduledEvent so the DeploymentScheduler
	// can update its lastDeployedConfigHash from a value that's tied to the
	// completing deployment, not from the latest render (which a parallel
	// reconcile may have overwritten while this deployment was in flight).
	//
	// Without this, the scheduler reads s.lastContentChecksum at completion
	// time and mis-records the in-flight render's checksum as "what was just
	// deployed" — silently making future deployments with the same hash
	// hit the unchanged-skip branch and never reach HAProxy. Symptom in CI:
	// a freshly-added Ingress's redirect/auth directive never appears in
	// the live haproxy.cfg even though the controller did render it.
	//
	// Empty string for the zero-endpoint code path (nothing was deployed).
	ContentChecksum string
	RenderProof     string
	Plan            *renderplan.Plan

	// PodSetHash identifies the endpoint authorities THIS deployment targeted.
	// It is captured from DeploymentScheduledEvent.Endpoints before execution.
	PodSetHash string

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type DeploymentResult struct {

	// CycleSnapshot is the exact render cycle this deployment applied.
	CycleSnapshot *rendercycle.Snapshot

	// OutputSnapshot is the exact render this deployment applied.
	OutputSnapshot *renderoutput.Snapshot

	// DeploymentID is the EventID of the DeploymentScheduledEvent being completed.
	DeploymentID string

	Total              int   // Total number of instances
	Succeeded          int   // Number of successful deployments
	Failed             int   // Number of failed deployments
	DurationMs         int64 // Total deployment duration in milliseconds
	ReloadsTriggered   int   // Count of instances that triggered HAProxy reload
	TotalAPIOperations int   // Sum of API operations across all instances
	// PendingReloads are pods that accepted the render but hold it behind a
	// paced reload; PendingReloadUntil is when the latest of them fires.
	PendingReloads     int
	PendingReloadUntil time.Time

	// OperationBreakdown provides a generic breakdown of operations performed.
	// Keys are formatted as "section_type" (e.g., "backend_create", "server_update", "global_update").
	// Values are the count of operations of that type.
	OperationBreakdown map[string]int

	// BackendDiffFields summarizes which BackendBase fields caused backend updates.
	// Empty when no backend attribute diffs were detected.
	BackendDiffFields string

	// StatusPatches are the chart-rendered status patches for the
	// configuration this deployment carried. Forwarded from the
	// DeploymentScheduledEvent and surfaced on DeploymentCompletedEvent for
	// the StatusApplier to consume.
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot carries the immutable patch set of this deployment.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// ContentChecksum is the checksum of the config + auxiliary files
	// THIS deployment pushed (forwarded from DeploymentScheduledEvent).
	// See DeploymentCompletedEvent.ContentChecksum for the full rationale.
	// Empty when no deployment occurred (zero-endpoint path).
	ContentChecksum string
	RenderProof     string
	Plan            *renderplan.Plan

	// PodSetHash identifies the endpoint authorities THIS deployment targeted.
	// Empty when no deployment occurred (zero-endpoint path).
	PodSetHash string

	// Phases is the slowest accepted pod's split; nil when no pod accepted.
	Phases *DeployPhases
	// contains filtered or unexported fields
}

type DeploymentScheduledEvent struct {

	// CycleSnapshot is the exact render cycle to deploy.
	CycleSnapshot *rendercycle.Snapshot

	// OutputSnapshot is the exact render to deploy.
	OutputSnapshot *renderoutput.Snapshot

	// Config is the rendered HAProxy configuration to deploy.
	Config string

	// AuxiliaryFiles contains all rendered auxiliary files.
	AuxiliaryFiles *dataplane.AuxiliaryFiles

	// Endpoints is the list of HAProxy endpoints to deploy to.
	Endpoints []dataplane.Endpoint

	// RuntimeConfigName is the name of the HAProxyCfg resource.
	// Used for publishing ConfigAppliedToPodEvent after successful deployment.
	RuntimeConfigName string

	// RuntimeConfigNamespace is the namespace of the HAProxyCfg resource.
	// Used for publishing ConfigAppliedToPodEvent after successful deployment.
	RuntimeConfigNamespace string

	// ContentChecksum is the pre-computed content checksum covering config + aux files.
	// Propagated from TemplateRenderedEvent to enable aux file comparison caching
	// in the deployer — when the checksum matches the last-deployed checksum for
	// an endpoint, the expensive aux file comparison is skipped.
	ContentChecksum string

	// Reason describes why this deployment was scheduled.
	// Examples: "config_validation", "pod_discovery", "drift_prevention"
	Reason string

	// Plan is the structure of the render being deployed, propagated from
	// TemplateRenderedEvent. Nil when the render produced none.
	Plan *renderplan.Plan

	// PlanID is the digest identifying Plan; it becomes the pod's applied plan
	// id once the deployment lands.
	PlanID string

	// RenderProof is the controller-local witness for this exact render.
	RenderProof string

	// StatusPatches are the chart-rendered status patches for this
	// configuration. The Deployer forwards them unchanged into
	// DeploymentCompletedEvent so the StatusApplier can apply the
	// "deployed" variant with the patches that correspond exactly to
	// the config this deployment shipped.
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot carries the immutable patch set for this configuration.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type DeploymentSkippedEvent struct {

	// CycleSnapshot is the exact render cycle already served by the fleet.
	CycleSnapshot *rendercycle.Snapshot

	// OutputSnapshot is the exact render already served by the fleet.
	OutputSnapshot *renderoutput.Snapshot

	// Total is the number of HAProxy endpoints already serving the rendered
	// configuration. Mirrors DeploymentCompletedEvent.Total so subscribers
	// can apply the same "is there actually a data plane to talk to?" guard.
	Total int

	// Reason is a short tag describing why no deployment ran for this
	// config: SkipReasonConfigUnchanged or SkipReasonReloadObserved.
	Reason string

	// ConfigHash is the content checksum of the rendered HAProxy
	// configuration that matched the last successful deployment. Useful
	// for debugging / correlation across the deployer's logs.
	ConfigHash string

	// PodSetHash is the hash of the endpoint set that matched the last
	// successful deployment. Useful for debugging / correlation.
	PodSetHash string

	// StatusPatches are the chart-rendered status patches for the
	// already-deployed configuration. The StatusApplier reads them from
	// this event to write the "deployed" variant — the data plane is
	// serving this exact config, so conditions gated on data-plane
	// readiness should reflect the current generation.
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot carries the immutable patch set already deployed.
	StatusPatchSnapshot *templating.StatusPatchSnapshot
	RenderProof         string
	Plan                *renderplan.Plan

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type DeploymentStartedEvent struct {
	// EndpointCount is the number of HAProxy instances this deploy targets.
	// Only the count is carried: subscribers (statecache, commentator) never
	// read more than len(), and carrying the full slice forced a defensive
	// deep-copy of every endpoint's address and credentials on each publish.
	EndpointCount int

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type DriftPreventionTriggeredEvent struct {
	// TimeSinceLastDeployment is the duration since the last deployment completed.
	TimeSinceLastDeployment time.Duration
	// contains filtered or unexported fields
}

type HAProxyPodRejectedEvent struct {
	// PodName is the rejected pod's name (used for correlation with
	// k8s events / pod logs).
	PodName string
	// Reason categorises the rejection. Stable identifiers used as a
	// Prometheus label, so prefer a fixed enum:
	//   - "version_mismatch_older" — the probed version is older than supported
	//   - "version_mismatch_newer" — the probed version is newer than supported
	//   - "version_check_failed"   — could not probe remote version (transient)
	Reason string
	// contains filtered or unexported fields
}

type HAProxyPodTerminatedEvent struct {
	PodName      string
	PodNamespace string
	PodUID       string
	// contains filtered or unexported fields
}

type HAProxyPodsDiscoveredEvent struct {
	// Endpoints is the list of discovered HAProxy pods, by their agent endpoint.
	Endpoints []dataplane.Endpoint
	Count     int
	// contains filtered or unexported fields
}

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

type HTTPContentRejectedEvent struct {
	URL string // Credentials, query, and fragment are redacted.
	// contains filtered or unexported fields
}

type HTTPContentRevokedEvent struct {
	URL             string // The URL whose content was revoked (credentials redacted)
	ContentChecksum string // SHA256 checksum of the revoked content
	Restored        bool   // The URL went back to its previous accepted content
	Critical        bool   // Renders fail until the URL has accepted content again
	// contains filtered or unexported fields
}

type HTTPResourceAcceptedEvent struct {
	URL             string // The URL whose content was accepted
	ContentChecksum string // SHA256 checksum of accepted content
	ContentSize     int    // Size of accepted content in bytes
	// contains filtered or unexported fields
}

type HTTPResourceUpdatedEvent struct {
	URL             string // The URL that was refreshed
	ContentChecksum string // SHA256 checksum of new content
	ContentSize     int    // Size of new content in bytes
	// contains filtered or unexported fields
}

type IndexSynchronizedEvent struct {
	// ResourceCounts maps resource types to their counts.
	ResourceCounts map[string]int
	// contains filtered or unexported fields
}

type InputRejection struct {
	Object  corev1.ObjectReference
	Deleted bool
	Reason  string
}

type InstanceDeploymentFailedEvent struct {
	Endpoint  any
	Error     string
	Retryable bool // Whether this failure is retryable

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type LeaderElectionStartedEvent struct {
	Identity       string
	LeaseName      string
	LeaseNamespace string
	// contains filtered or unexported fields
}

type LibrarySetChangedEvent struct {
	// Snippets holds the raw HAProxyTemplateLibrary resources.
	// Type: []any to avoid circular dependencies.
	// Consumers should type-assert elements to *unstructured.Unstructured.
	Snippets []any
	// contains filtered or unexported fields
}

type LostLeadershipEvent struct {
	Identity string
	Reason   string // graceful_shutdown, lease_expired, etc.
	// contains filtered or unexported fields
}

type NewLeaderObservedEvent struct {
	NewLeaderIdentity string
	IsSelf            bool // true if this replica is the new leader
	// contains filtered or unexported fields
}

type OperationCounts struct {
	// Config operations
	TotalAPIOperations int
	BackendsAdded      int
	BackendsRemoved    int
	BackendsModified   int
	ServersAdded       int
	ServersRemoved     int
	ServersModified    int
	FrontendsAdded     int
	FrontendsRemoved   int
	FrontendsModified  int

	// Auxiliary file operations
	MapsAdded            int
	MapsRemoved          int
	MapsModified         int
	SSLCertsAdded        int
	SSLCertsRemoved      int
	SSLCertsModified     int
	GeneralFilesAdded    int
	GeneralFilesRemoved  int
	GeneralFilesModified int
}

type ProposalValidationCompletedEvent struct {
	// RequestID correlates this response to the original request.
	RequestID string

	// Valid is true if the proposed configuration passed all validation phases.
	Valid bool

	// Phase indicates which validation phase failed (syntax, schema, semantic).
	// Empty if Valid is true.
	Phase string

	// Error contains the validation error message if Valid is false.
	// Empty if Valid is true.
	Error string

	// DurationMs is the total validation duration in milliseconds.
	DurationMs int64
	// contains filtered or unexported fields
}

type ProposalValidationRequestedEvent struct {
	// ID uniquely identifies this validation request for response correlation.
	ID string

	// Overlays maps store names to their proposed changes.
	// The ProposalValidator will create a CompositeStoreProvider using these.
	// Key: store name (e.g., "ingresses", "services")
	// Value: proposed changes for that store
	Overlays map[string]*stores.StoreOverlay

	// HTTPOverlay contains pending HTTP content changes for validation.
	// When present, the ProposalValidator includes this in the ValidationContext
	// so the render pipeline sees pending HTTP content.
	// Nil when validating K8s-only changes (e.g., webhook admission).
	HTTPOverlay stores.HTTPContentOverlay

	// Source identifies where this request originated from.
	// Examples: "httpstore", "webhook"
	Source string

	// SourceContext provides additional context about the source.
	// For httpstore: resource URL
	// For webhook: resource GVK and namespace/name
	SourceContext string
	// contains filtered or unexported fields
}

type ReconciliationCompletedEvent struct {
	DurationMs int64

	// CycleSnapshot binds the complete output and effects of this reconciliation.
	CycleSnapshot *rendercycle.Snapshot

	// RenderProof identifies this occurrence of the authenticated cycle.
	RenderProof string

	// RenderedResources are the Kubernetes resources the templates declared
	// under spec.k8sResources in this cycle. The
	// ResourceApplier reads them directly from the event so it stays
	// stateless on the success path — patches/resources travel with the
	// event that triggers their apply, never via a side-channel cache. May
	// be nil when the render didn't emit any K8s resources.
	RenderedResources []templating.RenderedResource

	// RenderedResourceSnapshot is the authenticated immutable production representation.
	RenderedResourceSnapshot *templating.RenderedResourceSnapshot

	// StatusPatches are the chart-rendered status patches of this cycle.
	// The ResourceApplier forwards them on ResourcesAppliedEvent after its
	// apply pass so the StatusApplier writes the "rendered" variant only
	// AFTER the same render's infrastructure resources exist (conditions
	// must describe materialized state — conformance's GatewayInfrastructure
	// lists labeled resources the moment Accepted turns True).
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot is the authenticated immutable production representation.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// Events are the Kubernetes Events templates asked to emit this cycle via
	// recordEvent() (e.g. a RouteConflict Warning on an Ingress). The
	// EventEmitter (leader-only) reads them directly off this event and emits
	// them via an EventRecorder. May be nil when no template recorded an event.
	// The publisher sets this from a cloned slice before Publish; treat as
	// read-only like every other event field.
	Events []templating.RenderedEvent

	// EventSnapshot is the authenticated immutable production representation.
	EventSnapshot *templating.RenderedEventSnapshot

	// PlanID is the render this cycle produced, so a consumer can pair the
	// cycle with the render gate's later verdict on it.
	PlanID string

	// ProfileCount is the number of distinct backend profiles this render
	// emitted, harvested from the plan. The metrics component sets the
	// haptic_render_profiles gauge from it. Zero when the render produced no plan.
	ProfileCount int

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type ReconciliationFailedEvent struct {
	Error string
	Phase string // Which phase failed: "render", "validate", "deploy"

	// DurationMs is how long the failed cycle ran.
	DurationMs int64

	// StatusPatches are the chart-rendered status patches from the most
	// recent SUCCESSFUL render (the failure itself rarely produces patches —
	// render failures have none; validation failures have the just-rendered
	// set). The StatusApplier reads them to write the renderFailed /
	// deployFailed variant on the affected resources. May be nil if no
	// successful render has happened yet (early bootstrap failures); the
	// applier handles nil gracefully by skipping the apply.
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot is the most recent successful immutable patch set.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type ReconciliationStartedEvent struct {
	// Trigger describes what triggered this reconciliation.
	Trigger string

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type ReconciliationTriggeredEvent struct {
	// Reason describes why reconciliation was triggered.
	// Examples: "debounce_timer", "config_change", "manual_trigger"
	Reason string

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type RenderGateCompletedEvent struct {

	// CycleSnapshot identifies the exact output and effects judged by the gate.
	CycleSnapshot *rendercycle.Snapshot

	// OutputSnapshot identifies the exact complete render judged by the gate.
	OutputSnapshot *renderoutput.Snapshot

	// PlanID is the render this verdict describes.
	PlanID string

	// RenderProof identifies the exact render instance this verdict describes.
	RenderProof string

	// Plan carries the exact controller-local render identity.
	Plan *renderplan.Plan

	// OK is true when the check passed.
	OK bool

	// Refused distinguishes HAProxy's own verdict from a gate that could not
	// run at all (no binary, unwritable temp tree). Only a refusal is evidence
	// about the config, so only a refusal reverts the fleet.
	Refused bool

	// Newest reports that this verdict describes the render the fleet is
	// converging on, rather than a superseded plan some pod still runs. The
	// gate checks both; only the newest one may move the latch, the pinned
	// gauge, the conditions or the validated plan, because every consumer of
	// those has already moved past a straggler. A straggler's verdict still
	// travels: it is what scopes the revert to the pods carrying it.
	Newest bool

	// Message is HAProxy's own words on a refusal, or the reason the gate
	// could not run. Empty on a pass.
	Message string

	// Pinned reports that renders are held until one passes: the gate is in
	// its pessimistic state and the fleet stays on the last config it accepted.
	Pinned bool

	// DurationMs is how long the check took.
	DurationMs int64

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type ResourceIndexUpdatedEvent struct {
	// ResourceTypeName identifies the watched resource type as configured in
	// spec.watchedResources (the plural form, e.g. "services").
	ResourceTypeName string

	// ChangeStats provides detailed change statistics including Created, Modified, Deleted counts
	// and whether this event occurred during initial sync.
	ChangeStats types.ChangeStats
	// contains filtered or unexported fields
}

type ResourceSyncCompleteEvent struct {
	// ResourceTypeName identifies the resource type from config (e.g., "ingresses").
	ResourceTypeName string

	// InitialCount is the number of resources loaded during initial sync.
	InitialCount int
	// contains filtered or unexported fields
}

type ResourcesAppliedEvent struct {

	// CycleSnapshot is the exact cycle whose resources now exist.
	CycleSnapshot *rendercycle.Snapshot

	// RenderProof identifies this occurrence of the authenticated cycle.
	RenderProof string

	// StatusPatches forwarded from the ReconciliationCompletedEvent that
	// triggered the apply pass.
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot forwards the immutable patch set from the same cycle.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type ResourcesProcessedEvent struct {
	Correlation
	// contains filtered or unexported fields
}

type RetainedConfigEvent struct {
	Namespace string
	Name      string
	UID       string
	Reason    string
	Message   string
	// contains filtered or unexported fields
}

type SecretResourceChangedEvent struct {
	// Resource contains the raw Secret resource.
	// Type: any to avoid circular dependencies.
	// Consumers should type-assert to *unstructured.Unstructured or *corev1.Secret.
	Resource any
	// contains filtered or unexported fields
}

type StatusPatchPhase string

type StatusUpdateCompletedEvent struct {
	// Phase identifies which pipeline phase triggered this status update.
	Phase StatusPatchPhase

	// AppliedCount is the number of status patches successfully applied.
	AppliedCount int

	// SkippedCount is the number of status patches skipped (checksum match).
	SkippedCount int

	// DurationMs is the total duration of status patch application.
	DurationMs int64

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type StatusUpdateFailedEvent struct {
	// Namespace is the namespace of the target Kubernetes resource.
	Namespace string

	// Name is the name of the target Kubernetes resource.
	Name string

	// GVR is the GroupVersionResource string of the target resource (e.g., "networking.k8s.io/v1/ingresses").
	GVR string

	// Error is the error message from the failed SSA patch.
	Error string

	// Retriable indicates whether the failure is transient and can be retried.
	Retriable bool

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type SyncMetadata struct {
	// ReloadTriggered indicates whether HAProxy was reloaded during this sync.
	// Reload path triggers a reload; runtime path doesn't.
	ReloadTriggered bool

	// SyncDuration is how long the sync operation took.
	SyncDuration time.Duration

	// OperationCounts provides a breakdown of operations performed.
	OperationCounts OperationCounts

	// AppliedPlanID is the render plan the pod accepted in this sync.
	AppliedPlanID      string
	AppliedPlanProof   string
	AppliedRenderProof string

	// RunningPlanID is the render plan the pod's running HAProxy serves after
	// this sync. It trails AppliedPlanID while a reload is still pending.
	RunningPlanID    string
	RunningPlanProof string

	// Mode is how the plan was applied: runtime, file_only, reload, scheduled,
	// noop or rejected. Empty until the agent reports it.
	Mode string

	// Reasons explain Mode, most significant first.
	Reasons []string

	// Error contains the error message if sync failed.
	// Empty string indicates success.
	Error string
}

type TemplateRenderFailedEvent struct {
	// TemplateName is the name of the template that failed to render.
	TemplateName string

	// Error is the error message.
	Error string

	// StackTrace provides additional debugging context.
	StackTrace string

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type TemplateRenderedEvent struct {

	// CycleSnapshot binds this output to every effect from the same render.
	CycleSnapshot *rendercycle.Snapshot

	// OutputSnapshot binds the exact config, plan, and auxiliary artifacts.
	OutputSnapshot *renderoutput.Snapshot

	// HAProxyConfig is the rendered main HAProxy configuration.
	// Uses relative paths (maps/, ssl/, files/) that work with HAProxy's `default-path origin`.
	HAProxyConfig string

	// AuxiliaryFiles contains all rendered auxiliary files (maps, certificates, general files).
	AuxiliaryFiles *dataplane.AuxiliaryFiles

	// AuxiliaryFileSnapshot is the authenticated immutable production representation.
	AuxiliaryFileSnapshot *renderartifact.Snapshot

	// StatusPatches contains status patches registered by templates during rendering.
	// Each patch targets a Kubernetes resource and contains outcome-keyed variants
	// for different pipeline lifecycle phases (rendered, deployed, renderFailed, deployFailed).
	StatusPatches []templating.StatusPatch

	// StatusPatchSnapshot is the authenticated immutable production representation.
	StatusPatchSnapshot *templating.StatusPatchSnapshot

	// RenderedResources contains full Kubernetes resources the templates declared
	// the controller should own and reconcile (e.g. an auxiliary Service or other
	// object a template emits alongside the HAProxy config). The applier compares
	// each against the last-applied checksum and skips unchanged entries to avoid
	// hammering the API server.
	RenderedResources []templating.RenderedResource

	// ContentChecksum is the pre-computed content checksum covering config + aux files.
	// Computed once in the pipeline and propagated to downstream consumers to avoid
	// redundant hashing in config publisher and deployment scheduler.
	ContentChecksum string

	// Plan is the structure this render declared, carried to the deployer so it
	// can diff against what each pod applied. Nil for renders that produced none.
	Plan *renderplan.Plan

	// PlanID is the digest identifying Plan.
	PlanID string

	// RenderProof identifies this render instance inside one controller process.
	RenderProof string

	// Metrics for observability
	ConfigBytes        int   // Size of HAProxyConfig
	AuxiliaryFileCount int   // Number of auxiliary files
	DurationMs         int64 // Total rendering duration

	// TriggerReason is the reason that triggered this reconciliation.
	// Propagated from ReconciliationTriggeredEvent.Reason.
	// Examples: "config_change", "debounce_timer", "drift_prevention"
	// Used by downstream components (e.g., DeploymentScheduler) to determine fallback behavior.
	TriggerReason string

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type ValidationFailedEvent struct {
	Errors     []string // Validation errors from HAProxy
	DurationMs int64

	// TriggerReason is the reason that triggered this reconciliation.
	// Propagated from TemplateRenderedEvent.TriggerReason.
	// Examples: "config_change", "debounce_timer", "drift_prevention"
	// Used by DeploymentScheduler to determine fallback behavior (deploy cached config on drift prevention).
	TriggerReason string

	// Correlation embeds correlation tracking for event tracing.
	Correlation
	// contains filtered or unexported fields
}

type WatchedInputsRejectedEvent struct {
	Rejections []InputRejection
	// contains filtered or unexported fields
}