v1alpha1

type CinderDatasource struct {
	// The type of resource to sync.
	Type CinderDatasourceType `json:"type"`
}

type CinderDatasourceType string

type CommittedResourceAllocation struct {
	// Timestamp when this workload was assigned to the reservation.
	// +kubebuilder:validation:Required
	CreationTimestamp metav1.Time `json:"creationTimestamp"`

	// Resources consumed by this instance.
	// +kubebuilder:validation:Required
	Resources map[hv1.ResourceName]resource.Quantity `json:"resources"`
}

type CommittedResourceReservationSpec struct {
	// ResourceName is the name of the resource to reserve. (e.g. flavor name for Nova)
	// +kubebuilder:validation:Optional
	ResourceName string `json:"resourceName,omitempty"`

	// CommitmentUUID is the UUID of the commitment that this reservation corresponds to.
	// +kubebuilder:validation:Optional
	CommitmentUUID string `json:"commitmentUUID,omitempty"`

	// ResourceGroup is the group/category of the resource (e.g., flavor group for Nova)
	// +kubebuilder:validation:Optional
	ResourceGroup string `json:"resourceGroup,omitempty"`

	// +kubebuilder:validation:Optional
	ProjectID string `json:"projectID,omitempty"`

	// +kubebuilder:validation:Optional
	DomainID string `json:"domainID,omitempty"`

	// Creator identifies the system or component that created this reservation.
	// Used to track ownership and for cleanup purposes (e.g., "commitments-syncer").
	// +kubebuilder:validation:Optional
	Creator string `json:"creator,omitempty"`

	// Allocations maps workload identifiers to their allocation details.
	// Key: Workload UUID (VM UUID for Nova, Pod UID for Pods, Machine UID for IronCore, etc.)
	// Value: allocation state and metadata
	// +kubebuilder:validation:Optional
	Allocations map[string]CommittedResourceAllocation `json:"allocations,omitempty"`
}

type CommittedResourceReservationStatus struct {
	// Allocations maps VM/instance UUIDs to the host they are currently running on.
	// Key: VM/instance UUID, Value: Host name where the VM is currently running.
	// +kubebuilder:validation:Optional
	Allocations map[string]string `json:"allocations,omitempty"`
}

type CurrentDecision struct {
	// The timestamp of when the decision was made.
	Timestamp metav1.Time `json:"timestamp"`
	// The pipeline that was used for the decision.
	PipelineRef corev1.ObjectReference `json:"pipelineRef"`
	// The intent of the decision (e.g., initial scheduling, rescheduling, etc.).
	Intent SchedulingIntent `json:"intent"`
	// Whether the scheduling decision was successful.
	Successful bool `json:"successful"`
	// The target host selected for the resource. nil when no host was found.
	// +kubebuilder:validation:Optional
	TargetHost *string `json:"targetHost,omitempty"`
	// A human-readable explanation of the scheduling decision.
	// +kubebuilder:validation:Optional
	Explanation string `json:"explanation,omitempty"`
	// The top hosts ordered by score (limited to 3).
	// +kubebuilder:validation:Optional
	// +kubebuilder:validation:MaxItems=3
	OrderedHosts []string `json:"orderedHosts,omitempty"`
}

type Datasource struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec defines the desired state of Datasource
	// +required
	Spec DatasourceSpec `json:"spec"`

	// status defines the observed state of Datasource
	// +optional
	Status DatasourceStatus `json:"status,omitempty,omitzero"`
}

type DatasourceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Datasource `json:"items"`
}

