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
	MemoryAdvisorConfig *MemoryAdvisorConfig `json:"memoryAdvisorConfig,omitempty"`
}

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

	// 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 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 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
	SystemLoadPressureEvictionConfig *SystemLoadPressureEvictionConfig `json:"systemLoadPressureEvictionConfig,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"`
}

type GenericConfigStatus struct {
	// 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.
	Conditions []GenericConfigCondition `json:"conditions,omitempty"`
}

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 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 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 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"`
}

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"`
}