v1

type AdjustRequest struct {
	PodUID     string
	IsScaleUp  bool
	NewRequest Resource
	NewLimit   Resource
}

type AllocRequest struct {
	// Name of the GPU pool to allocate from
	PoolName string
	// Namespace information for the workload
	WorkloadNameNamespace NameNamespace
	// Resource requirements for the allocation
	Request Resource
	Limit   Resource
	// Specific GPU indices to allocate, empty slice means any index
	GPUIndices []int32
	// Number of GPUs to allocate
	Count uint
	// Specific GPU model to allocate, empty string means any model
	GPUModel string

	// Specific GPU vendor to allocate, default to any if empty
	GPUVendor string

	// Node affinity requirements
	NodeAffinity *v1.NodeAffinity

	// final scheduled GPU IDs for this allocation request
	// This fields is set by GPUAllocator, user should not choose specific GPUs
	GPUNames []string

	// record the pod meta for quota check
	PodMeta metav1.ObjectMeta

	QoS QoSLevel

	Isolation IsolationModeType

	// PartitionTemplateID is the template ID used for partitioned mode allocation
	// This is set by the scheduler when a partition is matched, or read from pod annotation
	PartitionTemplateID string
}

type AllocatedPartition struct {
	// TemplateID is the template used to create this partition
	TemplateID string `json:"templateId"`

	// PodUID is the UID of the pod using this partition (used as map key)
	PodUID string `json:"podUid"`

	// PodName is the name of the pod using this partition
	PodName string `json:"podName"`

	// Namespace is the namespace of the pod using this partition
	Namespace string `json:"namespace"`

	// AllocatedAt is when this partition was allocated
	AllocatedAt metav1.Time `json:"allocatedAt"`

	// AllocatedSlotStart is the starting slot position where this partition is allocated
	// This is the actual hardware slot position (0-based index)
	// For NVIDIA MIG: physical slot position (0-7)
	AllocatedSlotStart *uint32 `json:"allocatedSlotStart,omitempty"`

	// AllocatedSlotEnd is the ending slot position (exclusive) where this partition is allocated
	// The partition occupies slots [AllocatedSlotStart, AllocatedSlotEnd)
	AllocatedSlotEnd *uint32 `json:"allocatedSlotEnd,omitempty"`

	// IsolationGroupID is the isolation group where this partition is allocated
	// For Ascend NPU: vGroup ID (0-3)
	// For NVIDIA MIG: this is derived from slot position, not used separately
	// +optional
	IsolationGroupID *uint32 `json:"isolationGroupId,omitempty"`
}

type AuthTypeEnum string

type AutoFreeze struct {
	Qos             QoSLevel `json:"qos,omitempty"`
	FreezeToMemTTL  string   `json:"freezeToMemTTL,omitempty"`
	FreezeToDiskTTL string   `json:"freezeToDiskTTL,omitempty"`
	Enable          *bool    `json:"enable,omitempty"`
}

type AutoFreezeAndResume struct {
	AutoFreeze         []AutoFreeze             `json:"autoFreeze,omitempty"`
	IntelligenceWarmup SmartSchedulerModelInput `json:"intelligenceWarmup,omitempty"`
}

type AutoScalingConfig struct {
	// Adjust baseline requests and limits to match the actual usage using recent metrics
	AutoSetResources *AutoSetResources `json:"autoSetResources,omitempty"`

	// CronScalingRules defines a list of CronScaling rules used to schedule scaling actions based on cron expressions.
	CronScalingRules []CronScalingRule `json:"cronScalingRules,omitempty"`

	ExternalScaler *ExternalScalerConfig `json:"externalScaler,omitempty"`
}

type AutoSetResources struct {
	Enable bool `json:"enable,omitempty"`

	// Target resource to scale, such as "compute", "vram", or "all" by default
	TargetResource ScalingTargetResource `json:"targetResource,omitempty"`

	// Tflops usage percentile that will be used as a base for tflops target recommendation. Default: 0.9
	TargetComputePercentile string `json:"targetComputePercentile,omitempty"`

	// Tflops usage percentile that will be used for the lower bound on tflops recommendation. Default: 0.5
	LowerBoundComputePercentile string `json:"lowerBoundComputePercentile,omitempty"`

	// Tflops usage percentile that will be used for the upper bound on tflops recommendation. Default: 0.95
	UpperBoundComputePercentile string `json:"upperBoundComputePercentile,omitempty"`

	// Vram usage percentile that will be used as a base for vram target recommendation. Default: 0.9
	TargetVRAMPercentile string `json:"targetVRAMPercentile,omitempty"`

	// Vram usage percentile that will be used for the lower bound on vram recommendation. Default: 0.5
	LowerBoundVRAMPercentile string `json:"lowerBoundVRAMPercentile,omitempty"`

	// Vram usage percentile that will be used for the upper bound on vram recommendation. Default: 0.95
	UpperBoundVRAMPercentile string `json:"upperBoundVRAMPercentile,omitempty"`

	// Fraction of usage added as the safety margin to the recommended request. Default: 0.15
	MarginFraction string `json:"marginFraction,omitempty"`

	// Only when the difference between the recommended request and the current request is greater than this threshold, the request will be updated. Default: 0.1
	// This value can't greater than MarginFraction, otherwise no update will be made since always inside the threshold after multiplying MarginFraction.
	UpdateThreshold string `json:"updateThreshold,omitempty"`

	// How much time back TSDB have to be queried to get historical metrics. Default: 2h
	HistoryDataPeriod string `json:"historyDataPeriod,omitempty"`

	// Min scaling ratio to original resources, e.g. request 10Gi, ratio 0.5, scale down limit to 5Gi, default: 0.2
	MinVRAMResourcesRatio string `json:"minVRAMResourcesRatio,omitempty"`

	// Max scaling ratio to original resources, e.g. request 10Gi, ratio 2.0, scale up limit to 20Gi, default: 5.0
	MaxVRAMResourcesRatio string `json:"maxVRAMResourcesRatio,omitempty"`

	// Min scaling ratio to original resources, e.g. request 10Gi, ratio 0.5, scale down limit to 5Gi, default: 0.1
	// This ratio only apply to tflops/compute request rather than limit, to avoid performance downgrade when not used for a long time
	MinComputeResourcesRatio string `json:"minComputeResourcesRatio,omitempty"`

	// Max scaling ratio to original resources, e.g. request 10Gi, ratio 2.0, scale up limit to 20Gi, default: 10.0
	MaxComputeResourcesRatio string `json:"maxComputeResourcesRatio,omitempty"`

	// When workload is created, wait for this period to collect enough metrics before scaling, default: 30m
	InitialDelayPeriod string `json:"initialDelayPeriod,omitempty"`

	// How often to evaluate the scaling operation, default: same as global config's auto scaling interval
	Interval string `json:"interval,omitempty"`
}

type BudgetExceedStrategy string

type CapacityConfig struct {
	// +optional
	MinResources *GPUOrCPUResourceUnit `json:"minResources,omitempty"`

	// +optional
	MaxResources *GPUOrCPUResourceUnit `json:"maxResources,omitempty"`

	// +optional
	WarmResources *GPUOrCPUResourceUnit `json:"warmResources,omitempty"`

	// +optional
	Oversubscription *Oversubscription `json:"oversubscription,omitempty"`
}

type CapacityTypeEnum string

type ClientConfig struct {
	// Image is the default client image, used when no ProviderConfig is found for the vendor
	// When ProviderConfig exists, remoteClient image from ProviderConfig takes precedence
	Image string `json:"image,omitempty"`

	OperatorEndpoint string `json:"operatorEndpoint,omitempty"`

	// +optional
	PatchToPod *runtime.RawExtension `json:"patchToPod,omitempty"`

	// +optional
	PatchToContainer *runtime.RawExtension `json:"patchToContainer,omitempty"`
}

