v1alpha1

type AccessControlConfig struct {
	// +optional
	AccessControlPolicies []AccessControlPolicy `json:"accessControlPolicies,omitempty"`
}

type AccessControlPolicy struct {
	// +optional
	Username string `json:"username,omitempty"`
	// +optional
	PolicyRule PolicyRule `json:"policyRule,omitempty"`
}

type AdminQoSConfig struct {
	// ReclaimedResourceConfig is a configuration for reclaim resource
	// +optional
	ReclaimedResourceConfig *ReclaimedResourceConfig `json:"reclaimedResourceConfig,omitempty"`

	// EvictionConfig is a configuration for eviction
	// +optional
	EvictionConfig *EvictionConfig `json:"evictionConfig,omitempty"`

	// +optional
	AdvisorConfig *AdvisorConfig `json:"advisorConfig,omitempty"`
}

type AdminQoSConfiguration struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   AdminQoSConfigurationSpec `json:"spec,omitempty"`
	Status GenericConfigStatus       `json:"status,omitempty"`
}

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

type AdminQoSConfigurationSpec struct {
	GenericConfigSpec `json:",inline"`

	// Config is custom field for admin qos configuration
	Config AdminQoSConfig `json:"config"`
}

type AdvisorConfig struct {
	// +optional
	CPUAdvisorConfig *CPUAdvisorConfig `json:"cpuAdvisorConfig,omitempty"`
	// +optional
	MemoryAdvisorConfig *MemoryAdvisorConfig `json:"memoryAdvisorConfig,omitempty"`
}

type Aggregator string

type AlgorithmConfig struct {
	// Method is the method used to calculate the resource portrait.
	Method string `json:"method"`

	// Params contains a list of parameters used by the algorithm.
	// +optional
	Params map[string]string `json:"params,omitempty"`

	// TimeWindow contains the time window used by the algorithm.
	TimeWindow TimeWindow `json:"timeWindow"`

	// ResyncPeriod contains the resync period used by the algorithm.
	ResyncPeriod time.Duration `json:"resyncPeriod"`
}

type AuthConfig struct {
	// BasicAuthConfig is configuration related to basic access authentication
	// +optional
	BasicAuthConfig *BasicAuthConfig `json:"basicAuthConfig,omitempty"`

	// BasicAuthConfig is configuration about access control
	// +optional
	AccessControlConfig *AccessControlConfig `json:"accessControlConfig,omitempty"`
}

type AuthConfiguration struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   AuthConfigurationSpec `json:"spec,omitempty"`
	Status GenericConfigStatus   `json:"status,omitempty"`
}