type DatasourceSpec struct {
	// SchedulingDomain defines in which scheduling domain this datasource
	// is used (e.g., nova, cinder, manila).
	SchedulingDomain SchedulingDomain `json:"schedulingDomain"`

	// If given, configures a Prometheus datasource to fetch.
	// Type must be set to "prometheus" if this is used.
	// +kubebuilder:validation:Optional
	Prometheus PrometheusDatasource `json:"prometheus"`
	// If given, configures an OpenStack datasource to fetch.
	// Type must be set to "openstack" if this is used.
	// +kubebuilder:validation:Optional
	OpenStack OpenStackDatasource `json:"openstack,omitempty"`

	// The type of the datasource.
	Type DatasourceType `json:"type"`

	// Database credentials to use for the datasource.
	// The secret should contain the following keys:
	// - "username": The database username.
	// - "password": The database password.
	// - "host": The database host.
	// - "port": The database port.
	// - "database": The database name.
	DatabaseSecretRef corev1.SecretReference `json:"databaseSecretRef"`

	// Kubernetes secret ref for an optional sso certificate to access the host.
	// The secret should contain two keys: "cert" and "key".
	// +kubebuilder:validation:Optional
	SSOSecretRef *corev1.SecretReference `json:"ssoSecretRef,omitempty"`
}

type DatasourceStatus struct {
	// When the datasource was last successfully synced.
	LastSynced metav1.Time `json:"lastSynced,omitempty"`
	// The number of objects currently stored for this datasource.
	NumberOfObjects int64 `json:"numberOfObjects,omitempty"`
	// Planned time for the next sync.
	NextSyncTime metav1.Time `json:"nextSyncTime,omitempty"`

	// The current status conditions of the datasource.
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
}

type DatasourceType string

type Decision struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec defines the desired state of Decision
	// +required
	Spec DecisionSpec `json:"spec"`

	// status defines the observed state of Decision
	// +optional
	Status DecisionStatus `json:"status,omitempty,omitzero"`
}

type DecisionList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Decision `json:"items"`
}

type DecisionResult struct {
	// Raw input weights to the pipeline.
	// +kubebuilder:validation:Optional
	RawInWeights map[string]float64 `json:"rawInWeights"`
	// Normalized input weights to the pipeline.
	// +kubebuilder:validation:Optional
	NormalizedInWeights map[string]float64 `json:"normalizedInWeights"`
	// Outputs of the decision pipeline including the activations used
	// to make the final ordering of compute hosts.
	// +kubebuilder:validation:Optional
	StepResults []StepResult `json:"stepResults,omitempty"`
	// Aggregated output weights from the pipeline.
	// +kubebuilder:validation:Optional
	AggregatedOutWeights map[string]float64 `json:"aggregatedOutWeights"`
	// Final ordered list of hosts from most preferred to least preferred.
	// +kubebuilder:validation:Optional
	OrderedHosts []string `json:"orderedHosts,omitempty"`
	// The first element of the ordered hosts is considered the target host.
	// +kubebuilder:validation:Optional
	TargetHost *string `json:"targetHost,omitempty"`
}

type DecisionSpec struct {
	// SchedulingDomain defines in which scheduling domain this decision
	// was or is processed (e.g., nova, cinder, manila).
	SchedulingDomain SchedulingDomain `json:"schedulingDomain"`

	// A reference to the pipeline that should be used for this decision.
	// This reference can be used to look up the pipeline definition and its
	// scheduler step configuration for additional context.
	PipelineRef corev1.ObjectReference `json:"pipelineRef"`

	// An identifier for the underlying resource to be scheduled.
	// For example, this can be the UUID of a nova instance or cinder volume.
	// This can be used to correlate multiple decisions for the same resource.
	ResourceID string `json:"resourceID"`

	// If the type is "nova", this field contains the raw nova decision request.
	// +kubebuilder:validation:Optional
	NovaRaw *runtime.RawExtension `json:"novaRaw,omitempty"`
	// If the type is "cinder", this field contains the raw cinder decision request.
	// +kubebuilder:validation:Optional
	CinderRaw *runtime.RawExtension `json:"cinderRaw,omitempty"`
	// If the type is "manila", this field contains the raw manila decision request.
	// +kubebuilder:validation:Optional
	ManilaRaw *runtime.RawExtension `json:"manilaRaw,omitempty"`
	// If the type is "machine", this field contains the machine reference.
	// +kubebuilder:validation:Optional
	MachineRef *corev1.ObjectReference `json:"machineRef,omitempty"`
	// If the type is "pod", this field contains the pod reference.
	// +kubebuilder:validation:Optional
	PodRef *corev1.ObjectReference `json:"podRef,omitempty"`

	// The intent of the scheduling decision (e.g., initial scheduling, rescheduling, etc.).
	// +kubebuilder:validation:Optional
	Intent SchedulingIntent `json:"intent,omitempty"`
}