type ComponentConfig struct {
	// +optional
	Worker *WorkerConfig `json:"worker,omitempty"`

	// +optional
	Hypervisor *HypervisorConfig `json:"hypervisor,omitempty"`

	// +optional
	Client *ClientConfig `json:"client,omitempty"`
}

type ComputingVendorConfig struct {
	Name string `json:"name,omitempty"`

	// support popular cloud providers
	Type ComputingVendorName `json:"type,omitempty"`

	AuthType AuthTypeEnum `json:"authType,omitempty"` // Authentication type (e.g., accessKey, serviceAccount).

	// +optional
	// +kubebuilder:default=true
	Enable *bool `json:"enable,omitempty"` // Enable or disable the computing vendor.

	Params ComputingVendorParams `json:"params,omitempty"`
}

type ComputingVendorName string

type ComputingVendorParams struct {
	// +optional
	DefaultRegion string `json:"defaultRegion,omitempty"` // Region for the computing vendor.

	// the secret of access key and secret key or config file, must be mounted as file path
	// +optional
	AccessKeyPath string `json:"accessKeyPath,omitempty"`
	// +optional
	SecretKeyPath string `json:"secretKeyPath,omitempty"`

	// preferred IAM role since it's more secure
	// +optional
	IAMRole string `json:"iamRole,omitempty"`

	// +optional
	ConfigFile string `json:"configFile,omitempty"`

	// +optional
	// User can set extra cloud vendor params, eg.
	// in ali cloud:" spotPriceLimit, spotDuration, spotInterruptionBehavior, systemDiskCategory, systemDiskSize, dataDiskPerformanceLevel
	// in aws cloud: TODO
	ExtraParams map[string]string `json:"extraParams,omitempty"`
}

type CronScalingRule struct {
	// Enable specifies whether the cron scaler is enabled.
	Enable bool `json:"enable,omitempty"`
	// Name is the identifier for the cron scaler.
	Name string `json:"name,omitempty"`
	// Start is the start time for the scaling schedule, in cron format.
	Start string `json:"start,omitempty"`
	// End is the end time for the scaling schedule, in cron format.
	End string `json:"end,omitempty"`
	// DesiredResources specifies the target resources to scale to during the schedule.
	DesiredResources Resources `json:"desiredResources,omitempty"`
}

type DevicePluginDetectionConfig struct {
	// ResourceNamePrefixes are prefixes used to identify this vendor's device plugin resources
	// e.g., ["nvidia.com/gpu", "nvidia.com/mig"] for NVIDIA
	// +optional
	ResourceNamePrefixes []string `json:"resourceNamePrefixes,omitempty"`

	// UsedBySystemName is the identifier for workloads using this vendor's native device plugin
	// +optional
	UsedBySystemName string `json:"usedBySystemName,omitempty"`
}

type ElasticRateLimitParameters struct {
	// Refill rate is controlled by PID controller, adjusted by current utilization
	MaxRefillRate string `json:"maxRefillRate,omitempty"`
	MinRefillRate string `json:"minRefillRate,omitempty"`

	// Filter ineffective requests from rate limit, 0.0 to 1.0
	FilterAlpha string `json:"filterAlpha,omitempty"`

	// PID controller parameters
	Ki string `json:"ki,omitempty"`
	Kd string `json:"kd,omitempty"`
	Kp string `json:"kp,omitempty"`

	// Burst window to control token bucket Min/Max (currentCapacity = burstWindow x currentRefillRate)
	BurstWindow string `json:"burstWindow,omitempty"`
	// token bucket min and max
	CapacityMin string `json:"capacityMin,omitempty"`
	CapacityMax string `json:"capacityMax,omitempty"`

	// Decay factor for integral term in PID controller, to avoid integral windup
	IntegralDecayFactor string `json:"integralDecayFactor,omitempty"`
}

type ExternalScalerConfig struct {
	Enable bool `json:"enable,omitempty"`

	URL string `json:"url,omitempty"`

	// API key will be set into the request header as "Authorization: Bearer <api key>"
	APIKeySecretRef *v1.SecretReference `json:"apiKeySecretRef,omitempty"`

	InitialDelayPeriod string `json:"initialDelayPeriod,omitempty"`

	// How often to evaluate the scaling operation, default: same as global config's auto scaling interval
	Interval string `json:"interval,omitempty"`
}

type ExternalScalerRequest struct {
	WorkloadName     string    `json:"workloadName,omitempty"`
	Namespace        string    `json:"namespace,omitempty"`
	CurrentResources Resources `json:"currentResources,omitempty"`
}

type ExternalScalerResponse struct {
	NeedScaleUp   bool `json:"needScaleUp,omitempty"`
	NeedScaleDown bool `json:"needScaleDown,omitempty"`

	// Explain why the scaling operation is needed or not needed, recorded to event and workload status
	Reason string `json:"reason,omitempty"`

	// If no scaling operation needed, this could be zero value
	RecommendedResources Resources `json:"recommendedResources,omitempty"`
}

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

	Status GPUStatus `json:"status,omitempty"`
}

type GPUAllocationInfo struct {
	Request   Resource `json:"request,omitempty"`
	Limit     Resource `json:"limit,omitempty"`
	PodName   string   `json:"podName,omitempty"`
	PodUID    string   `json:"podUID,omitempty"`
	Namespace string   `json:"namespace,omitempty"`
}

type GPUFilter struct {
	Type   string               `json:"type,omitempty"`
	Params runtime.RawExtension `json:"params,omitempty"`
}

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

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

	Spec   GPUNodeSpec   `json:"spec,omitempty"`
	Status GPUNodeStatus `json:"status,omitempty"`
}

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

	Spec   GPUNodeClaimSpec   `json:"spec,omitempty"`
	Status GPUNodeClaimStatus `json:"status,omitempty"`
}

type GPUNodeClaimList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []GPUNodeClaim `json:"items"`
}

type GPUNodeClaimPhase string

type GPUNodeClaimSpec struct {
	NodeName     string           `json:"nodeName,omitempty"`
	Region       string           `json:"region,omitempty"`
	Zone         string           `json:"zone,omitempty"`
	InstanceType string           `json:"instanceType,omitempty"`
	NodeClassRef GroupKindName    `json:"nodeClassRef,omitempty"`
	CapacityType CapacityTypeEnum `json:"capacityType,omitempty"`

	TFlopsOffered    resource.Quantity `json:"tflopsOffered"`
	VRAMOffered      resource.Quantity `json:"vramOffered"`
	GPUDeviceOffered int32             `json:"gpuDeviceOffered"`

	ExtraParams map[string]string `json:"extraParams,omitempty"`
}

type GPUNodeClaimStatus struct {

	// +kubebuilder:default=Pending
	Phase GPUNodeClaimPhase `json:"phase"`

	InstanceID string `json:"instanceID,omitempty"`
}

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

	Spec   GPUNodeClassSpec   `json:"spec,omitempty"`
	Status GPUNodeClassStatus `json:"status,omitempty"`
}

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

