dataplane

type AppliedOperation struct {
	// Type is the operation type: "create", "update", or "delete"
	Type string

	// Section is the configuration section: "backend", "server", "frontend", "acl", "http-rule", etc.
	Section string

	// Resource is the resource name or identifier (e.g., backend name, server name)
	Resource string

	// Description is a human-readable description of what was changed
	Description string
}

type AuxiliaryFiles struct {
	// GeneralFiles contains general-purpose files (error pages, custom response files, etc.)
	GeneralFiles []auxiliaryfiles.GeneralFile

	// SSLCertificates contains SSL certificates to sync to HAProxy SSL storage
	SSLCertificates []auxiliaryfiles.SSLCertificate

	// SSLCaFiles contains SSL CA certificate files for client/backend certificate verification
	SSLCaFiles []auxiliaryfiles.SSLCaFile

	// MapFiles contains map files for backend routing and other map-based features
	MapFiles []auxiliaryfiles.MapFile

	// CRTListFiles contains crt-list files for SSL certificate lists with per-certificate options
	CRTListFiles []auxiliaryfiles.CRTListFile
}

type Capabilities = client.Capabilities

type Client struct {
	// Endpoint contains connection information
	Endpoint Endpoint
	// contains filtered or unexported fields
}

type ConfigParser interface {
	ParseFromString(config string) (*parserconfig.StructuredConfig, error)
}

type ConnectionError struct {
	// Endpoint is the URL that failed to connect
	Endpoint string

	// Cause is the underlying connection error
	Cause error
}

type DiffDetails struct {
	// Total operation counts
	TotalOperations int
	Creates         int
	Updates         int
	Deletes         int

	// Global and defaults changes
	GlobalChanged   bool
	DefaultsChanged bool

	// Frontend changes
	FrontendsAdded    []string
	FrontendsModified []string
	FrontendsDeleted  []string

	// Backend changes
	BackendsAdded    []string
	BackendsModified []string
	BackendsDeleted  []string

	// Backend diff fields: for each modified backend, the BackendBase fields that differ.
	// Only populated when backend attribute changes (not nested collections) cause the update.
	BackendDiffFields map[string][]string

	// Server changes (map of backend -> server names)
	ServersAdded    map[string][]string
	ServersModified map[string][]string
	ServersDeleted  map[string][]string

	// Auxiliary file changes
	MapsAdded            int
	MapsModified         int
	MapsDeleted          int
	SSLCertsAdded        int
	SSLCertsModified     int
	SSLCertsDeleted      int
	SSLCaFilesAdded      int
	SSLCaFilesModified   int
	SSLCaFilesDeleted    int
	GeneralFilesAdded    int
	GeneralFilesModified int
	GeneralFilesDeleted  int
}

type Endpoint struct {
	// URL is the Dataplane API endpoint (e.g., "http://haproxy:5555/v3").
	// A trailing "/v2" or "/v3" is stripped before the v3 version-detection probe;
	// only v3.x operations are supported (no v2-only endpoints).
	URL string

	// Username for basic authentication
	Username string

	// Password for basic authentication
	Password string

	// PodName is the Kubernetes pod name (for observability)
	PodName string

	// PodNamespace is the Kubernetes pod namespace (for observability)
	PodNamespace string

	// Version info (cached after discovery admission, avoids redundant /v3/info calls)
	// Zero values indicate version not yet detected.
	DetectedMajorVersion int    // Major version (e.g., 3)
	DetectedMinorVersion int    // Minor version (e.g., 2)
	DetectedFullVersion  string // Full version string (e.g., "v3.2.6 87ad0bcf")
}

type HAProxyExecutor interface {
	// Version returns the combined output of `haproxy -v`.
	Version() (string, error)
	// Check runs `haproxy <args...>` with the working directory set to
	// workDir and returns the combined output. The working directory
	// matters: semantic validation invokes haproxy with a relative config
	// path so that relative file references inside the config resolve.
	Check(workDir string, args ...string) ([]byte, error)
}