type DecisionStatus struct {
	// The result of this decision.
	// +kubebuilder:validation:Optional
	Result *DecisionResult `json:"result,omitempty"`

	// If there were previous decisions for the underlying resource, they can
	// be resolved here to provide historical context for the decision.
	// +kubebuilder:validation:Optional
	History *[]corev1.ObjectReference `json:"history,omitempty"`

	// The number of decisions that preceded this one for the same resource.
	// +kubebuilder:validation:Optional
	Precedence *int `json:"precedence,omitempty"`

	// A human-readable explanation of the decision result.
	// +kubebuilder:validation:Optional
	Explanation string `json:"explanation,omitempty"`

	// The current status conditions of the decision.
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
}

type Descheduling struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec defines the desired state of Descheduling
	// +required
	Spec DeschedulingSpec `json:"spec"`

	// status defines the observed state of Descheduling
	// +optional
	Status DeschedulingStatus `json:"status,omitempty,omitzero"`
}

type DeschedulingList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Descheduling `json:"items"`
}

type DeschedulingSpec struct {
	// A reference to the virtual machine that should be descheduled.
	Ref string `json:"ref,omitempty"`
	// The type of reference used to identify the virtual machine.
	RefType DeschedulingSpecVMReferenceType `json:"refType,omitempty"`
	// The name of the compute host from which the virtual machine should be descheduled.
	PrevHost string `json:"prevHost,omitempty"`
	// The type of host from which the virtual machine should be descheduled.
	PrevHostType DeschedulingSpecHostType `json:"prevHostType,omitempty"`
	// The human-readable reason why the VM should be descheduled.
	Reason string `json:"reason,omitempty"`
}

type DeschedulingSpecHostType string

type DeschedulingSpecVMReferenceType string

type DeschedulingStatus struct {
	// The current status conditions of the descheduling.
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
	// The name of the compute host where the VM was rescheduled to.
	NewHost string `json:"newHost,omitempty"`
	// The type of host where the VM was rescheduled to.
	NewHostType DeschedulingSpecHostType `json:"newHostType,omitempty"`
}

type DetectorSpec struct {
	// The name of the scheduler step in the cortex implementation.
	// Must match to a step implemented by the pipeline controller.
	Name string `json:"name"`

	// Additional configuration for the step that can be used
	// +kubebuilder:validation:Optional
	Params Parameters `json:"params,omitempty"`

	// Additional description of the step which helps understand its purpose
	// and decisions made by it.
	// +kubebuilder:validation:Optional
	Description string `json:"description,omitempty"`
}

type FailoverReservationSpec struct {
	// ResourceGroup is the group/category of the resource (e.g., "hana_medium_v2").
	// +kubebuilder:validation:Optional
	ResourceGroup string `json:"resourceGroup,omitempty"`
}

type FailoverReservationStatus struct {
	// Allocations maps VM/instance UUIDs to the host they are currently allocated on.
	// Key: VM/instance UUID, Value: Host name where the VM is currently running.
	// +kubebuilder:validation:Optional
	Allocations map[string]string `json:"allocations,omitempty"`

	// LastChanged tracks when the reservation was last modified.
	// This is used to track pending changes that need acknowledgment.
	// +kubebuilder:validation:Optional
	LastChanged *metav1.Time `json:"lastChanged,omitempty"`

	// AcknowledgedAt is the timestamp when the last change was acknowledged.
	// When nil, the reservation is in a pending state awaiting acknowledgment.
	// This does not affect the Ready condition - reservations are still considered
	// ready even when not yet acknowledged.
	// +kubebuilder:validation:Optional
	AcknowledgedAt *metav1.Time `json:"acknowledgedAt,omitempty"`
}