type GPUNodeClassSpec struct {
	// +optional
	// The launch template to use for VM instances, if set, all other fields could be skipped
	LaunchTemplate NodeClassItemSelectorTerms `json:"launchTemplate"`

	// +optional
	// Could be private or public, varies in different cloud vendor, define where to query the OSImageID
	// +kubebuilder:default="Private"
	OSImageType OSImageTypeEnum `json:"osImageType,omitempty"`

	// the OS image identifier string, default to use first one, if not found, fallback to others
	OSImageSelectorTerms []NodeClassItemSelectorTerms `json:"osImageSelectorTerms,omitempty"`

	// +optional
	// The instance profile to use, assign IAM role and permissions for EC2 instances
	InstanceProfile string `json:"instanceProfile,omitempty"`

	// +optional
	// for AWS only, IMDSv2 metadata service options
	MetadataOptions *NodeClassMetadataOptions `json:"metadataOptions,omitempty"`

	// +optional
	SecurityGroupSelectorTerms []NodeClassItemSelectorTerms `json:"securityGroupSelectorTerms,omitempty"`

	// +optional
	SubnetSelectorTerms []NodeClassItemSelectorTerms `json:"subnetSelectorTerms,omitempty"` // Terms to select subnets

	// +optional
	BlockDeviceMappings []NodeClassBlockDeviceMappings `json:"blockDeviceMappings,omitempty"` // Block device mappings for the instance

	// +optional
	Tags map[string]string `json:"tags,omitempty"` // Tags associated with the resource

	// +optional
	UserData string `json:"userData,omitempty"` // User data script for the instance
}

type GPUNodeClassStatus struct {
}

type GPUNodeInfo struct {
	// Additional space for L1/L2 VRAM buffer
	RAMSize      resource.Quantity `json:"ramSize,omitempty"`
	DataDiskSize resource.Quantity `json:"dataDiskSize,omitempty"`
}

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

type GPUNodeManageMode string

type GPUNodeSpec struct {

	// +kubebuilder:default=AutoSelect
	ManageMode GPUNodeManageMode `json:"manageMode,omitempty"`

	// +optional
	CostPerHour string `json:"costPerHour,omitempty"`

	// if not all GPU cards should be used, specify the GPU card indices, default to empty,
	// onboard all GPU cards to the pool
	// +optional
	GPUCardIndices []int `json:"gpuCardIndices,omitempty"`

	// +optional
	CloudVendorParam string `json:"cloudVendorParam,omitempty"`
}

type GPUNodeStatus struct {
	// +kubebuilder:default=Pending
	Phase TensorFusionGPUNodePhase `json:"phase"`

	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	TotalTFlops resource.Quantity `json:"totalTFlops"`
	TotalVRAM   resource.Quantity `json:"totalVRAM"`

	// +optional
	VirtualTFlops resource.Quantity `json:"virtualTFlops,omitempty"`
	// +optional
	VirtualVRAM resource.Quantity `json:"virtualVRAM,omitempty"`

	// +optional
	AvailableTFlops resource.Quantity `json:"availableTFlops,omitempty"`
	// +optional
	AvailableVRAM resource.Quantity `json:"availableVRAM,omitempty"`

	// +optional
	VirtualAvailableTFlops *resource.Quantity `json:"virtualAvailableTFlops,omitempty"`
	// +optional
	VirtualAvailableVRAM *resource.Quantity `json:"virtualAvailableVRAM,omitempty"`

	// +optional
	HypervisorStatus NodeHypervisorStatus `json:"hypervisorStatus,omitempty"`

	// +optional
	NodeInfo GPUNodeInfo `json:"nodeInfo,omitempty"`

	// +optional
	LoadedModels *[]string `json:"loadedModels,omitempty"`

	TotalGPUs   int32 `json:"totalGPUs"`
	ManagedGPUs int32 `json:"managedGPUs"`

	// +optional
	ManagedGPUDeviceIDs []string `json:"managedGPUDeviceIDs,omitempty"`

	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// +optional
	TotalGPUPods int32 `json:"totalGPUPods,omitempty"`

	// +optional
	AllocatedPods map[string][]*PodGPUInfo `json:"allocatedPods,omitempty"`
}

type GPUOrCPUResourceUnit struct {
	TFlops resource.Quantity `json:"tflops,omitempty"`

	VRAM resource.Quantity `json:"vram,omitempty"`

	// CPU/Memory is only available when CloudVendor connection is enabled
	// +optional
	CPU resource.Quantity `json:"cpu,omitempty"`

	// +optional
	Memory resource.Quantity `json:"memory,omitempty"`
}

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

	Spec   GPUPoolSpec   `json:"spec,omitempty"`
	Status GPUPoolStatus `json:"status,omitempty"`
}

type GPUPoolDefinition struct {
	Name string `json:"name,omitempty"` // Name of the GPU pool.

	IsDefault bool `json:"isDefault,omitempty"`

	SpecTemplate GPUPoolSpec `json:"specTemplate"`
}

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

type GPUPoolSpec struct {

	// +optional
	DefaultUsingLocalGPU *bool `json:"defaultUsingLocalGPU,omitempty"`

	CapacityConfig *CapacityConfig `json:"capacityConfig,omitempty"`

	// +required
	NodeManagerConfig *NodeManagerConfig `json:"nodeManagerConfig,omitempty"`

	// +optional
	QosConfig *QosConfig `json:"qosConfig,omitempty"`

	// +optional
	ComponentConfig *ComponentConfig `json:"componentConfig,omitempty"`

	// +optional
	SchedulingConfigTemplate *string `json:"schedulingConfigTemplate,omitempty"`
}

type GPUPoolStatus struct {
	Cluster string `json:"cluster,omitempty"`

	// +kubebuilder:default=Pending
	Phase TensorFusionPoolPhase `json:"phase"`

	Conditions []metav1.Condition `json:"conditions,omitempty"`

	TotalNodes    int32 `json:"totalNodes,omitempty"`
	TotalGPUs     int32 `json:"totalGPUs,omitempty"`
	ReadyNodes    int32 `json:"readyNodes"`
	NotReadyNodes int32 `json:"notReadyNodes"`

	TotalTFlops resource.Quantity `json:"totalTFlops"`
	TotalVRAM   resource.Quantity `json:"totalVRAM"`

	VirtualTFlops resource.Quantity `json:"virtualTFlops"`
	VirtualVRAM   resource.Quantity `json:"virtualVRAM"`

	AvailableTFlops resource.Quantity `json:"availableTFlops"`
	AvailableVRAM   resource.Quantity `json:"availableVRAM"`

	RunningAppsCnt int32 `json:"runningAppsCnt,omitempty"`

	// +optional
	VirtualAvailableTFlops *resource.Quantity `json:"virtualAvailableTFlops,omitempty"`
	// +optional
	VirtualAvailableVRAM *resource.Quantity `json:"virtualAvailableVRAM,omitempty"`

	// when updating any component version or config, pool controller will perform rolling update.
	// the status will be updated periodically, default to 5s, progress will be 0-100.
	// when the progress is 100, the component version or config is fully updated.
	ComponentStatus PoolComponentStatus `json:"componentStatus"`

	// TODO: aggregated with interval
	SavedCostsPerMonth       string `json:"savedCostsPerMonth,omitempty"`
	PotentialSavingsPerMonth string `json:"potentialSavingsPerMonth,omitempty"`

	// +kubebuilder:default=""
	// If the budget is exceeded, the set value in comma separated string to indicate which period caused the exceeding.
	// If this field is not empty, scheduler will not schedule new AI workloads and stop scaling-up check.
	// TODO not implemented yet
	BudgetExceeded string `json:"budgetExceeded,omitempty"`

	// +optional
	// +kubebuilder:default="None"
	ProvisioningPhase ProvisioningPhase `json:"provisioningPhase,omitempty"`

	// +optional
	LastCompactionTime *metav1.Time `json:"lastCompactionTime,omitempty"`
}

type GPUResourceAvailablePercent struct {
	// +optional
	RequestsTFlops string `json:"requests.tflops,omitempty"`

	// +optional
	RequestsVRAM string `json:"requests.vram,omitempty"`

	// +optional
	LimitsTFlops string `json:"limits.tflops,omitempty"`

	// +optional
	LimitsVRAM string `json:"limits.vram,omitempty"`

	// +optional
	Workers string `json:"workers,omitempty"`
}