type AuthConfigurationList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`

	Items []AuthConfiguration `json:"items"`
}

type AuthConfigurationSpec struct {
	GenericConfigSpec `json:",inline"`

	Config AuthConfig `json:"config,omitempty"`
}

type BasicAuthConfig struct {
	// UserPasswordPairs is the list of valid username and corresponding password
	// +optional
	UserPasswordPairs []UserPasswordPair `json:"userPasswordPairs,omitempty"`
}

type BlockConfig struct {
	// Labels indicates disable tmo if pods with these labels. The requirements are ORed.
	// +optional
	Labels []metav1.LabelSelectorRequirement `json:"labels,omitempty"`

	// Annotations indicates disable tmo if pods with these annotations. The requirements are ORed.
	// +optional
	Annotations []metav1.LabelSelectorRequirement `json:"annotations,omitempty"`
}

type CPUAdvisorConfig struct {
	// AllowSharedCoresOverlapReclaimedCores is a flag, when enabled,
	// we will rely on kernel features to ensure that shared_cores pods can suppress and preempt reclaimed_cores pods.
	// +optional
	AllowSharedCoresOverlapReclaimedCores *bool `json:"allowSharedCoresOverlapReclaimedCores,omitempty"`

	// optional
	CPUProvisionConfig *CPUProvisionConfig `json:"cpuProvisionConfig"`
}

type CPUHeadroomConfig struct {
	// UtilBasedConfig is a config for utilization based cpu headroom policy
	// +optional
	UtilBasedConfig *CPUHeadroomUtilBasedConfig `json:"utilBasedConfig,omitempty"`
}

type CPUHeadroomUtilBasedConfig struct {
	// Enable is a flag to enable utilization based cpu headroom policy
	// +optional
	Enable *bool `json:"enable,omitempty"`

	// TargetReclaimedCoreUtilization is the target reclaimed core utilization to be used for
	// calculating the oversold cpu headroom
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	TargetReclaimedCoreUtilization *float64 `json:"targetReclaimedCoreUtilization,omitempty"`

	// MaxReclaimedCoreUtilization is the max reclaimed core utilization of reclaimed_cores pool,
	// which is used to calculate the oversold cpu headroom, if zero means no limit
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	MaxReclaimedCoreUtilization *float64 `json:"maxReclaimedCoreUtilization,omitempty"`

	// MaxOversoldRate is the max oversold rate of cpu headroom to the actual size of
	// reclaimed_cores pool
	// +kubebuilder:validation:Minimum=0
	// +optional
	MaxOversoldRate *float64 `json:"maxOversoldRate,omitempty"`

	// MaxHeadroomCapacityRate is the max headroom capacity rate of cpu headroom to the total
	// cpu capacity of node
	// +kubebuilder:validation:Minimum=0
	// +optional
	MaxHeadroomCapacityRate *float64 `json:"maxHeadroomCapacityRate,omitempty"`
}

type CPUPressureEvictionConfig struct {
	// EnableLoadEviction is whether to enable cpu load eviction
	// +optional
	EnableLoadEviction *bool `json:"enableLoadEviction,omitempty"`

	// LoadUpperBoundRatio is the upper bound ratio of cpuset pool load, if the load
	// of the target cpuset pool is greater than the load upper bound repeatedly, the
	// eviction will be triggered
	// +kubebuilder:validation:Minimum=1
	// +optional
	LoadUpperBoundRatio *float64 `json:"loadUpperBoundRatio,omitempty"`

	// LoadLowerBoundRatio is the lower bound ratio of cpuset pool load, if the load
	// of the target cpuset pool is greater than the load lower bound repeatedly, the
	// node taint will be triggered
	// +kubebuilder:validation:Minimum=0
	// +optional
	LoadLowerBoundRatio *float64 `json:"loadLowerBoundRatio,omitempty"`

	// LoadThresholdMetPercentage is the percentage of the number of times the load
	// over the upper bound to the total number of times the load is measured, if the
	// percentage is greater than the load threshold met percentage, the eviction or
	// node tainted will be triggered
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	LoadThresholdMetPercentage *float64 `json:"loadThresholdMetPercentage,omitempty"`

	// LoadMetricRingSize is the size of the load metric ring, which is used to calculate the
	// load of the target cpuset pool
	// +kubebuilder:validation:Minimum=1
	// +optional
	LoadMetricRingSize *int `json:"loadMetricRingSize,omitempty"`

	// LoadEvictionCoolDownTime is the cool-down time of cpu load eviction,
	// if the cpu load eviction is triggered, the cpu load eviction will be
	// disabled for the cool-down time
	// +optional
	LoadEvictionCoolDownTime *metav1.Duration `json:"loadEvictionCoolDownTime,omitempty"`

	// EnableSuppressionEviction is whether to enable pod-level cpu suppression eviction
	// +optional
	EnableSuppressionEviction *bool `json:"enableSuppressionEviction,omitempty"`

	// MaxSuppressionToleranceRate is the maximum cpu suppression tolerance rate that
	// can be set by the pod, if the cpu suppression tolerance rate of the pod is greater
	// than the maximum cpu suppression tolerance rate, the cpu suppression tolerance rate
	// of the pod will be set to the maximum cpu suppression tolerance rate
	// +kubebuilder:validation:Minimum=0
	// +optional
	MaxSuppressionToleranceRate *float64 `json:"maxSuppressionToleranceRate,omitempty"`

	// MinSuppressionToleranceDuration is the minimum duration a pod can tolerate cpu
	// suppression, only if the cpu suppression duration of the pod is greater than the
	// minimum cpu suppression duration, the eviction will be triggered
	// +optional
	MinSuppressionToleranceDuration *metav1.Duration `json:"minSuppressionToleranceDuration,omitempty"`

	// GracePeriod is the grace period of cpu pressure eviction
	// +kubebuilder:validation:Minimum=0
	// +optional
	GracePeriod *int64 `json:"gracePeriod,omitempty"`
}

type CPUProvisionConfig struct {
	RegionIndicators []RegionIndicators       `json:"regionIndicators,omitempty"`
	Constraints      []ControlKnobConstraints `json:"constraints,omitempty"`
}

type CPUSystemPressureEvictionConfig struct {
	// +optional
	EnableCPUSystemPressureEviction *bool `json:"enableCPUSystemPressureEviction,omitempty"`

	// LoadUpperBoundRatio is the upper bound ratio of node, if the load
	// of the node is greater than the load upper bound repeatedly, the
	// eviction will be triggered
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	LoadUpperBoundRatio *float64 `json:"loadUpperBoundRatio,omitempty"`

	// LoadLowerBoundRatio is the lower bound ratio of node, if the load
	// of the node is greater than the load lower bound repeatedly, the
	// cordon will be triggered
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	LoadLowerBoundRatio *float64 `json:"loadLowerBoundRatio,omitempty"`

	// UsageUpperBoundRatio is the upper bound ratio of node, if the cpu usage
	// of the node is greater than the usage upper bound repeatedly, the
	// eviction will be triggered
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	UsageUpperBoundRatio *float64 `json:"usageUpperBoundRatio,omitempty"`

	// UsageLowerBoundRatio is the lower bound ratio of node, if the cpu usage
	// of the node is greater than the usage lower bound repeatedly, the
	// cordon will be triggered
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	UsageLowerBoundRatio *float64 `json:"usageLowerBoundRatio,omitempty"`

	// ThresholdMetPercentage is the percentage of the number of times the metric
	// over the upper bound to the total number of times the metric is measured, if the
	// percentage is greater than the threshold met percentage, the eviction or
	// node tainted will be triggered
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	ThresholdMetPercentage *float64 `json:"thresholdMetPercentage,omitempty"`

	// MetricRingSize is the size of the load metric ring
	// +kubebuilder:validation:Minimum=1
	// +optional
	MetricRingSize *int `json:"metricRingSize,omitempty"`

	// EvictionCoolDownTime is the cool down duration of pod eviction
	// +optional
	EvictionCoolDownTime *metav1.Duration `json:"evictionCoolDownTime,omitempty"`

	// EvictionRankingMetrics is the metric list for ranking eviction pods
	// +optional
	EvictionRankingMetrics []string `json:"evictionRankingMetrics,omitempty"`

	// +optional
	GracePeriod *int64 `json:"gracePeriod,omitempty"`

	// +optional
	CheckCPUManager *bool `json:"checkCPUManager,omitempty"`

	// +optional
	RankingLabels map[string][]string `json:"RankingLabels,omitempty"`
}

type CgroupConfig struct {
	// CgroupPath is an cgroupV2 absolute path, e.g. /sys/fs/cgroup/hdfs
	CgroupPath string `json:"cgroupPath"`

	// ConfigDetail is configuration details of TMO
	ConfigDetail TMOConfigDetail `json:"configDetail"`
}

type ConfigConditionType string

type ConfigUpdateStrategy struct {
	// Type of config update. Only `RollingUpdate` is supported.
	// +optional
	Type ConfigUpdateStrategyType `json:"type,omitempty"`

	// Rolling update config params. Present only if type = "RollingUpdate".
	//---
	// TODO: Update this to follow our convention for oneOf, whatever we decide it
	// to be. Same as Deployment `strategy.rollingUpdate`.
	// See https://github.com/kubernetes/kubernetes/issues/35345
	// +optional
	RollingUpdate *RollingUpdateConfig `json:"rollingUpdate,omitempty"`
}

type ConfigUpdateStrategyType string

type ControlKnobConstraints struct {
	Name                ControlKnobName     `json:"name"`
	RestrictConstraints RestrictConstraints `json:",inline"`
}

type ControlKnobName string

type CustomNodeConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   CustomNodeConfigSpec   `json:"spec,omitempty"`
	Status CustomNodeConfigStatus `json:"status,omitempty"`
}

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

type CustomNodeConfigSpec struct {
}

type CustomNodeConfigStatus struct {
	// KatalystCustomConfigList contains a list of target custom config
	KatalystCustomConfigList []TargetConfig `json:"katalystCustomConfigList,omitempty"`

	// ServiceProfileConfigList contains a list of target service Profile config
	ServiceProfileConfigList []TargetConfig `json:"serviceProfileConfigList,omitempty"`
}

type EphemeralSelector struct {
	// Specific nodes' name the configurations will be effected.
	// +optional
	NodeNames []string `json:"nodeNames,omitempty"`

	// define the duration this configuration will last from creationTimestamp.
	// must and only set when NodeNames already set
	LastDuration *metav1.Duration `json:"lastDuration,omitempty"`
}

type EvictionConfig struct {
	// DryRun is the list of eviction plugins to dryRun
	// '*' means "all dry-run by default"
	// 'foo' means "dry-run 'foo'"
	// first item for a particular name wins
	// +optional
	DryRun []string `json:"dryRun"`

	// CPUPressureEvictionConfig is the config for cpu pressure eviction
	// +optional
	CPUPressureEvictionConfig *CPUPressureEvictionConfig `json:"cpuPressureEvictionConfig,omitempty"`

	// SystemLoadPressureEvictionConfig is the config for system load eviction
	// +optional
	//
	// Deprecated: Please use CPUSystemPressureEvictionConfig instead to configure params for CPU eviction plugin at node level
	SystemLoadPressureEvictionConfig *SystemLoadPressureEvictionConfig `json:"systemLoadPressureEvictionConfig,omitempty"`

	// CPUSystemPressureEvictionConfig is the config for cpu system pressure eviction at node level
	// +optional
	CPUSystemPressureEvictionConfig *CPUSystemPressureEvictionConfig `json:"cpuSystemPressureEvictionConfig,omitempty"`

	// MemoryPressureEvictionConfig is the config for memory pressure eviction
	// +optional
	MemoryPressureEvictionConfig *MemoryPressureEvictionConfig `json:"memoryPressureEvictionConfig,omitempty"`

	// RootfsPressureEvictionConfig is the config for rootfs pressure eviction
	// +optional
	RootfsPressureEvictionConfig *RootfsPressureEvictionConfig `json:"rootfsPressureEvictionConfig,omitempty"`

	// ReclaimedResourcesEvictionConfig is the config for reclaimed resources' eviction
	// +optional
	ReclaimedResourcesEvictionConfig *ReclaimedResourcesEvictionConfig `json:"reclaimedResourcesEvictionConfig,omitempty"`
}

type GenericConfigCondition struct {
	// Type of config condition
	Type ConfigConditionType `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// Last time the condition transit from one status to another.
	// +optional
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
	// reason is the reason for the condition's last transition.
	// +optional
	Reason string `json:"reason,omitempty"`
	// message is a human-readable explanation containing details about the transition
	// +optional
	Message string `json:"message,omitempty"`
}