type FilterSpec struct {
	// The name of the scheduler step in the cortex implementation.
	// Must match to a step implemented by the pipeline controller.
	Name string `json:"name"`

	// Additional configuration for the step that can be used
	// +kubebuilder:validation:Optional
	Params Parameters `json:"params,omitempty"`

	// Additional description of the step which helps understand its purpose
	// and decisions made by it.
	// +kubebuilder:validation:Optional
	Description string `json:"description,omitempty"`
}

type History struct {
	metav1.TypeMeta `json:",inline"`

	// Standard object metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec defines the desired state of History.
	// +required
	Spec HistorySpec `json:"spec"`
	// Status defines the observed state of History.
	// +optional
	Status HistoryStatus `json:"status,omitempty"`
}

type HistoryList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []History `json:"items"`
}

type HistorySpec struct {
	// The scheduling domain this object with the history belongs to.
	SchedulingDomain SchedulingDomain `json:"schedulingDomain"`
	// The resource ID this history belongs to (e.g., the UUID of a nova instance).
	ResourceID string `json:"resourceID"`
	// The availability zone of the resource, if known. Only set for scheduling
	// domains that provide AZ information (e.g., Nova).
	// +kubebuilder:validation:Optional
	AvailabilityZone *string `json:"availabilityZone,omitempty"`
}

type HistoryStatus struct {
	// Current represents the latest scheduling decision with full context.
	// +kubebuilder:validation:Optional
	Current CurrentDecision `json:"current,omitempty"`
	// History of past scheduling decisions (limited to last 10).
	// +kubebuilder:validation:Optional
	History []SchedulingHistoryEntry `json:"history,omitempty"`

	// Conditions represent the latest available observations of the history's state.
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
}

type IdentityDatasource struct {
	// The type of resource to sync.
	Type IdentityDatasourceType `json:"type"`
}

type IdentityDatasourceType string

type KPI struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec defines the desired state of KPI
	// +required
	Spec KPISpec `json:"spec"`

	// status defines the observed state of KPI
	// +optional
	Status KPIStatus `json:"status,omitempty,omitzero"`
}

type KPIDependenciesSpec struct {
	// Datasources required for extracting this kpi.
	// +kubebuilder:validation:Optional
	Datasources []corev1.ObjectReference `json:"datasources,omitempty"`

	// Knowledges this kpi depends on.
	// +kubebuilder:validation:Optional
	Knowledges []corev1.ObjectReference `json:"knowledges,omitempty"`
}

type KPIList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []KPI `json:"items"`
}

type KPISpec struct {
	// SchedulingDomain defines in which scheduling domain this kpi
	// is used (e.g., nova, cinder, manila).
	SchedulingDomain SchedulingDomain `json:"schedulingDomain"`

	// The name of the kpi in the cortex implementation.
	Impl string `json:"impl"`
	// Additional configuration for the extractor that can be used
	// +kubebuilder:validation:Optional
	Opts runtime.RawExtension `json:"opts,omitempty"`
	// Dependencies required for extracting this kpi.
	// +kubebuilder:validation:Optional
	Dependencies KPIDependenciesSpec `json:"dependencies"`
	// Additional description of the kpi which helps understand its purpose
	// and decisions made by it.
	// +kubebuilder:validation:Optional
	Description string `json:"description,omitempty"`
}