type GPUResourcePricingUnit struct {

	// +kubebuilder:default="$0.0069228"
	PerFP16TFlopsPerHour string `json:"perFP16TFlopsPerHour,omitempty"`

	// +kubebuilder:default="$0.01548"
	PerGBOfVRAMPerHour string `json:"perGBOfVRAMPerHour,omitempty"`
}

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

	Spec   GPUResourceQuotaSpec   `json:"spec,omitempty"`
	Status GPUResourceQuotaStatus `json:"status,omitempty"`
}

type GPUResourceQuotaConditionType string

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

type GPUResourceQuotaSingle struct {
	// Maximum resources per workload
	// +optional
	MaxRequests *Resource `json:"maxRequests,omitempty"`

	// +optional
	MaxLimits *Resource `json:"maxLimits,omitempty"`

	// +optional
	MaxGPUCount *int32 `json:"maxGPUCount,omitempty"`

	// Default limits applied to workloads without explicit limits
	// +optional
	DefaultRequests *Resource `json:"defaultRequests,omitempty"`

	// Default requests applied to workloads without explicit requests
	// +optional
	DefaultLimits *Resource `json:"defaultLimits,omitempty"`
}

type GPUResourceQuotaSpec struct {
	// Total namespace limits (similar to ResourceQuotas)
	Total GPUResourceQuotaTotal `json:"total,omitempty"`

	// Per-workload limits (similar to LimitRanges)
	Single GPUResourceQuotaSingle `json:"single,omitempty"`
}

type GPUResourceQuotaStatus struct {
	// Current resource usage in the namespace
	Used GPUResourceUsage `json:"used,omitempty"`

	// Available percentage for each resource type
	AvailablePercent GPUResourceAvailablePercent `json:"availablePercent,omitempty"`

	// Conditions represent the latest available observations of the quota's state
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// LastUpdateTime is the last time the status was updated
	// +optional
	LastUpdateTime *metav1.Time `json:"lastUpdateTime,omitempty"`
}

type GPUResourceQuotaTotal struct {
	// Total requests limits for the namespace
	// +optional
	Requests *Resource `json:"requests,omitempty"`

	// Total limits for the namespace
	// +optional
	Limits *Resource `json:"limits,omitempty"`

	// Maximum number of workers in the namespace
	// +optional
	// +kubebuilder:default=32768
	MaxWorkers *int32 `json:"maxWorkers,omitempty"`

	// Alert threshold percentage (0-100)
	// When usage exceeds this percentage, an alert event will be triggered
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=100
	// +kubebuilder:default=95
	// +optional
	AlertThresholdPercent *int32 `json:"alertThresholdPercent,omitempty"`
}

type GPUResourceUnit struct {
	// Tera floating point operations per second
	TFlops resource.Quantity `json:"tflops,omitempty"`

	// VRAM is short for Video memory, namely GPU RAM
	VRAM resource.Quantity `json:"vram,omitempty"`
}

type GPUResourceUsage struct {
	// Current requests usage
	// +optional
	Requests Resource `json:"requests,omitempty"`

	// Current limits usage
	// +optional
	Limits Resource `json:"limits,omitempty"`

	// Current number of workers
	// +optional
	Workers int32 `json:"workers,omitempty"`
}

type GPUStatus struct {
	// +kubebuilder:default=Pending
	Phase TensorFusionGPUPhase `json:"phase"`

	// +kubebuilder:default="NVIDIA"
	Vendor string `json:"vendor"`

	Capacity  *Resource `json:"capacity"`
	Available *Resource `json:"available"`

	UUID string `json:"uuid"`

	// +optional
	// +kubebuilder:default=soft
	IsolationMode IsolationModeType `json:"isolationMode,omitempty"`

	// +optional
	Index *int32 `json:"index,omitempty"`

	// When it's -1, it means the GPU is not assigned to any NUMA node
	// +optional
	NUMANode *int32 `json:"numaNode,omitempty"`

	// The host match selector to schedule worker pods
	NodeSelector map[string]string `json:"nodeSelector"`
	GPUModel     string            `json:"gpuModel"`

	// GPU is used by tensor-fusion or nvidia-operator
	// This is the key to be compatible with nvidia-device-plugin to avoid resource overlap
	// Hypervisor will watch kubelet device plugin to report all GPUs already used by nvidia-device-plugin
	// GPUs will be grouped by usedBy to be used by different Pods,
	// tensor-fusion annotation or nvidia-device-plugin resource block
	// +optional
	UsedBy UsedBySystem `json:"usedBy,omitempty"`

	Message string `json:"message"`

	// +optional
	RunningApps []*RunningAppDetail `json:"runningApps,omitempty"`

	// +optional
	// AllocatedPartitions tracks allocated partitions on this GPU
	// Key is partitionUUID, value contains template info and allocated resources
	AllocatedPartitions map[string]AllocatedPartition `json:"allocatedPartitions,omitempty"`
}

type GangSchedulingConfig struct {
	// MinMembers specifies the minimum number of pods that must be scheduled together
	// When > 0, gang scheduling is enabled for this workload
	// The gang group name is automatically derived from the workload name (namespace/workload-name)
	// +kubebuilder:validation:Minimum=0
	MinMembers int32 `json:"minMembers,omitempty"`

	// Timeout specifies how long to wait for all gang members to be schedulable
	// If not set or set to "0s", wait indefinitely until resources are available
	// Example values: "5m", "10m", "1h"
	// +optional
	Timeout *metav1.Duration `json:"timeout,omitempty"`
}

type GroupKindName struct {
	Group   string `json:"group"`
	Kind    string `json:"kind"`
	Version string `json:"version"`
	Name    string `json:"name"`
}

type HardwareModelInfo struct {
	// Model is the short model identifier (e.g., "A100_SXM_80G", "RTX4090")
	// +kubebuilder:validation:Required
	Model string `json:"model"`

	// FullModelName is the full human-readable name (e.g., "NVIDIA A100-SXM4-80GB")
	// +kubebuilder:validation:Required
	FullModelName string `json:"fullModelName"`

	// CostPerHour is the average cost per hour for this GPU model
	// +optional
	CostPerHour string `json:"costPerHour,omitempty"`

	// Fp16TFlops is the FP16 performance in TFlops
	// +kubebuilder:validation:Required
	Fp16TFlops resource.Quantity `json:"fp16TFlops"`

	// MaxPartitions is the maximum number of partitions this GPU can support
	// +optional
	MaxPartitions uint32 `json:"maxPartitions,omitempty"`

	// MaxPlacementSlots is the maximum number of placement slots (e.g., 8 for NVIDIA MIG)
	// +optional
	MaxPlacementSlots uint32 `json:"maxPlacementSlots,omitempty"`

	// MaxIsolationGroups is the maximum number of isolation groups (e.g., 4 for Ascend vGroups)
	// +optional
	MaxIsolationGroups uint32 `json:"maxIsolationGroups,omitempty"`

	// TotalExtendedResources defines the total capacity of extended resources
	// For Ascend NPU: {"AICORE": 8, "AICPU": 7, "VPC": 12, ...}
	// +optional
	TotalExtendedResources map[string]uint32 `json:"totalExtendedResources,omitempty"`

	// PartitionTemplateRefs contains references to virtualization templates
	// Use template IDs defined in VirtualizationTemplates
	// +optional
	PartitionTemplateRefs []string `json:"partitionTemplateRefs,omitempty"`
}