type GenericConfigSpec struct {
	// RevisionHistoryLimit is the maximum number of revisions that will
	// be maintained in the resource's revision history. The revision history
	// consists of all revisions not represented by a currently applied
	// Spec version. The default value is 3.
	// +kubebuilder:default:=3
	RevisionHistoryLimit int64 `json:"revisionHistoryLimit,omitempty"`

	// NodeLabelSelector select nodes to apply these configurations,
	// the priority and node label selector must be matched according
	// to KatalystCustomConfig.spec.nodeLabelSelectorAllowedKeyList,
	// otherwise it will not be synced.
	// +optional
	NodeLabelSelector string `json:"nodeLabelSelector,omitempty"`

	// Priority is used by one node matched by NodeLabelSelector of more
	// than one configuration, and the higher priority will be considered.
	// The priority only be supported when NodeLabelSelector set
	// +optional
	Priority int32 `json:"priority,omitempty"`

	// EphemeralSelector is a selector for temporary use only
	// +optional
	EphemeralSelector EphemeralSelector `json:"ephemeralSelector,omitempty"`

	// Indicates that the config is paused.
	// +optional
	Paused bool `json:"paused,omitempty"`

	// An update strategy to replace existing CustomNodeConfig configurations with new ones.
	// +optional
	UpdateStrategy ConfigUpdateStrategy `json:"updateStrategy,omitempty"`
}