type KPIStatus struct {
	// How many dependencies have been reconciled.
	ReadyDependencies int `json:"readyDependencies"`
	// Total number of dependencies configured.
	TotalDependencies int `json:"totalDependencies"`
	// "ReadyDependencies / TotalDependencies ready" as a human-readable string
	// or "ready" if there are no dependencies configured.
	DependenciesReadyFrac string `json:"dependenciesReadyFrac,omitempty"`

	// The current status conditions of the kpi.
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
}

type Knowledge struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec defines the desired state of Knowledge
	// +required
	Spec KnowledgeSpec `json:"spec"`

	// status defines the observed state of Knowledge
	// +optional
	Status KnowledgeStatus `json:"status,omitempty,omitzero"`
}

type KnowledgeDependenciesSpec struct {
	// Datasources required for extracting this knowledge.
	// If provided, all datasources must have the same database secret reference
	// so the knowledge can be joined across multiple database tables.
	// +kubebuilder:validation:Optional
	Datasources []corev1.ObjectReference `json:"datasources,omitempty"`

	// Other knowledges this knowledge depends on.
	// +kubebuilder:validation:Optional
	Knowledges []corev1.ObjectReference `json:"knowledges,omitempty"`
}

type KnowledgeExtractorSpec struct {
	// The name of the extractor.
	Name string `json:"name,omitempty"`

	// Additional configuration for the extractor.
	// +kubebuilder:validation:Optional
	Config runtime.RawExtension `json:"config"`
}

type KnowledgeList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Knowledge `json:"items"`
}

type KnowledgeSpec struct {
	// SchedulingDomain defines in which scheduling domain this knowledge
	// is used (e.g., nova, cinder, manila).
	SchedulingDomain SchedulingDomain `json:"schedulingDomain"`

	// The feature extractor to use for extracting this knowledge.
	Extractor KnowledgeExtractorSpec `json:"extractor,omitempty"`

	// The desired recency of this knowledge, i.e. how old it can be until
	// it needs to be re-extracted.
	// +kubebuilder:default="60s"
	Recency metav1.Duration `json:"recency"`

	// A human-readable description of the knowledge to be extracted.
	// +kubebuilder:validation:Optional
	Description string `json:"description,omitempty"`

	// Dependencies required for extracting this knowledge.
	// +kubebuilder:validation:Optional
	Dependencies KnowledgeDependenciesSpec `json:"dependencies"`
}

type KnowledgeStatus struct {
	// When the knowledge was last successfully extracted.
	// +kubebuilder:validation:Optional
	LastExtracted metav1.Time `json:"lastExtracted"`

	// When the extracted knowledge content last changed.
	// Updated only when the Raw data actually changes, not on every reconcile.
	// +kubebuilder:validation:Optional
	LastContentChange metav1.Time `json:"lastContentChange,omitempty"`

	// The raw data behind the extracted knowledge, e.g. a list of features.
	// +kubebuilder:validation:Optional
	Raw runtime.RawExtension `json:"raw"`
	// The number of features extracted, or 1 if the knowledge is not a list.
	// +kubebuilder:validation:Optional
	RawLength int `json:"rawLength,omitempty"`

	// The current status conditions of the knowledge.
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
}

type LimesDatasource struct {
	// The type of resource to sync.
	Type LimesDatasourceType `json:"type"`
}

type LimesDatasourceType string

type ManilaDatasource struct {
	// The type of resource to sync.
	Type ManilaDatasourceType `json:"type"`
}

type ManilaDatasourceType string

type NovaDatasource struct {
	// The type of resource to sync.
	Type NovaDatasourceType `json:"type"`
	// Time frame in minutes for the changes-since parameter when fetching
	// deleted servers. Set if the Type is "deletedServers".
	DeletedServersChangesSinceMinutes *int `json:"deletedServersChangesSinceMinutes,omitempty"`
}

type NovaDatasourceType string