type HypervisorConfig struct {
	// Image is the default hypervisor image, used when no ProviderConfig is found for the vendor
	// When ProviderConfig exists, middleware image from ProviderConfig takes precedence
	Image string `json:"image,omitempty"`

	VectorImage string `json:"vectorImage,omitempty"`

	// +kubebuilder:default=8000
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=65535
	// +optional
	PortNumber *int32 `json:"portNumber,omitempty"`

	// +optional
	PodTemplate *runtime.RawExtension `json:"podTemplate,omitempty"`

	// +optional
	EnableVector bool `json:"enableVector,omitempty"`
}

type HypervisorScheduling struct {
	// additional layer to save VRAM, auto-freeze memory and cool down to RAM and Disk
	// Hypervisor will monitor and trigger freeze of inactive workers, Operator should mark them as scaled-to-zero and release the GPU pool resources, don't scale down CPU client part, so that they can continue to serve the traffic or scale down by other auto-scaling solutions like KEDA/KNative
	AutoFreezeAndResume AutoFreezeAndResume `json:"autoFreezeAndResume,omitempty"`

	// Hypervisor will move low priority jobs to pending queue if GPU is full
	// This config can adjust hypervisor's queueing behavior to balance the co-scheduling CUDA calls
	ElasticRateLimitParameters ElasticRateLimitParameters `json:"elasticRateLimitParameters,omitempty"`

	// +optional
	// For differentiate QoS levels, ensure critical and high QoS workloads on same GPU card getting more computing resources
	MultiProcessQueuingParameters MultiProcessQueuingParameters `json:"multiProcessQueuingParameters,omitempty"`
}

type IsolationModeType string

type MaintenanceWindow struct {
	// crontab syntax.
	Includes []string `json:"includes,omitempty"`
}

type MultiProcessQueuingParameters struct {
	// Condition for triggering scale down when usage is above ComputingThresholdForPreempt
	ComputingThresholdForPreempt string `json:"computingThresholdForPreempt,omitempty"`
	TriggerPreemptDuration       string `json:"triggerPreemptDuration,omitempty"`

	// Condition for triggering scale up when usage is below ComputingThresholdForResume
	ComputingThresholdForResume string `json:"computingThresholdForResume,omitempty"`
	TriggerResumeDuration       string `json:"triggerResumeDuration,omitempty"`

	// Coefficient for scale down when resource contention happens
	CoefficientLow    string `json:"coefficientLow,omitempty"`
	CoefficientMedium string `json:"coefficientMedium,omitempty"`
	CoefficientHigh   string `json:"coefficientHigh,omitempty"`

	// When avg utilization < ComputingThresholdForResume and last for more than TriggerResumeDuration
	// Use following formula to scale up:
	// Case #1 If all process has same QoS level, and cur_limit <= limit, fast resume to limit
	// Case #2 Else, Max(limit, Min(cur_limit * 1/CoEfficient * SlowStartRatio, cur_limit * 1.2))
	SlowStartRatio string `json:"slowStartRatio,omitempty"`
}

type NameNamespace struct {
	Name      string `json:"name,omitempty"`
	Namespace string `json:"namespace,omitempty"`
}

type NodeClassBlockDeviceMappings struct {
	// +optional
	DeviceName string `json:"deviceName,omitempty"` // The device name for the block device

	EBS NodeClassBlockDeviceSettings `json:"ebs,omitempty"`
}

type NodeClassBlockDeviceSettings struct {
	VolumeSize string `json:"volumeSize,omitempty"`

	// +optional
	// Default value would varies based on the cloud vendor
	// For AWS it's gp3, for Alicloud it's cloud_essd
	VolumeType string `json:"volumeType,omitempty"`

	// +optional
	// +kubebuilder:default=true
	DeleteOnTermination bool `json:"deleteOnTermination,omitempty"` // Whether to delete the EBS volume on termination

	// +optional
	// +kubebuilder:default=true
	Encrypted bool `json:"encrypted,omitempty"` // Whether the EBS volume is encrypted

}

type NodeClassItemSelectorTerms struct {

	// +optional
	// The item ID
	ID string `json:"id,omitempty"`

	// +optional
	// The item name
	Name string `json:"name,omitempty"`

	// +optional
	// Query by tags
	Tags map[string]string `json:"tags,omitempty"`
}

type NodeClassMetadataOptions struct {
	// +optional
	// +kubebuilder:default=true
	HttpEndpoint bool `json:"httpEndpoint,omitempty"`

	// +optional
	// +kubebuilder:default=false
	HttpProtocolIPv6 bool `json:"httpProtocolIPv6,omitempty"`

	// +optional
	// +kubebuilder:default=1
	HttpPutResponseHopLimit int `json:"httpPutResponseHopLimit,omitempty"`

	// +optional
	// +kubebuilder:default="required"
	HttpTokens string `json:"httpTokens,omitempty"`
}

type NodeCompaction struct {
	// +kubebuilder:default="5m"
	Period string `json:"period,omitempty"`
}

type NodeHypervisorStatus struct {
	HypervisorState   string      `json:"hypervisorState,omitempty"`
	HypervisorVersion string      `json:"hypervisorVersion,omitempty"`
	LastHeartbeatTime metav1.Time `json:"lastHeartbeatTime,omitempty"`
}

type NodeManagerConfig struct {
	// +kubebuilder:default="AutoSelect"
	ProvisioningMode ProvisioningMode `json:"provisioningMode,omitempty"`

	// +optional
	// +kubebuilder:default=NVIDIA
	// In single AI accelerator hardware vendor mode, when default vendor set
	// All nodes provisioned by NodeProvisioner or selected by NodeSelector will be set with vendor label
	DefaultVendor string `json:"defaultVendor,omitempty"`

	// +optional
	NodeProvisioner *NodeProvisioner `json:"nodeProvisioner,omitempty"`

	// +optional
	NodeSelector *corev1.NodeSelector `json:"nodeSelector,omitempty"`

	// +optional
	// When this field set, the GPU pool will be in multi AI accelerator vendor mode
	// each GPU node's vendor name is set to map key, e.g. { AMD: { nodeSelectorTerms }}
	MultiVendorNodeSelector map[string]*corev1.NodeSelector `json:"multiVendorNodeSelector,omitempty"`

	// +optional
	NodeCompaction *NodeCompaction `json:"nodeCompaction,omitempty"`

	// +optional
	NodePoolRollingUpdatePolicy *NodeRollingUpdatePolicy `json:"nodePoolRollingUpdatePolicy,omitempty"`
}

type NodeProvisioner struct {

	// TensorFusion GPUNodeClass name
	NodeClass string `json:"nodeClass,omitempty"`

	// Karpenter NodeClass name
	// +optional
	KarpenterNodeClassRef *GroupKindName `json:"karpenterNodeClassRef,omitempty"`

	// +optional
	GPURequirements []Requirement `json:"gpuRequirements,omitempty"`
	// +optional
	GPUTaints []Taint `json:"gpuTaints,omitempty"`
	// +optional
	GPULabels map[string]string `json:"gpuNodeLabels,omitempty"`

	// +optional
	CPURequirements []Requirement `json:"cpuRequirements,omitempty"`
	// +optional
	CPUTaints []Taint `json:"cpuTaints,omitempty"`
	// +optional
	CPULabels map[string]string `json:"cpuNodeLabels,omitempty"`
	// +optional
	GPUAnnotation map[string]string `json:"gpuNodeAnnotations,omitempty"`

	// +optional
	// NodeProvisioner will start an virtual billing based on public pricing or customized pricing, if the VM's costs exceeded any budget constraints, the new VM will not be created, and alerts will be generated
	Budget *PeriodicalBudget `json:"budget,omitempty"`
}