type ParseError struct {
	// ConfigType indicates which config failed: "current" or "desired"
	ConfigType string

	// ConfigSnippet contains the first 200 characters of the problematic config
	ConfigSnippet string

	// Cause is the underlying parsing error
	Cause error
}

type PathConfig struct {
	// MapsDir is the base path for HAProxy map files (e.g., /etc/haproxy/maps).
	MapsDir string

	// SSLDir is the base path for HAProxy SSL certificates (e.g., /etc/haproxy/ssl).
	SSLDir string

	// GeneralDir is the base path for HAProxy general files (e.g., /etc/haproxy/general).
	GeneralDir string

	// ConfigFile is the path to the HAProxy configuration file (e.g., /tmp/haproxy.cfg).
	// Only used in validation contexts; can be empty for production paths.
	ConfigFile string
}

type ResolvedPaths struct {
	// MapsDir is the resolved path for HAProxy map files.
	MapsDir string

	// SSLDir is the resolved path for HAProxy SSL certificates.
	SSLDir string

	// CRTListDir is the resolved path for CRT-list files.
	// Always equals GeneralDir because CRT-list files are stored as general files
	// to avoid reload on create (native CRT-list API doesn't support skip_reload).
	CRTListDir string

	// GeneralDir is the resolved path for HAProxy general files.
	GeneralDir string

	// ConfigFile is the path to the HAProxy configuration file.
	ConfigFile string
}

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

type SyncError struct {
	// Stage indicates where the failure occurred. Common values:
	//   "connect", "parse-current", "parse-desired",
	//   "compare", "compare_files", "compare_ssl", "compare_ssl_ca", "compare_maps", "compare_crtlists",
	//   "sync_ssl_pre", "sync_ssl_ca_pre", "sync_files_pre", "sync_maps_pre",
	//   "apply", "commit", "reload_verification", "auxiliary_reload_verification",
	//   "fallback"
	Stage string

	// Message provides a detailed error description
	Message string

	// Cause is the underlying error that caused the failure
	Cause error

	// Hints provides actionable suggestions for fixing the problem
	Hints []string
}

type SyncMode string

type SyncOptions struct {
	// Timeout for the entire sync operation (default: 2 minutes)
	Timeout time.Duration

	// VerifyReload enables async reload verification after sync (default: true)
	// When true, polls the reload status endpoint until succeeded/failed/timeout.
	// Disable for dry-run or when reload verification is not needed.
	VerifyReload bool

	// ReloadVerificationTimeout is the maximum time to wait for reload verification (default: 10s)
	// This should be set higher than the DataPlane API's reload-delay setting.
	// Only used when VerifyReload is true.
	ReloadVerificationTimeout time.Duration

	// PreParsedConfig is an optional pre-parsed desired configuration. When
	// non-nil, sync skips parsing the desiredConfig string.
	PreParsedConfig *parserconfig.StructuredConfig

	// CachedCurrentConfig is an optional cached parsed current configuration
	// from a previous sync. When set with CachedConfigVersion, sync calls
	// GetVersion() first and reuses the cached config if the version matches.
	CachedCurrentConfig *parserconfig.StructuredConfig

	// CachedConfigVersion is the expected config version on the pod. Only
	// used when CachedCurrentConfig is also set.
	CachedConfigVersion int64

	// ContentChecksum is the pre-computed checksum of the desired config +
	// aux files. When it matches LastDeployedChecksum, the expensive aux
	// file comparison is skipped because the desired state is identical
	// to what was last deployed.
	ContentChecksum string

	// LastDeployedChecksum is the content checksum from the last successful
	// sync to this endpoint. Drift prevention syncs leave this empty.
	LastDeployedChecksum string

	// RestampVersionHeader (SyncRuntimeFast only) re-writes the pushed body
	// WITH a `# _version=N` header after a successful pure-runtime apply, via
	// one versioned skip_reload push. A skip_version push leaves the on-disk
	// config headerless, and sync() refuses to trust an empty diff against a
	// headerless config (it forces a reload to activate potentially parked
	// content). Re-stamping proves "disk == running state" so the next
	// structural sync stays reload-free.
	//
	// Callers must set this ONLY when no structural deploy can be in flight
	// on the pod (the deployer's authoritative runtime-raw lane dispatch).
	// A fast-track partial apply racing an in-flight structural reload must
	// leave the config headerless: its `set server` actions can land on the
	// worker the reload replaces, and a re-stamped header would let the next
	// sync trust an empty diff over that lost update.
	RestampVersionHeader bool
}

