events

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

type ConfigAppliedToPodEvent struct {
	RuntimeConfigName      string
	RuntimeConfigNamespace string
	PodName                string
	PodNamespace           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
	// 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
	// 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 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
	// 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
	// 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 CredentialsInvalidEvent struct {
	SecretVersion string
	Error         string
	// 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 DeployedConfigPublishRequest struct {
	RuntimeConfigName      string
	RuntimeConfigNamespace string
	Config                 string
	AuxiliaryFiles         *dataplane.AuxiliaryFiles
	ContentChecksum        string
	// contains filtered or unexported fields
}

type DeploymentCancelRequestEvent struct {
	// Reason describes why the deployment is being cancelled.
	Reason string

	Correlation
	// contains filtered or unexported fields
}

type DeploymentCompletedEvent struct {
	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

	// 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

	// 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

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

type DeploymentResult struct {
	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

	// 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

	// 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
}

type DeploymentScheduledEvent struct {
	// Config is the rendered HAProxy configuration to deploy.
	Config string

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

	// ParsedConfig is the pre-parsed desired configuration from validation.
	// May be nil if validation cache was used.
	// When non-nil, passed to sync operations to skip redundant parsing.
	ParsedConfig *parser.StructuredConfig

	// 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 (Dataplane API downloads) is skipped.
	ContentChecksum string

	// Reason describes why this deployment was scheduled.
	// Examples: "config_validation", "pod_discovery", "drift_prevention"
	Reason 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

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

type DeploymentSkippedEvent struct {
	// 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 the deployment was skipped.
	// Currently always "config_unchanged"; left as a string to leave room
	// for future skip causes (e.g. "drift_check_only") without an event
	// schema change.
	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

	// 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" — remote HAProxy is older than local
	//   - "version_mismatch_newer" — remote HAProxy is newer than local
	//   - "version_check_failed"   — could not probe remote version (transient)
	Reason string
	// contains filtered or unexported fields
}

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

type HAProxyPodsDiscoveredEvent struct {
	// Endpoints is the list of discovered HAProxy Dataplane API endpoints.
	Endpoints []dataplane.Endpoint
	Count     int
	// 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 HTTPResourceRejectedEvent struct {
	URL             string // The URL whose content was rejected
	ContentChecksum string // SHA256 checksum of rejected content
	Reason          string // Why the content was rejected
	// 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 InstanceDeployedEvent struct {
	Endpoint       any // The HAProxy endpoint that was deployed to
	DurationMs     int64
	ReloadRequired bool // Whether this deployment required a HAProxy reload

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

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 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

	// 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

	// 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

	// 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"

	// 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

	// 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 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 {
	// StatusPatches forwarded from the ReconciliationCompletedEvent that
	// triggered the apply pass.
	StatusPatches []templating.StatusPatch

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

type RuntimeFastPathResultEvent struct {
	// ServerUpdates is the number of runtime-eligible server updates applied to
	// the live worker on this fire (0 = fired, nothing to do).
	ServerUpdates int
	// Failed is true when the apply errored. Best-effort: the scheduled deploy
	// is the correctness floor and converges the pod regardless.
	Failed bool
	// 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

	// ReloadID is the reload identifier from HAProxy dataplane API.
	// Only populated when ReloadTriggered is true.
	ReloadID string

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

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

	// 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 {
	// 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

	// 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

	// 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

	// 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 ValidationCompletedEvent struct {
	Warnings   []string // Non-fatal warnings from HAProxy validation
	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 on validation failure.
	TriggerReason string

	// ParsedConfig is the pre-parsed desired configuration from syntax validation.
	// May be nil if validation cache was used.
	// When non-nil, can be passed to downstream sync operations to avoid re-parsing.
	ParsedConfig *parser.StructuredConfig

	// 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
}