type OpenStackDatasource struct {
	// The type of the OpenStack datasource.
	Type OpenStackDatasourceType `json:"type"`

	// Datasource for openstack nova.
	// Only required if Type is "nova".
	// +kubebuilder:validation:Optional
	Nova NovaDatasource `json:"nova"`
	// Datasource for openstack placement.
	// Only required if Type is "placement".
	// +kubebuilder:validation:Optional
	Placement PlacementDatasource `json:"placement"`
	// Datasource for openstack manila.
	// Only required if Type is "manila".
	// +kubebuilder:validation:Optional
	Manila ManilaDatasource `json:"manila"`
	// Datasource for openstack identity.
	// Only required if Type is "identity".
	// +kubebuilder:validation:Optional
	Identity IdentityDatasource `json:"identity"`
	// Datasource for openstack limes.
	// Only required if Type is "limes".
	// +kubebuilder:validation:Optional
	Limes LimesDatasource `json:"limes"`
	// Datasource for openstack cinder.
	// Only required if Type is "cinder".
	// +kubebuilder:validation:Optional
	Cinder CinderDatasource `json:"cinder"`

	// How often to sync the datasource.
	// +kubebuilder:default="600s"
	SyncInterval metav1.Duration `json:"syncInterval"`

	// Keystone credentials secret ref for authenticating with openstack.
	// The secret should contain the following keys:
	// - "availability": The service availability, e.g. "public", "internal", or "admin".
	// - "url": The keystone auth URL.
	// - "username": The keystone username.
	// - "password": The keystone password.
	// - "userDomainName": The keystone user domain name.
	// - "projectName": The keystone project name.
	// - "projectDomainName": The keystone project domain name.
	SecretRef corev1.SecretReference `json:"secretRef"`
}

type OpenStackDatasourceType string

type Parameter struct {
	// The key of the parameter.
	// +kubebuilder:validation:Required
	Key string `json:"key"`

	// +kubebuilder:validation:Optional
	StringValue *string `json:"stringValue,omitempty"`
	// +kubebuilder:validation:Optional
	BoolValue *bool `json:"boolValue,omitempty"`
	// +kubebuilder:validation:Optional
	IntValue *int64 `json:"intValue,omitempty"`
	// +kubebuilder:validation:Optional
	FloatValue *float64 `json:"floatValue,omitempty"`
	// +kubebuilder:validation:Optional
	StringListValue *[]string `json:"stringListValue,omitempty"`
	// +kubebuilder:validation:Optional
	FloatMapValue *map[string]float64 `json:"floatMapValue,omitempty"`
}

type Parameters []Parameter

type Pipeline struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec defines the desired state of Pipeline
	// +required
	Spec PipelineSpec `json:"spec"`

	// status defines the observed state of Pipeline
	// +optional
	Status PipelineStatus `json:"status,omitempty,omitzero"`
}

type PipelineList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Pipeline `json:"items"`
}

type PipelineSpec struct {
	// SchedulingDomain defines in which scheduling domain this pipeline
	// is used (e.g., nova, cinder, manila).
	SchedulingDomain SchedulingDomain `json:"schedulingDomain"`

	// An optional description of the pipeline, helping understand its purpose.
	// +kubebuilder:validation:Optional
	Description string `json:"description,omitempty"`

	// If this pipeline should create history objects.
	// When this is false, the pipeline will still process requests.
	// +kubebuilder:default=false
	CreateHistory bool `json:"createHistory,omitempty"`

	// If this pipeline should ignore host preselection and gather all
	// available placement candidates before applying filters, instead of
	// relying on a pre-filtered set and weights.
	// +kubebuilder:default=false
	IgnorePreselection bool `json:"ignorePreselection,omitempty"`

	// The type of the pipeline, used to differentiate between
	// filter-weigher and detector pipelines within the same
	// scheduling domain.
	//
	// If the type is filter-weigher, the filter and weigher attributes
	// must be set. If the type is detector, the detectors attribute
	// must be set.
	//
	// +kubebuilder:validation:Enum=filter-weigher;detector
	Type PipelineType `json:"type"`

	// Ordered list of filters to apply in a scheduling pipeline.
	//
	// This attribute is set only if the pipeline type is filter-weigher.
	// Filters remove host candidates from an initial set, leaving
	// valid candidates. Filters are run before weighers are applied.
	// +kubebuilder:validation:Optional
	Filters []FilterSpec `json:"filters,omitempty"`

	// Ordered list of weighers to apply in a scheduling pipeline.
	//
	// This attribute is set only if the pipeline type is filter-weigher.
	// These weighers are run after filters are applied.
	// +kubebuilder:validation:Optional
	Weighers []WeigherSpec `json:"weighers,omitempty"`

	// Ordered list of detectors to apply in a descheduling pipeline.
	//
	// This attribute is set only if the pipeline type is detector.
	// Detectors find candidates for descheduling (migration off current host).
	// These detectors are run after weighers are applied.
	// +kubebuilder:validation:Optional
	Detectors []DetectorSpec `json:"detectors,omitempty"`
}