type GenericConfigStatus struct {
	// The number of nodes that this config is targeting.
	// +optional
	TargetNodes int32 `json:"targetNodes"`

	// The number of nodes that this config is targeting and should be updated given the current strategy.
	// +optional
	CanaryNodes int32 `json:"canaryNodes"`

	// The number of target nodes that have been updated by this config.
	// +optional
	UpdatedTargetNodes int32 `json:"updatedTargetNodes"`

	// The number of nodes (including non-target nodes) that have been updated by this config.
	// +optional
	UpdatedNodes int32 `json:"updatedNodes"`

	// The hash of the current config observed by the kcc controller.
	// +optional
	CurrentHash string `json:"currentHash,omitempty"`

	// Count of hash collisions for this cr. The kcc controller
	// uses this field as a collision avoidance mechanism when it needs to
	// create the name for the newest ControllerRevision.
	// +optional
	CollisionCount *int32 `json:"collisionCount,omitempty"`

	// The most recent generation observed by the kcc controller.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Represents the latest available observations of a config's current state.
	// +optional
	Conditions []GenericConfigCondition `json:"conditions,omitempty"`
}

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

	// Configs are global resource portrait configuration
	Configs []ResourcePortraitConfiguration `json:"configs,omitempty"`
}

type IndicatorTargetConfiguration struct {
	Name   v1alpha1.ServiceSystemIndicatorName `json:"name"`
	Target float64                             `json:"target"`
}

type KatalystCustomConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   KatalystCustomConfigSpec   `json:"spec,omitempty"`
	Status KatalystCustomConfigStatus `json:"status,omitempty"`
}