type NodeRequirementKey string

type NodeRollingUpdatePolicy struct {

	// +optional
	AutoUpdateHypervisor bool `json:"autoUpdateHypervisor,omitempty"`

	// +optional
	AutoUpdateWorker bool `json:"autoUpdateWorker,omitempty"`

	// +optional
	AutoUpdateClient bool `json:"autoUpdateClient,omitempty"`

	// +kubebuilder:default=100
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=100
	BatchPercentage int32 `json:"batchPercentage,omitempty"`

	// +kubebuilder:default="1s"
	BatchInterval string `json:"batchInterval,omitempty"`

	// +optional
	// +kubebuilder:default="10m"
	MaxDuration string `json:"maxDuration,omitempty"`

	// +optional
	MaintenanceWindow MaintenanceWindow `json:"maintenanceWindow,omitempty"`
}

type OSImageTypeEnum string

type Oversubscription struct {
	// the percentage of Host RAM appending to GPU VRAM, default to 50%
	// +optional
	// +kubebuilder:default=50
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=100
	VRAMExpandToHostMem int32 `json:"vramExpandToHostMem,omitempty"`

	// the percentage of Host Disk appending to GPU VRAM, default to 70%
	// +optional
	// +kubebuilder:default=70
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=100
	VRAMExpandToHostDisk int32 `json:"vramExpandToHostDisk,omitempty"`

	// The multi of TFlops to oversell, default to 500%, indicates 5 times oversell
	// +optional
	// +kubebuilder:default=500
	// +kubebuilder:validation:Minimum=100
	// +kubebuilder:validation:Maximum=100000
	TFlopsOversellRatio int32 `json:"tflopsOversellRatio,omitempty"`
}

type PartitionTemplate struct {
	// TemplateID is the unique identifier for this partition template (e.g., "1g.24gb", "4g.94gb")
	TemplateID string `json:"templateId"`

	// Name is a human-readable name for this template
	Name string `json:"name"`
}

type PeriodicalBudget struct {
	// +kubebuilder:default="100"
	BudgetPerDay string `json:"budgetPerDay,omitempty"`

	// +kubebuilder:default="1000"
	BudgetPerMonth string `json:"budgetPerMonth,omitempty"`

	// +kubebuilder:default="3000"
	BudgetPerQuarter string `json:"budgetPerQuarter,omitempty"`

	// +kubebuilder:default=AlertOnly
	BudgetExceedStrategy BudgetExceedStrategy `json:"budgetExceedStrategy,omitempty"`
}

type PlacementConfig struct {
	// +kubebuilder:default=NodeCompactGPULowLoad
	Mode PlacementMode `json:"mode"`

	// +kubebuilder:default=true
	// +optional
	AllowUsingLocalGPU *bool `json:"allowUsingLocalGPU,omitempty"` // If false, workloads will not be scheduled directly to GPU nodes with 'localGPU: true'.

	// +optional
	GPUFilters []GPUFilter `json:"gpuFilters,omitempty"`
}

type PlacementMode string

type PodGPUInfo struct {
	Name      string   `json:"name,omitempty"`
	Namespace string   `json:"namespace,omitempty"`
	UID       string   `json:"uid,omitempty"`
	Requests  Resource `json:"requests,omitempty"`
	Limits    Resource `json:"limits,omitempty"`
	QoS       QoSLevel `json:"qos,omitempty"`

	// IsExternal indicates if this allocation is from an external device plugin
	// (e.g., nvidia-device-plugin) rather than TensorFusion scheduler
	// +optional
	IsExternal bool `json:"isExternal,omitempty"`
}

type PoolComponentStatus struct {
	WorkerVersion        string `json:"worker,omitempty"`
	WorkerConfigSynced   bool   `json:"workerConfigSynced,omitempty"`
	WorkerUpdateProgress int32  `json:"workerUpdateProgress,omitempty"`

	HypervisorVersion        string `json:"hypervisor,omitempty"`
	HypervisorConfigSynced   bool   `json:"hypervisorConfigSynced,omitempty"`
	HyperVisorUpdateProgress int32  `json:"hypervisorUpdateProgress,omitempty"`

	ClientVersion        string `json:"client,omitempty"`
	ClientConfigSynced   bool   `json:"clientConfigSynced,omitempty"`
	ClientUpdateProgress int32  `json:"clientUpdateProgress,omitempty"`
}

type PoolProvisioningStatus struct {
	InitializingNodes int32 `json:"initializingNodes,omitempty"`
	TerminatingNodes  int32 `json:"terminatingNodes,omitempty"`
	AvailableNodes    int32 `json:"availableNodes,omitempty"`
}

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

	Spec   ProviderConfigSpec   `json:"spec,omitempty"`
	Status ProviderConfigStatus `json:"status,omitempty"`
}

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

type ProviderConfigSpec struct {
	// Vendor is the hardware vendor name (e.g., NVIDIA, AMD, Ascend, Apple)
	// +kubebuilder:validation:Required
	Vendor string `json:"vendor"`

	// Images contains container images for different components
	Images ProviderImages `json:"images"`

	// Hypervisor contains vendor-specific hypervisor settings
	// +optional
	Hypervisor *ProviderHypervisorConfig `json:"hypervisor,omitempty"`

	// HardwareMetadata contains GPU/accelerator model information
	// +optional
	HardwareMetadata []HardwareModelInfo `json:"hardwareMetadata,omitempty"`

	// VirtualizationTemplates contains partition/slice templates that can be referenced by hardware metadata
	// This avoids duplicating template info across multiple GPU models
	// +optional
	VirtualizationTemplates []VirtualizationTemplate `json:"virtualizationTemplates,omitempty"`

	// InUseResourceNames contains resource names that should be removed from pods
	// when TensorFusion takes over GPU management (e.g., "nvidia.com/gpu", "amd.com/gpu")
	// +optional
	InUseResourceNames []string `json:"inUseResourceNames,omitempty"`

	// DevicePluginDetection contains settings for detecting existing device plugins
	// +optional
	DevicePluginDetection *DevicePluginDetectionConfig `json:"devicePluginDetection,omitempty"`
}

type ProviderConfigStatus struct{}

type ProviderHypervisorConfig struct {
	// PrivilegedHypervisor indicates the hypervisor container should run in privileged mode
	// +optional
	PrivilegedHypervisor bool `json:"privilegedHypervisor,omitempty"`

	// LDLibraryPath appends entries to LD_LIBRARY_PATH for the hypervisor container
	// +optional
	LDLibraryPath string `json:"ldLibraryPath,omitempty"`

	// HostPathMounts adds host path mounts to the hypervisor pod
	// +optional
	HostPathMounts []ProviderHypervisorHostPathMount `json:"hostPathMounts,omitempty"`
}

type ProviderHypervisorHostPathMount struct {
	// Name is the volume name
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// HostPath is the path on the host to mount
	// +kubebuilder:validation:Required
	HostPath string `json:"hostPath"`

	// MountPath is the path inside the container
	// +kubebuilder:validation:Required
	MountPath string `json:"mountPath"`

	// ReadOnly indicates if the mount should be read-only
	// +optional
	ReadOnly bool `json:"readOnly,omitempty"`
}

type ProviderImages struct {
	// Middleware is the hypervisor/middleware image that runs on GPU nodes
	// This image contains vendor-specific GPU drivers and runtime
	// +kubebuilder:validation:Required
	Middleware string `json:"middleware"`

	// RemoteClient is the client library image injected into user pods
	// +optional
	RemoteClient string `json:"remoteClient,omitempty"`

	// RemoteWorker is the worker process image for remote GPU access
	// +optional
	RemoteWorker string `json:"remoteWorker,omitempty"`
}