type PipelineStatus struct {
	// The current status conditions of the pipeline.
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
}

type PipelineType string

type PlacementDatasource struct {
	// The type of resource to sync.
	Type PlacementDatasourceType `json:"type"`
}

type PlacementDatasourceType string

type PrometheusDatasource struct {
	// The query to use to fetch the metric.
	Query string `json:"query"`
	// Especially when a more complex query is used, we need an alias
	// under which the table will be stored in the database.
	// Additionally, this alias is used to reference the metric in the
	// feature extractors as dependency.
	Alias string `json:"alias"`
	// The type of the metric, mapping directly to a metric model supported
	// by cortex. Note that the metrics are fetched as time series, not instant.
	Type string `json:"type"`

	// Time range to query the data for.
	// +kubebuilder:default="2419200s"
	TimeRange metav1.Duration `json:"timeRange"`
	// The interval at which to query the data.
	// +kubebuilder:default="86400s"
	Interval metav1.Duration `json:"interval"`
	// The resolution of the data.
	// +kubebuilder:default="43200s"
	Resolution metav1.Duration `json:"resolution"`

	// Secret containing the following keys:
	// - "url": The prometheus URL.
	SecretRef corev1.SecretReference `json:"secretRef"`
}

type Reservation struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty,omitzero"`

	// spec defines the desired state of Reservation
	// +required
	Spec ReservationSpec `json:"spec"`

	// status defines the observed state of Reservation
	// +optional
	Status ReservationStatus `json:"status,omitempty,omitzero"`
}

type ReservationList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Reservation `json:"items"`
}

type ReservationSpec struct {
	// Type of reservation.
	// +kubebuilder:validation:Enum=CommittedResourceReservation;FailoverReservation
	// +kubebuilder:validation:Required
	Type ReservationType `json:"type"`

	// SchedulingDomain specifies the scheduling domain for this reservation (e.g., "nova", "ironcore").
	// +kubebuilder:validation:Optional
	SchedulingDomain SchedulingDomain `json:"schedulingDomain,omitempty"`

	// AvailabilityZone specifies the availability zone for this reservation, if restricted to a specific AZ.
	// +kubebuilder:validation:Optional
	AvailabilityZone string `json:"availabilityZone,omitempty"`

	// Resources to reserve for this instance.
	// +kubebuilder:validation:Optional
	Resources map[hv1.ResourceName]resource.Quantity `json:"resources,omitempty"`

	// StartTime is the time when the reservation becomes active.
	// +kubebuilder:validation:Optional
	StartTime *metav1.Time `json:"startTime,omitempty"`

	// EndTime is the time when the reservation expires.
	// +kubebuilder:validation:Optional
	EndTime *metav1.Time `json:"endTime,omitempty"`

	// TargetHost is the desired compute host where the reservation should be placed.
	// This is a generic name that represents different concepts depending on the scheduling domain:
	// - For Nova: the hypervisor hostname
	// - For Pods: the node name
	// The scheduler will attempt to place the reservation on this host.
	// +kubebuilder:validation:Optional
	TargetHost string `json:"targetHost,omitempty"`

	// CommittedResourceReservation contains fields specific to committed resource reservations.
	// Only used when Type is CommittedResourceReservation.
	// +kubebuilder:validation:Optional
	CommittedResourceReservation *CommittedResourceReservationSpec `json:"committedResourceReservation,omitempty"`

	// FailoverReservation contains fields specific to failover reservations.
	// Only used when Type is FailoverReservation.
	// +kubebuilder:validation:Optional
	FailoverReservation *FailoverReservationSpec `json:"failoverReservation,omitempty"`
}