type KatalystCustomConfigCondition struct {
	// Type of KatalystCustomConfig condition
	Type KatalystCustomConfigConditionType `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// Last time the condition transit from one status to another.
	// +optional
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
	// reason is the reason for the condition's last transition.
	// +optional
	Reason string `json:"reason,omitempty"`
	// message is a human-readable explanation containing details about the transition
	// +optional
	Message string `json:"message,omitempty"`
}

type KatalystCustomConfigConditionType string

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

type KatalystCustomConfigSpec struct {
	// the GVR of target config type
	TargetType metav1.GroupVersionResource `json:"targetType"`
	// whether disable revisionHistory for the KatalystCustomConfig resource
	// +kubebuilder:default:=true
	// +optional
	DisableRevisionHistory bool `json:"disableRevisionHistory,omitempty"`
	// the keys list allowed in node selector to select which nodes will be effected by the KatalystCustomConfig resource,
	// and the priority will be used when one node match two KatalystCustomConfig resource at the same time, the higher
	// priority one will be considered. If not set, node label selector is not allowed to use.
	// +patchMergeKey=priority
	// +patchStrategy=merge
	// +optional
	NodeLabelSelectorAllowedKeyList []PriorityNodeLabelSelectorAllowedKeyList `json:"nodeLabelSelectorAllowedKeyList,omitempty"`
}

type KatalystCustomConfigStatus struct {
	// ObservedGeneration is the generation as observed by the controller consuming the KatalystCustomConfig.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// InvalidTargetConfigList is a name list of invalid Config
	InvalidTargetConfigList []string `json:"invalidTargetConfigList,omitempty"`

	// Represents the latest available observations of a KatalystCustomConfig's current state.
	Conditions []KatalystCustomConfigCondition `json:"conditions,omitempty"`
}

type MemoryAdvisorConfig struct {
	// MemoryGuardConfig is a config for memory guard plugin, which is used to avoid high priority workload from being
	// affected by memory bursting caused by low priority workload.
	// +optional
	MemoryGuardConfig *MemoryGuardConfig `json:"memoryGuardConfig,omitempty"`
}

type MemoryGuardConfig struct {
	// Enable is a flag to enable memory guard plugin
	// +optional
	Enable *bool `json:"enable,omitempty"`
}

type MemoryHeadroomConfig struct {
	// MemoryHeadroomUtilBasedConfig is a config for utilization based memory headroom policy
	// +optional
	UtilBasedConfig *MemoryHeadroomUtilBasedConfig `json:"utilBasedConfig,omitempty"`
}

type MemoryHeadroomUtilBasedConfig struct {
	// Enable is a flag to enable utilization based memory headroom policy
	// +optional
	Enable *bool `json:"enable,omitempty"`

	// FreeBasedRatio is the estimation of free memory utilization, which can
	// be used as system buffer to oversold memory.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	FreeBasedRatio *float64 `json:"freeBasedRatio,omitempty"`

	// StaticBasedCapacity is the static oversold memory size by bytes
	// +kubebuilder:validation:Minimum=0
	// +optional
	StaticBasedCapacity *float64 `json:"staticBasedCapacity,omitempty"`

	// CacheBasedRatio is the rate of cache oversold, 0 means disable cache oversold
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1
	// +optional
	CacheBasedRatio *float64 `json:"cacheBasedRatio,omitempty"`
}

type MemoryPressureEvictionConfig struct {
	// EnableNumaLevelEviction is whether to enable numa-level eviction
	// +optional
	EnableNumaLevelEviction *bool `json:"enableNumaLevelEviction,omitempty"`

	// EnableSystemLevelEviction is whether to enable system-level eviction
	// +optional
	EnableSystemLevelEviction *bool `json:"enableSystemLevelEviction,omitempty"`

	// NumaVictimMinimumUtilizationThreshold is the victim's minimum memory usage on a NUMA node, if a pod
	// uses less memory on a NUMA node than this threshold,it won't be evicted by this NUMA's memory pressure.
	// +optional
	NumaVictimMinimumUtilizationThreshold *float64 `json:"numaVictimMinimumUtilizationThreshold,omitempty"`

	// NumaFreeBelowWatermarkTimesThreshold is the threshold for the number of
	// times NUMA's free memory falls below the watermark
	// +kubebuilder:validation:Minimum=0
	// +optional
	NumaFreeBelowWatermarkTimesThreshold *int `json:"numaFreeBelowWatermarkTimesThreshold,omitempty"`

	// NumaFreeBelowWatermarkTimesThreshold is the threshold for the rate of
	// kswapd reclaiming rate
	// +kubebuilder:validation:Minimum=0
	// +optional
	SystemKswapdRateThreshold *int `json:"systemKswapdRateThreshold,omitempty"`

	// SystemKswapdRateExceedDurationThreshold is the threshold for the duration the kswapd reclaiming rate
	// exceeds the threshold
	// +kubebuilder:validation:Minimum=0
	// +optional
	SystemKswapdRateExceedDurationThreshold *int `json:"systemKswapdRateExceedDurationThreshold,omitempty"`

	// SystemFreeMemoryThresholdMinimum is the system free memory threshold minimum.
	// +optional
	SystemFreeMemoryThresholdMinimum *resource.Quantity `json:"systemFreeMemoryThresholdMinimum,omitempty"`

	// NumaEvictionRankingMetrics is the metrics used to rank pods for eviction
	// at the NUMA level
	// +kubebuilder:validation:MinItems=1
	// +optional
	NumaEvictionRankingMetrics []NumaEvictionRankingMetric `json:"numaEvictionRankingMetrics,omitempty"`

	// SystemEvictionRankingMetrics is the metrics used to rank pods for eviction
	// at the system level
	// +kubebuilder:validation:MinItems=1
	// +optional
	SystemEvictionRankingMetrics []SystemEvictionRankingMetric `json:"systemEvictionRankingMetrics,omitempty"`

	// EnableRSSOveruseEviction is whether to enable pod-level rss overuse eviction
	// +optional
	EnableRSSOveruseEviction *bool `json:"enableRSSOveruseEviction,omitempty"`

	// RSSOveruseRateThreshold is the threshold for the rate of rss
	// +kubebuilder:validation:Minimum=0
	// +optional
	RSSOveruseRateThreshold *float64 `json:"rssOveruseRateThreshold,omitempty"`

	// GracePeriod is the grace period of memory pressure eviction
	// +kubebuilder:validation:Minimum=0
	// +optional
	GracePeriod *int64 `json:"gracePeriod,omitempty"`
}

type NumaEvictionRankingMetric string

type PSIPolicyConf struct {
	// MaxProbe limits the memory offloading size in one cycle, it's a ratio of memory usage.
	MaxProbe *float64 `json:"maxProbe,omitempty"`

	// PSIAvg60Threshold indicates the threshold of memory pressure. If observed pressure exceeds
	// this threshold, memory offloading will be paused.
	PSIAvg60Threshold *float64 `json:"psiAvg60Threshold,omitempty"`
}

type PolicyRule struct {
	// +optional
	Resources []string `json:"resources,omitempty"`
}

type PriorityNodeLabelSelectorAllowedKeyList struct {
	// Priority is the priority of configurations
	Priority int32 `json:"priority"`
	// KeyList is allowed to use in node selector in the Priority
	KeyList []string `json:"keyList"`
}

type QoSLevelConfig struct {
	// QoSLevel is either of reclaimed_cores, shared_cores, dedicated_cores, system_cores
	QoSLevel consts.QoSLevel `json:"qosLevel"`

	// ConfigDetail is configuration details of TMO
	ConfigDetail TMOConfigDetail `json:"configDetail"`
}

type QoSRegionType string

type ReclaimedResourceConfig struct {
	// EnableReclaim is a flag to enable reclaim resource, if true, reclaim resource will be enabled,
	// which means reclaim resource will be reported to custom node resource and support colocation between
	// reclaimed_cores pod and other pods, otherwise, reclaim resource will be disabled.
	// +optional
	EnableReclaim *bool `json:"enableReclaim,omitempty"`

	// ReservedResourceForReport is a reserved resource for report to custom node resource, which is used to
	// prevent reclaim resource from being requested by reclaimed_cores pods.
	// +optional
	ReservedResourceForReport *v1.ResourceList `json:"reservedResourceForReport,omitempty"`

	// MinReclaimedResourceForReport is a minimum reclaimed resource for report to custom node resource, which means
	// if reclaimed resource is less than MinReclaimedResourceForReport, then reclaimed resource will be reported as
	// MinReclaimedResourceForReport.
	// +optional
	MinReclaimedResourceForReport *v1.ResourceList `json:"minReclaimedResourceForReport,omitempty"`

	// ReservedResourceForAllocate is a resource reserved for non-reclaimed_cores pods that are not allocated to
	// reclaimed_cores pods. It is used to set aside some buffer resources to avoid sudden increase in resource
	// requirements.
	// +optional
	ReservedResourceForAllocate *v1.ResourceList `json:"reservedResourceForAllocate,omitempty"`

	// MinReclaimedResourceForAllocate is a resource reserved for reclaimed_cores pods，these resources will not be used
	// by shared_cores pods.
	// +optional
	MinReclaimedResourceForAllocate *v1.ResourceList `json:"minReclaimedResourceForAllocate,omitempty"`

	// CPUHeadroomConfig is a configuration for cpu headroom
	// +optional
	CPUHeadroomConfig *CPUHeadroomConfig `json:"cpuHeadroomConfig,omitempty"`

	// MemoryHeadroomConfig is a configuration for memory headroom
	// +optional
	MemoryHeadroomConfig *MemoryHeadroomConfig `json:"memoryHeadroomConfig,omitempty"`
}

type ReclaimedResourcesEvictionConfig struct {
	// EvictionThreshold eviction threshold rate for reclaimed resources
	// +optional
	EvictionThreshold map[v1.ResourceName]float64 `json:"evictionThreshold"`

	// GracePeriod is the grace period of reclaimed resources' eviction
	// +kubebuilder:validation:Minimum=0
	// +optional
	GracePeriod *int64 `json:"gracePeriod,omitempty"`

	// ThresholdMetToleranceDuration is the tolerance duration before eviction.
	// +kubebuilder:validation:Minimum=0
	// +optional
	ThresholdMetToleranceDuration *int64 `json:"thresholdMetToleranceDuration,omitempty"`
}

type RefaultPolicyConf struct {
	// MaxProbe limits the memory offloading size in one cycle, it's a ratio of memory usage.
	MaxProbe *float64 `json:"maxProbe,omitempty"`
	// ReclaimAccuracyTarget indicates the desired level of precision or accuracy in offloaded pages.
	ReclaimAccuracyTarget *float64 `json:"reclaimAccuracyTarget,omitempty"`
	// ReclaimScanEfficiencyTarget indicates the desired level of efficiency in scanning and
	// identifying memory pages that can be offloaded.
	ReclaimScanEfficiencyTarget *float64 `json:"reclaimScanEfficiencyTarget,omitempty"`
}

type RegionIndicators struct {
	RegionType QoSRegionType                  `json:"regionType"`
	Targets    []IndicatorTargetConfiguration `json:"targets"`
}

type ResourcePortraitConfig struct {
	// Source indicates the source of the configuration.
	// When this field is empty, the configuration is ignored.
	Source string `json:"source"`

	// Algorithm is the algorithm config used to calculate the resource portrait.
	AlgorithmConfig AlgorithmConfig `json:"algorithmConfig"`

	// Metrics contains preset metric query templates, such as CPU and memory metric queries.
	// +optional
	Metrics []string `json:"metrics,omitempty"`

	// CustomMetrics contains custom metric query, the key is the metric name, the value is the metric query.
	// +optional
	CustomMetrics map[string]string `json:"customMetrics,omitempty"`
}

type ResourcePortraitConfiguration struct {
	// Config defines the algorithm and indicator configuration used for resource portrait.
	Config ResourcePortraitConfig `json:"config"`

	// Filter filters SPDs matching filter rules by namespaces and labels.
	// Namespaces and labels are derived from the workload referenced by the SPD.
	Filter ResourcePortraitFilter `json:"filter,omitempty"`
}

type ResourcePortraitFilter struct {
	// Selector is used to filter workloads associated with SPD from the label dimension.
	// +optional
	Selector *metav1.LabelSelector `json:"selector,omitempty"`

	// Namespaces contains a list of namespaces used for filtering the target workload with spd.
	// The workload only needs to match a single namespace.
	// +optional
	Namespaces []string `json:"namespaces,omitempty"`
}

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

	// Configs are spd's resource portrait configuration
	Configs []ResourcePortraitConfig `json:"configs,omitempty"`
}

type RestrictConstraints struct {
	// MaxUpperGap is the maximum upward offset value from the baseline
	MaxUpperGap *float64 `json:"maxUpperGap,omitempty"`
	// MaxLowerGap is the maximum downward offset value from the baseline
	MaxLowerGap *float64 `json:"maxLowerGap,omitempty"`
	// MaxUpperGapRatio is the maximum upward offset ratio from the baseline
	MaxUpperGapRatio *float64 `json:"maxUpperGapRatio,omitempty"`
	// MaxLowerGapRatio is the maximum downward offset ratio from the baseline
	MaxLowerGapRatio *float64 `json:"maxLowerGapRatio,omitempty"`
}

type RollingUpdateConfig struct {
	// The number or percentage of target CustomNodeConfigs to update to the current configuration.
	// For example: `100“ and `20%` are valid values.
	// +kubebuilder:validation:XIntOrString
	// +kubebuilder:validation:Pattern=`^(100|[1-9][0-9]?|0)%$`
	// +optional
	Canary *intstr.IntOrString `json:"canary,omitempty"`
}