type ProvisioningMode string

type ProvisioningPhase string

type QoSLevel string

type QosConfig struct {
	Definitions []QosDefinition `json:"definitions,omitempty"`
	DefaultQoS  QoSLevel        `json:"defaultQoS,omitempty"`
	Pricing     []QosPricing    `json:"pricing,omitempty"`

	// Eviction protection price ratio applied to cost calculation during protection period
	// This multiplier increases pricing for protected workloads to discourage preemption
	// +optional
	// +kubebuilder:default="1.2"
	EvictionProtectionPriceRatio string `json:"evictionProtectionPriceRatio,omitempty"`
}

type QosDefinition struct {
	Name        QoSLevel `json:"name,omitempty"`
	Description string   `json:"description,omitempty"`
	Priority    int      `json:"priority,omitempty"` // Range from 1-100, reflects the scheduling priority when GPU is full and tasks are in the queue.
}

type QosPricing struct {
	Qos QoSLevel `json:"qos,omitempty"`

	Requests GPUResourcePricingUnit `json:"requests,omitempty"`

	// Default requests and limitsOverRequests are same, indicates normal on-demand serverless GPU usage, in hands-on lab low QoS case, limitsOverRequests should be lower, so that user can get burstable GPU resources with very low cost
	// +kubebuilder:default="1"
	LimitsOverRequestsChargingRatio string `json:"limitsOverRequests,omitempty"`
}

type ReBalanceThreshold struct {
	MatchAny runtime.RawExtension `json:"matchAny,omitempty"`
}

type ReBalancerConfig struct {
	Enable                *bool              `json:"enable,omitempty"`
	Interval              string             `json:"interval,omitempty"`
	ReBalanceCoolDownTime string             `json:"reBalanceCoolDownTime,omitempty"`
	Threshold             ReBalanceThreshold `json:"threshold,omitempty"`
}

type Requirement struct {
	Key NodeRequirementKey `json:"key,omitempty"`

	// +kubebuilder:default="In"
	// +kubebuilder:validation:Enum=In;Exists;DoesNotExist;Gt;Lt
	Operator corev1.NodeSelectorOperator `json:"operator,omitempty"`

	Values []string `json:"values,omitempty"`
}

type Resource struct {
	Tflops resource.Quantity `json:"tflops"`

	// +optional
	// 0-100 percentage, mutually exclusive with TFLOPs
	ComputePercent resource.Quantity `json:"compute,omitempty"`

	Vram resource.Quantity `json:"vram"`
}

type ResourceName string

type Resources struct {
	Requests Resource `json:"requests"`
	Limits   Resource `json:"limits"`
}

type RunningAppDetail struct {
	// Workload name namespace
	Name      string `json:"name,omitempty"`
	Namespace string `json:"namespace,omitempty"`

	// Worker count
	Count int `json:"count"`

	// Pod names that are running this workload
	// +optional
	Pods []*PodGPUInfo `json:"pods,omitempty"`
}

type ScalingTargetResource string

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

	Spec   SchedulingConfigTemplateSpec   `json:"spec,omitempty"`
	Status SchedulingConfigTemplateStatus `json:"status,omitempty"`
}

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

type SchedulingConfigTemplateSpec struct {

	// place the client or worker to best matched nodes
	Placement PlacementConfig `json:"placement"`

	// scale the workload based on the usage and traffic
	// +optional
	VerticalScalingRules []VerticalScalingRule `json:"verticalScalingRules,omitempty"`

	// avoid hot GPU devices and continuously balance the workload
	// implemented by mark GPU as hot and trigger evict for re-scheduling
	// The hot GPUs will get lower priority for scheduling
	// Future: implement rebalancer
	// +optional
	ReBalancer *ReBalancerConfig `json:"reBalancer,omitempty"`

	// single GPU device multi-process queuing and fair scheduling with QoS constraint
	// +optional
	Hypervisor *HypervisorScheduling `json:"hypervisor,omitempty"`
}

type SchedulingConfigTemplateStatus struct {
}

type SmartSchedulerModelInput struct {
	Enable            *bool  `json:"enable,omitempty"`
	Model             string `json:"model,omitempty"`
	HistoryDataPeriod string `json:"historyDataPeriod,omitempty"`
	PredictionPeriod  string `json:"predictionPeriod,omitempty"`
}

type Taint struct {
	// +kubebuilder:default=NoSchedule
	// +kubebuilder:validation:Enum=NoSchedule;NoExecute;PreferNoSchedule
	Effect corev1.TaintEffect `json:"effect,omitempty"`
	Key    string             `json:"key,omitempty"`
	Value  string             `json:"value,omitempty"`
}

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

	Spec   TensorFusionClusterSpec   `json:"spec,omitempty"`
	Status TensorFusionClusterStatus `json:"status,omitempty"`
}

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

type TensorFusionClusterPhase string

type TensorFusionClusterSpec struct {
	GPUPools []GPUPoolDefinition `json:"gpuPools,omitempty"`

	// +optional
	ComputingVendor *ComputingVendorConfig `json:"computingVendor,omitempty"`
}

type TensorFusionClusterStatus struct {

	// +kubebuilder:default=Pending
	Phase TensorFusionClusterPhase `json:"phase,omitempty"`

	Conditions []metav1.Condition `json:"conditions,omitempty"`

	TotalPools int32 `json:"totalPools"`
	TotalNodes int32 `json:"totalNodes"`
	TotalGPUs  int32 `json:"totalGPUs"`

	TotalTFlops resource.Quantity `json:"totalTFlops"`
	TotalVRAM   resource.Quantity `json:"totalVRAM"`

	VirtualTFlops resource.Quantity `json:"virtualTFlops"`
	VirtualVRAM   resource.Quantity `json:"virtualVRAM"`

	AvailableTFlops resource.Quantity `json:"availableTFlops"`
	AvailableVRAM   resource.Quantity `json:"availableVRAM"`

	// +optional
	VirtualAvailableTFlops *resource.Quantity `json:"virtualAvailableTFlops,omitempty"`
	// +optional
	VirtualAvailableVRAM *resource.Quantity `json:"virtualAvailableVRAM,omitempty"`

	// +optional
	ReadyGPUPools []string `json:"readyGPUPools"`

	// +optional
	NotReadyGPUPools []string `json:"notReadyGPUPools"`

	// +kubebuilder:default=0
	//
	RetryCount int64 `json:"retryCount"`

	// TODO: calculated every 1h/1d/1w average
	UtilizedTFlopsPercent string `json:"utilizedTFlopsPercent,omitempty"`
	UtilizedVRAMPercent   string `json:"utilizedVRAMPercent,omitempty"`

	// TODO: updated with interval
	AllocatedTFlopsPercent string `json:"allocatedTFlopsPercent,omitempty"`
	AllocatedVRAMPercent   string `json:"allocatedVRAMPercent,omitempty"`

	// TODO: aggregated with interval
	SavedCostsPerMonth       string `json:"savedCostsPerMonth,omitempty"`
	PotentialSavingsPerMonth string `json:"potentialSavingsPerMonth,omitempty"`

	CloudVendorConfigHash string `json:"cloudVendorConfigHash,omitempty"`
}

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

	Spec   TensorFusionConnectionSpec   `json:"spec,omitempty"`
	Status TensorFusionConnectionStatus `json:"status,omitempty"`
}

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

type TensorFusionConnectionSpec struct {
	WorkloadName string `json:"workloadName"`
	ClientPod    string `json:"clientPod"`
}

type TensorFusionConnectionStatus struct {
	Phase         WorkerPhase `json:"phase"`
	ConnectionURL string      `json:"connectionURL"`
	WorkerName    string      `json:"workerName"`
}