type SyncPhase int

type SyncResult struct {
	// Success indicates whether the sync completed successfully
	Success bool

	// AppliedOperations contains structured information about operations that were applied
	AppliedOperations []AppliedOperation

	// ReloadTriggered indicates whether a HAProxy reload was triggered
	// true when commit status is 202, false when 200
	ReloadTriggered bool

	// ReloadID is the reload identifier from the Reload-ID response header
	// Only set when ReloadTriggered is true
	ReloadID string

	// ReloadVerified indicates whether the reload was verified as successful.
	// Only set when VerifyReload option is enabled and ReloadTriggered is true.
	ReloadVerified bool

	// ReloadVerificationError contains an error message if reload verification failed.
	// This includes timeout errors or explicit reload failures from HAProxy.
	ReloadVerificationError string

	// SyncMode indicates which sync strategy was used.
	// See SyncMode* constants for possible values.
	SyncMode SyncMode

	// Duration of the sync operation
	Duration time.Duration

	// Details contains detailed diff information
	// This field is always populated regardless of SyncMode
	Details DiffDetails

	// Message provides additional context about the result
	Message string

	// PostSyncVersion is the config version on the pod after a successful sync.
	// Callers can cache this alongside the desired parsed config to skip
	// redundant GetRawConfiguration() + parse on subsequent syncs when the
	// pod's version hasn't changed. Zero means version was not captured.
	//
	// Never carries 1: version 1 is the headerless sentinel — a config
	// written by a skip_version push (the runtime bypass) has no
	// `# _version=N` header and GetVersion reads it as 1 regardless of
	// body, so 1 cannot discriminate states and must never be cached
	// (see fetchCurrentConfig). The runtime fast path (SyncRuntimeFast)
	// deliberately leaves PostSyncVersion zero and PostSyncParsedConfig
	// nil: it is fetch-free by design, and its skip_version push strips
	// the version header, forcing the next versioned sync to take a
	// cache miss and re-fetch the pod's actual state.
	PostSyncVersion int64

	// PostSyncParsedConfig is the pod's actual configuration AFTER the sync
	// completed, fetched and parsed from the dataplane API. Set only when
	// AppliedOperations is non-empty AND the post-sync fetch+parse
	// succeeded; nil otherwise (no-changes paths, or fetch/parse failure —
	// callers fall back to the desired config in those cases).
	//
	// Callers should cache this in preference to their input desired config:
	// incremental dataplane patches don't guarantee byte-identity with the
	// caller's intent (different starting baselines across pods produce
	// logically-equivalent-but-byte-different end states). Caching the
	// actual post-sync state lets subsequent drift checks compare apples to
	// apples — the comparator sees pod-actual vs desired, not
	// desired vs desired.
	PostSyncParsedConfig *parserconfig.StructuredConfig
}

type ValidationError struct {
	// Phase indicates which validation phase failed: "syntax" or "semantic"
	Phase string

	// Message is the validation error message
	Message string

	// Cause is the underlying error
	Cause error
}

type ValidationPaths struct {
	// TempDir is the root temp directory for validation files.
	// The validator is responsible for cleaning this up after validation completes.
	// This prevents race conditions where the renderer's cleanup runs before
	// the async validator can use the validation files.
	TempDir           string
	MapsDir           string
	SSLCertsDir       string
	CRTListDir        string // Directory for CRT-list files (may differ from SSLCertsDir on HAProxy < 3.2)
	GeneralStorageDir string
	ConfigFile        string
}

type Version = client.Version