type RootfsPressureEvictionConfig struct {
	// EnableRootfsPressureEviction is whether to enable rootfs pressure eviction.
	// +optional
	EnableRootfsPressureEviction *bool `json:"enableRootfsPressureEviction,omitempty"`

	// MinimumImageFsFreeThreshold is a threshold for a node.
	// Once the image rootfs free space of current node is lower than this threshold, the eviction manager will try to evict some pods.
	// For example: "200Gi", "10%".
	// +optional
	// +kubebuilder:validation:Pattern=`^(0|[1-9][0-9]*)(\.[0-9]+)?%?$|^(0|[1-9][0-9]*)([kKmMGTPeE]i?)$`
	MinimumImageFsFreeThreshold *string `json:"minimumImageFsFreeThreshold,omitempty"`

	// MinimumImageFsInodesFreeThreshold is a threshold for a node.
	// Once the image rootfs free inodes of current node is lower than this threshold, the eviction manager will try to evict some pods.
	// For example: "100000", "10%".
	// +optional
	// +kubebuilder:validation:Pattern=`^(0|[1-9]\d*)(\.\d+)?%?$|^\d+$`
	MinimumImageFsInodesFreeThreshold *string `json:"minimumImageFsInodesFreeThreshold,omitempty"`

	// PodMinimumUsedThreshold is a threshold for all pods.
	// The eviction manager will ignore this pod if its rootfs used in bytes is lower than this threshold.
	// For example: "200Gi", "1%".
	// +optional
	// +kubebuilder:validation:Pattern=`^(0|[1-9][0-9]*)(\.[0-9]+)?%?$|^(0|[1-9][0-9]*)([kKmMGTPeE]i?)$`
	PodMinimumUsedThreshold *string `json:"podMinimumUsedThreshold,omitempty"`

	// PodMinimumInodesUsedThreshold is a threshold for all pods.
	// The eviction manager will ignore this pod if its rootfs inodes used is lower than this threshold.
	// For example: "1000", "1%".
	// +optional
	// +kubebuilder:validation:Pattern=`^(0|[1-9]\d*)(\.\d+)?%?$|^\d+$`
	PodMinimumInodesUsedThreshold *string `json:"podMinimumInodesUsedThreshold,omitempty"`

	// ReclaimedQoSPodUsedPriorityThreshold is a threshold for all offline pods.
	// The eviction manager will prioritize the eviction of offline pods that reach this threshold.
	// For example: "100Gi", "1%".
	// +optional
	// +kubebuilder:validation:Pattern=`^(0|[1-9][0-9]*)(\.[0-9]+)?%?$|^(0|[1-9][0-9]*)([kKmMGTPeE]i?)$`
	ReclaimedQoSPodUsedPriorityThreshold *string `json:"reclaimedQoSPodUsedPriorityThreshold,omitempty"`

	// ReclaimedQoSPodInodesUsedPriorityThreshold is a threshold for all offline pods.
	// The eviction manager will prioritize the eviction of reclaimed pods that reach this threshold.
	// For example: "500", "1%".
	// +optional
	// +kubebuilder:validation:Pattern=`^(0|[1-9]\d*)(\.\d+)?%?$|^\d+$`
	ReclaimedQoSPodInodesUsedPriorityThreshold *string `json:"reclaimedQoSPodInodesUsedPriorityThreshold,omitempty"`

	// MinimumImageFsDiskCapacityThreshold is a threshold for all nodes.
	// The eviction manager will ignore those nodes whose image fs disk capacity is less than this threshold.
	// Fox example: "100Gi".
	MinimumImageFsDiskCapacityThreshold *resource.Quantity `json:"minimumImageFsDiskCapacityThreshold,omitempty"`

	// GracePeriod is the grace period of pod deletion
	// +optional
	GracePeriod *int64 `json:"gracePeriod,omitempty"`
}