type ReservationStatus struct {
	// The current status conditions of the reservation.
	// Conditions include:
	// - type: Ready
	//   status: True|False|Unknown
	//   reason: ReservationReady
	//   message: Reservation is successfully scheduled
	//   lastTransitionTime: <timestamp>
	// +kubebuilder:validation:Optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`

	// Host is the actual host where the reservation is placed.
	// This is set by the scheduler after successful placement and reflects the current state.
	// It should match Spec.TargetHost when the reservation is successfully placed.
	// This is a generic name that represents different concepts depending on the scheduling domain:
	// - For Nova: the hypervisor hostname
	// - For Pods: the node name
	// +kubebuilder:validation:Optional
	Host string `json:"host,omitempty"`

	// CommittedResourceReservation contains status fields specific to committed resource reservations.
	// Only used when Type is CommittedResourceReservation.
	// +kubebuilder:validation:Optional
	CommittedResourceReservation *CommittedResourceReservationStatus `json:"committedResourceReservation,omitempty"`

	// FailoverReservation contains status fields specific to failover reservations.
	// Only used when Type is FailoverReservation.
	// +kubebuilder:validation:Optional
	FailoverReservation *FailoverReservationStatus `json:"failoverReservation,omitempty"`
}

type ReservationType string

type SchedulingDomain string

type SchedulingHistoryEntry struct {
	// The timestamp of when the decision was made.
	Timestamp metav1.Time `json:"timestamp"`
	// The pipeline that was used for the decision.
	PipelineRef corev1.ObjectReference `json:"pipelineRef"`
	// The intent of the decision (e.g., initial scheduling, rescheduling, etc.).
	Intent SchedulingIntent `json:"intent"`
	// The top hosts ordered by score for the decision (limited to 3).
	// This is not a complete list of all candidates — only the highest-ranked
	// hosts are retained to keep the history compact.
	// +kubebuilder:validation:Optional
	// +kubebuilder:validation:MaxItems=3
	OrderedHosts []string `json:"orderedHosts,omitempty"`
	// Whether the scheduling decision was successful.
	// +kubebuilder:validation:Optional
	Successful bool `json:"successful"`
}

type SchedulingIntent string

type StepResult struct {
	// object reference to the scheduler step.
	StepName string `json:"stepName"`
	// Activations of the step for each host.
	Activations map[string]float64 `json:"activations"`
}

type WeigherSpec struct {
	// The name of the scheduler step in the cortex implementation.
	// Must match to a step implemented by the pipeline controller.
	Name string `json:"name"`

	// Additional configuration for the step that can be used
	// +kubebuilder:validation:Optional
	Params Parameters `json:"params,omitempty"`

	// Additional description of the step which helps understand its purpose
	// and decisions made by it.
	// +kubebuilder:validation:Optional
	Description string `json:"description,omitempty"`

	// Optional multiplier to apply to the step's output.
	// This can be used to increase or decrease the weight of a step
	// relative to other steps in the same pipeline.
	// +kubebuilder:validation:Optional
	Multiplier *float64 `json:"multiplier,omitempty"`
}