type TensorFusionGPUNodePhase string

type TensorFusionGPUPhase string

type TensorFusionPoolPhase string

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

	Spec   WorkloadProfileSpec        `json:"spec,omitempty"`
	Status TensorFusionWorkloadStatus `json:"status,omitempty"`
}

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

type TensorFusionWorkloadPhase string

type TensorFusionWorkloadStatus struct {
	// +kubebuilder:default=Pending
	Phase TensorFusionWorkloadPhase `json:"phase,omitempty"`

	// Represents the latest available observations of the workload's current state.
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// workerCount is the number of vGPU workers
	WorkerCount int32 `json:"workerCount"`

	// readyWorkers is the number of vGPU workers ready
	ReadyWorkers int32 `json:"readyWorkers,omitempty"`

	// Hash of the pod template used to create worker pods
	PodTemplateHash string `json:"podTemplateHash,omitempty"`

	// The most recently GPU resources recommended by the autoscaler
	// +optional
	Recommendation *Resources `json:"recommendation,omitempty"`

	// The number of replicas currently applied based on the latest recommendation
	// +optional
	AppliedRecommendedReplicas int32 `json:"appliedRecommendedReplicas,omitempty"`

	// The currently active cron scaling rule
	// +optional
	ActiveCronScalingRule *CronScalingRule `json:"activeCronScalingRule,omitempty"`
}

type UsedBySystem string

type VerticalScalingRule struct {
	Name string `json:"name,omitempty"`

	// Rule auto applied in webhook, when pod matches the selector,
	// the rule will be added into workload profile's autoScalingConfig and annotation
	Selector metav1.LabelSelector `json:"selector,omitempty"`
	Rule     *AutoScalingConfig   `json:"autoScaling,omitempty"`
}

type VirtualizationTemplate struct {
	// ID is the unique identifier for this template (e.g., "mig-1g-10gb", "vir01")
	// +kubebuilder:validation:Required
	ID string `json:"id"`

	// Name is the vendor-specific name (e.g., "1g.10gb", "vir01")
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// MemoryGigabytes is the memory allocated to this partition
	// +kubebuilder:validation:Required
	MemoryGigabytes uint64 `json:"memoryGigabytes"`

	// ComputePercent is the percentage of compute allocated (0-100), serialized as string
	// +kubebuilder:validation:Required
	ComputePercent string `json:"computePercent"`

	// Description provides additional information about this template
	// +optional
	Description string `json:"description,omitempty"`

	// MaxInstances is the maximum number of instances of this template per GPU
	// +optional
	MaxInstances uint32 `json:"maxInstances,omitempty"`

	// PlacementLimit defines valid placement positions using a bitmask
	// For NVIDIA MIG: defines which slots can host this partition
	// +optional
	PlacementLimit []uint32 `json:"placementLimit,omitempty"`

	// PlacementOffset defines the slot offset for this template
	// +optional
	PlacementOffset uint32 `json:"placementOffset,omitempty"`

	// ExtendedResources contains additional resource dimensions
	// For Ascend NPU: {"AICORE": 1, "AICPU": 1, "VPC": 1, ...}
	// +optional
	ExtendedResources map[string]uint32 `json:"extendedResources,omitempty"`

	// IsolationGroupSharing defines how isolation groups are handled
	// "exclusive" - each partition requires its own isolation group
	// "shared" - multiple partitions can share an isolation group (time-sharing)
	// +optional
	// +kubebuilder:default="exclusive"
	// +kubebuilder:validation:Enum=exclusive;shared
	IsolationGroupSharing string `json:"isolationGroupSharing,omitempty"`

	// MaxPartitionsPerIsolationGroup limits partitions sharing one isolation group
	// Only applicable when IsolationGroupSharing is "shared"
	// +optional
	MaxPartitionsPerIsolationGroup uint32 `json:"maxPartitionsPerIsolationGroup,omitempty"`

	// IsolationGroupSlots defines minimum slots required by this template's isolation group
	// +optional
	IsolationGroupSlots uint32 `json:"isolationGroupSlots,omitempty"`
}

type WorkerConfig struct {
	// Image is the default worker image, used when no ProviderConfig is found for the vendor
	// When ProviderConfig exists, remoteWorker image from ProviderConfig takes precedence
	Image string `json:"image,omitempty"`

	// +optional
	PodTemplate *runtime.RawExtension `json:"podTemplate,omitempty"`
}

type WorkerPhase string

type WorkerStatus struct {
	WorkerPhase WorkerPhase `json:"workerPhase"`

	WorkerName   string            `json:"workerName"`
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`
	// +optional
	WorkerIp string `json:"workerIp,omitempty"`
	// +optional
	ResourceVersion string `json:"resourceVersion,omitempty"`
}

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

	Spec   WorkloadProfileSpec   `json:"spec,omitempty"`
	Status WorkloadProfileStatus `json:"status,omitempty"`
}

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

type WorkloadProfileSpec struct {
	// +optional
	// If replicas not set, it will be dynamic based on pending Pod
	// If isLocalGPU set to true, replicas must be dynamic, and this field will be ignored
	Replicas *int32 `json:"replicas,omitempty"`

	// +optional
	PoolName string `json:"poolName,omitempty"`

	// +optional
	Resources Resources `json:"resources"`

	// +optional
	// Qos defines the quality of service level for the client.
	Qos QoSLevel `json:"qos,omitempty"`

	// +optional
	// Schedule the workload to the same GPU server that runs vGPU worker for best performance, default to false
	IsLocalGPU bool `json:"isLocalGPU,omitempty"`

	// +optional
	// When set to sidecar worker mode, its always Local GPU mode, and hard-isolated with shared memory
	// default to false, indicates the workload's embedded worker is same process, soft-isolated
	SidecarWorker bool `json:"sidecarWorker,omitempty"`

	// +optional
	// +kubebuilder:default=soft
	// How to isolate resources, could be `shared` or `soft` or `hard` or `partitioned`
	Isolation IsolationModeType `json:"isolation,omitempty"`

	// +optional
	// PartitionTemplateID specifies the partition template ID for partitioned isolation mode
	// This is read from pod annotation tensor-fusion.ai/partition if specified
	PartitionTemplateID string `json:"partitionTemplateId,omitempty"`

	// +optional
	// GPUModel specifies the required GPU model (e.g., "A100", "H100")
	GPUModel string `json:"gpuModel,omitempty"`

	// The number of GPUs to be used by the workload, default to 1
	GPUCount uint32 `json:"gpuCount,omitempty"`

	// Specify GPU indices for precise control of scheduling
	GPUIndices []int32 `json:"gpuIndices,omitempty"`

	// Specify GPU vendor for precise control of scheduling
	GPUVendor string `json:"vendor,omitempty"`

	// +optional
	// AutoScalingConfig configured here will override Pool's schedulingConfig
	// This field can not be fully supported in annotation, if user want to enable auto-scaling in annotation,
	// user can set tensor-fusion.ai/autoscale: 'true'
	AutoScalingConfig AutoScalingConfig `json:"autoScalingConfig,omitempty"`

	// +optional
	// NodeAffinity specifies the node affinity requirements for the workload
	NodeAffinity *v1.NodeAffinity `json:"nodeAffinity,omitempty"`

	// +optional
	// WorkerPodTemplate is the template for the worker pod, only take effect in remote vGPU mode
	WorkerPodTemplate *runtime.RawExtension `json:"workerPodTemplate,omitempty"`

	// +optional
	// GangScheduling configuration for scheduling multiple pods together
	GangScheduling *GangSchedulingConfig `json:"gangScheduling,omitempty"`
}

type WorkloadProfileStatus struct {
}