type SystemEvictionRankingMetric string

type SystemLoadPressureEvictionConfig struct {
	// SoftThreshold is the soft threshold of system load pressure, it should be an integral multiple of 100, which means
	// the real threshold is (SoftThreshold / 100) * CoreNumber
	// +optional
	SoftThreshold *int64 `json:"softThreshold,omitempty"`

	// HardThreshold is the hard threshold of system load pressure, it should be an integral multiple of 100, which means
	// the real threshold is (SoftThreshold / 100) * CoreNumber
	// +optional
	HardThreshold *int64 `json:"hardThreshold,omitempty"`

	// HistorySize is the size of the load metric ring, which is used to calculate the system load
	// +kubebuilder:validation:Minimum=1
	// +optional
	HistorySize *int64 `json:"historySize,omitempty"`

	// SyncPeriod is the interval in seconds of the plugin fetch the load information
	// +kubebuilder:validation:Minimum=1
	// +optional
	SyncPeriod *int64 `json:"syncPeriod,omitempty"`

	// CoolDownTime is the cool-down time of the plugin evict pods
	// +kubebuilder:validation:Minimum=1
	// +optional
	CoolDownTime *int64 `json:"coolDownTime,omitempty"`

	// GracePeriod is the grace period of pod deletion
	// +optional
	GracePeriod *int64 `json:"gracePeriod,omitempty"`

	// the plugin considers the node is facing load pressure only when the ratio of load history which is greater than
	// threshold is greater than this percentage
	// +optional
	ThresholdMetPercentage *float64 `json:"thresholdMetPercentage,omitempty"`
}

type TMOConfigDetail struct {
	// EnableTMO is whether to enable TMO on target objective
	// +optional
	EnableTMO *bool `json:"enableTMO,omitempty"`

	// EnableSwap is whether to enable swap to offloading anon pages
	// +optional
	EnableSwap *bool `json:"enableSwap,omitempty"`

	// Interval is the minimum duration the objectives got memory reclaimed by TMO
	// +optional
	Interval *metav1.Duration `json:"interval,omitempty"`

	// PolicyName is used to specify the policy for calculating memory offloading size
	// +optional
	PolicyName *TMOPolicyName `json:"policyName,omitempty"`

	// PSIPolicyConf is configurations of a TMO policy which reclaim memory by PSI
	// +optional
	PSIPolicyConf *PSIPolicyConf `json:"psiPolicy,omitempty"`

	// RefaultPolicy is configurations of a TMO policy which reclaim memory by refault
	// +optional
	RefaultPolicConf *RefaultPolicyConf `json:"refaultPolicy,omitempty"`
}

type TMOPolicyName string

type TargetConfig struct {
	// ConfigType gvr of target config
	ConfigType metav1.GroupVersionResource `json:"configType"`
	// ConfigName name of target config
	ConfigName string `json:"configName"`
	// ConfigNamespace namespace of target config
	ConfigNamespace string `json:"configNamespace"`
	// Hash is current hash value of target config.
	// The agent will first check whether the local config hash and
	// the target config hash are equal, only if not, it will try to
	// update the local config from the remote.
	Hash string `json:"hash"`
}

type TimeWindow struct {
	// Input is the time interval used when querying the time series data source, with the unit being seconds.
	Input int `json:"input"`

	// HistorySteps is the number of steps to use as the input for the algorithm.
	HistorySteps int `json:"historySteps"`

	// Aggregator is the aggregator used to aggregate the time series data group.
	Aggregator Aggregator `json:"aggregator"`

	// Output is the grouping interval of portrait data, which groups portrait data at an integer multiple of Input.
	Output int `json:"output"`

	// PredictionSteps is the number of steps to predict the future value.
	PredictionSteps int `json:"predictionSteps"`
}

type TransparentMemoryOffloadingConfig struct {
	// QoSLevelConfig is a configuration for manipulating TMO on Different QoS Level
	// +optional
	// +listMapKey=qosLevel
	// +listType=map
	QoSLevelConfig []QoSLevelConfig `json:"qosLevelConfig,omitempty"`

	// CgroupConfig is a configuration for manipulating TMO on specified cgroups
	// +optional
	// +listMapKey=cgroupPath
	// +listType=map
	CgroupConfig []CgroupConfig `json:"CgroupConfig,omitempty"`

	// BlockConfig is a configuration for blocking tmo on specified pods.
	// +optional
	BlockConfig *BlockConfig `json:"blockConfig,omitempty"`
}

type TransparentMemoryOffloadingConfiguration struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   TransparentMemoryOffloadingConfigurationSpec `json:"spec,omitempty"`
	Status GenericConfigStatus                          `json:"status,omitempty"`
}

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

type TransparentMemoryOffloadingConfigurationSpec struct {
	GenericConfigSpec `json:",inline"`

	// Config is custom field for TMO configuration
	Config TransparentMemoryOffloadingConfig `json:"config"`
}

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

	// ConfigDetail is configuration details of TMO
	ConfigDetail *TMOConfigDetail `json:"configDetail,omitempty"`
}

type UserPasswordPair struct {
	// +optional
	Username string `json:"username,omitempty"`
	// base64 encoded password
	// +optional
	Password string `json:"password,omitempty"`
}