v1

type AppStatus struct {
	// +optional
	Deployments map[string]ServeDeploymentStatus `json:"serveDeploymentStatuses,omitempty"`
	// +optional
	Status string `json:"status,omitempty"`
	// +optional
	Message string `json:"message,omitempty"`
}

type AuthMode string

type AuthOptions struct {
	// Mode specifies the authentication mode.
	// Supported values are "disabled" and "token".
	// Defaults to "token".
	// +kubebuilder:validation:Enum=disabled;token
	// +optional
	Mode AuthMode `json:"mode,omitempty"`
}

type AutoscalerOptions struct {
	// Resources specifies optional resource request and limit overrides for the autoscaler container.
	// Default values: 500m CPU request and limit. 512Mi memory request and limit.
	// +optional
	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`
	// Image optionally overrides the autoscaler's container image. This override is provided for autoscaler testing and development.
	// +optional
	Image *string `json:"image,omitempty"`
	// ImagePullPolicy optionally overrides the autoscaler container's image pull policy. This override is provided for autoscaler testing and development.
	// +optional
	ImagePullPolicy *corev1.PullPolicy `json:"imagePullPolicy,omitempty"`
	// SecurityContext defines the security options the container should be run with.
	// If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext.
	// More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
	// +optional
	SecurityContext *corev1.SecurityContext `json:"securityContext,omitempty"`
	// IdleTimeoutSeconds is the number of seconds to wait before scaling down a worker pod which is not using Ray resources.
	// Defaults to 60 (one minute). It is not read by the KubeRay operator but by the Ray autoscaler.
	// +optional
	IdleTimeoutSeconds *int32 `json:"idleTimeoutSeconds,omitempty"`
	// UpscalingMode is "Conservative", "Default", or "Aggressive."
	// Conservative: Upscaling is rate-limited; the number of pending worker pods is at most the size of the Ray cluster.
	// Default: Upscaling is not rate-limited.
	// Aggressive: An alias for Default; upscaling is not rate-limited.
	// It is not read by the KubeRay operator but by the Ray autoscaler.
	// +optional
	UpscalingMode *UpscalingMode `json:"upscalingMode,omitempty"`
	// Version is the version of the Ray autoscaler.
	// Setting this to v1 will explicitly use autoscaler v1.
	// Setting this to v2 will explicitly use autoscaler v2.
	// If this isn't set, the Ray version determines the autoscaler version.
	// In Ray 2.47.0 and later, the default autoscaler version is v2. It's v1 before that.
	// +optional
	Version *AutoscalerVersion `json:"version,omitempty"`
	// Optional list of environment variables to set in the autoscaler container.
	// +optional
	Env []corev1.EnvVar `json:"env,omitempty"`
	// Optional list of sources to populate environment variables in the autoscaler container.
	// +optional
	EnvFrom []corev1.EnvFromSource `json:"envFrom,omitempty"`
	// Optional list of volumeMounts.  This is needed for enabling TLS for the autoscaler container.
	// +optional
	VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"`
}

type AutoscalerVersion string

type ClusterState string

type ClusterUpgradeOptions struct {
	// The capacity of serve requests the upgraded cluster should scale to handle each interval.
	// Defaults to 100%.
	// +kubebuilder:default:=100
	MaxSurgePercent *int32 `json:"maxSurgePercent,omitempty"`
	// The percentage of traffic to switch to the upgraded RayCluster at a set interval after scaling by MaxSurgePercent.
	StepSizePercent *int32 `json:"stepSizePercent"`
	// The interval in seconds between transferring StepSize traffic from the old to new RayCluster.
	IntervalSeconds *int32 `json:"intervalSeconds"`
	// The name of the Gateway Class installed by the Kubernetes Cluster admin.
	GatewayClassName string `json:"gatewayClassName"`
}

type DeletionCondition struct {
	// JobStatus is the terminal status of the RayJob that triggers this condition. This field is required.
	// For the initial implementation, only "SUCCEEDED" and "FAILED" are supported.
	// +kubebuilder:validation:Enum=SUCCEEDED;FAILED
	JobStatus JobStatus `json:"jobStatus"`

	// TTLSeconds is the time in seconds from when the JobStatus
	// reaches the specified terminal state to when this deletion action should be triggered.
	// The value must be a non-negative integer.
	// +kubebuilder:default=0
	// +kubebuilder:validation:Minimum=0
	// +optional
	TTLSeconds int32 `json:"ttlSeconds,omitempty"`
}

type DeletionPolicy struct {
	// Policy is the action to take when the condition is met.
	// This field is logically required when using the legacy OnSuccess/OnFailure policies.
	// It is marked as '+optional' at the API level to allow the 'deletionRules' field to be used instead.
	// +kubebuilder:validation:Enum=DeleteCluster;DeleteWorkers;DeleteSelf;DeleteNone
	// +optional
	Policy *DeletionPolicyType `json:"policy,omitempty"`
}

type DeletionPolicyType string

type DeletionRule struct {
	// Policy is the action to take when the condition is met. This field is required.
	// +kubebuilder:validation:Enum=DeleteCluster;DeleteWorkers;DeleteSelf;DeleteNone
	Policy DeletionPolicyType `json:"policy"`

	// The condition under which this deletion rule is triggered. This field is required.
	Condition DeletionCondition `json:"condition"`
}

type DeletionStrategy struct {
	// OnSuccess is the deletion policy for a successful RayJob.
	// Deprecated: Use `deletionRules` instead for more flexible, multi-stage deletion strategies.
	// This field will be removed in release 1.6.0.
	// +optional
	OnSuccess *DeletionPolicy `json:"onSuccess,omitempty"`

	// OnFailure is the deletion policy for a failed RayJob.
	// Deprecated: Use `deletionRules` instead for more flexible, multi-stage deletion strategies.
	// This field will be removed in release 1.6.0.
	// +optional
	OnFailure *DeletionPolicy `json:"onFailure,omitempty"`

	// DeletionRules is a list of deletion rules, processed based on their trigger conditions.
	// While the rules can be used to define a sequence, if multiple rules are overdue (e.g., due to controller downtime),
	// the most impactful rule (e.g., DeleteSelf) will be executed first to prioritize resource cleanup.
	// +optional
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	DeletionRules []DeletionRule `json:"deletionRules,omitempty"`
}

type EventReason string

type GcsFaultToleranceOptions struct {
	// +optional
	RedisUsername *RedisCredential `json:"redisUsername,omitempty"`
	// +optional
	RedisPassword *RedisCredential `json:"redisPassword,omitempty"`
	// +optional
	ExternalStorageNamespace string `json:"externalStorageNamespace,omitempty"`
	RedisAddress             string `json:"redisAddress"`
}

type HeadGroupSpec struct {
	// Template is the exact pod template used in K8s deployments, statefulsets, etc.
	Template corev1.PodTemplateSpec `json:"template"`
	// HeadService is the Kubernetes service of the head pod.
	// +optional
	HeadService *corev1.Service `json:"headService,omitempty"`
	// EnableIngress indicates whether operator should create ingress object for head service or not.
	// +optional
	EnableIngress *bool `json:"enableIngress,omitempty"`
	// Resources specifies the resource quantities for the head group.
	// These values override the resources passed to `rayStartParams` for the group, but
	// have no effect on the resources set at the K8s Pod container level.
	// +optional
	Resources map[string]string `json:"resources,omitempty"`
	// Labels specifies the Ray node labels for the head group.
	// These labels will also be added to the Pods of this head group and override the `--labels`
	// argument passed to `rayStartParams`.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`
	// RayStartParams are the params of the start command: node-manager-port, object-store-memory, ...
	// +optional
	RayStartParams map[string]string `json:"rayStartParams"`
	// ServiceType is Kubernetes service type of the head service. it will be used by the workers to connect to the head pod
	// +optional
	ServiceType corev1.ServiceType `json:"serviceType,omitempty"`
}

type HeadInfo struct {
	// +optional
	PodIP string `json:"podIP,omitempty"`
	// +optional
	ServiceIP string `json:"serviceIP,omitempty"`
	// +optional
	PodName string `json:"podName,omitempty"`
	// +optional
	ServiceName string `json:"serviceName,omitempty"`
}

type JobDeploymentStatus string

type JobFailedReason string

type JobStatus string

type JobSubmissionMode string

type RayCluster struct {
	// Standard object metadata.
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Specification of the desired behavior of the RayCluster.
	Spec RayClusterSpec `json:"spec,omitempty"`
	// +optional
	Status RayClusterStatus `json:"status,omitempty"`
}

type RayClusterConditionType string

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

type RayClusterSpec struct {
	// AuthOptions specifies the authentication options for the RayCluster.
	// +optional
	AuthOptions *AuthOptions `json:"authOptions,omitempty"`
	// Suspend indicates whether a RayCluster should be suspended.
	// A suspended RayCluster will have head pods and worker pods deleted.
	// +optional
	Suspend *bool `json:"suspend,omitempty"`
	// ManagedBy is an optional configuration for the controller or entity that manages a RayCluster.
	// The value must be either 'ray.io/kuberay-operator' or 'kueue.x-k8s.io/multikueue'.
	// The kuberay-operator reconciles a RayCluster which doesn't have this field at all or
	// the field value is the reserved string 'ray.io/kuberay-operator',
	// but delegates reconciling the RayCluster with 'kueue.x-k8s.io/multikueue' to the Kueue.
	// The field is immutable.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="the managedBy field is immutable"
	// +kubebuilder:validation:XValidation:rule="self in ['ray.io/kuberay-operator', 'kueue.x-k8s.io/multikueue']",message="the managedBy field value must be either 'ray.io/kuberay-operator' or 'kueue.x-k8s.io/multikueue'"
	// +optional
	ManagedBy *string `json:"managedBy,omitempty"`
	// AutoscalerOptions specifies optional configuration for the Ray autoscaler.
	// +optional
	AutoscalerOptions *AutoscalerOptions `json:"autoscalerOptions,omitempty"`
	// +optional
	HeadServiceAnnotations map[string]string `json:"headServiceAnnotations,omitempty"`
	// EnableInTreeAutoscaling indicates whether operator should create in tree autoscaling configs
	// +optional
	EnableInTreeAutoscaling *bool `json:"enableInTreeAutoscaling,omitempty"`
	// GcsFaultToleranceOptions for enabling GCS FT
	// +optional
	GcsFaultToleranceOptions *GcsFaultToleranceOptions `json:"gcsFaultToleranceOptions,omitempty"`
	// HeadGroupSpec is the spec for the head pod
	HeadGroupSpec HeadGroupSpec `json:"headGroupSpec"`
	// RayVersion is used to determine the command for the Kubernetes Job managed by RayJob
	// +optional
	RayVersion string `json:"rayVersion,omitempty"`
	// WorkerGroupSpecs are the specs for the worker pods
	// +optional
	WorkerGroupSpecs []WorkerGroupSpec `json:"workerGroupSpecs,omitempty"`
}

type RayClusterStatus struct {
	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
	// Important: Run "make" to regenerate code after modifying this file
	// Status reflects the status of the cluster
	//
	// Deprecated: the State field is replaced by the Conditions field.
	// +optional
	State ClusterState `json:"state,omitempty"`
	// DesiredCPU indicates total desired CPUs for the cluster
	// +optional
	DesiredCPU resource.Quantity `json:"desiredCPU,omitempty"`
	// DesiredMemory indicates total desired memory for the cluster
	// +optional
	DesiredMemory resource.Quantity `json:"desiredMemory,omitempty"`
	// DesiredGPU indicates total desired GPUs for the cluster
	// +optional
	DesiredGPU resource.Quantity `json:"desiredGPU,omitempty"`
	// DesiredTPU indicates total desired TPUs for the cluster
	// +optional
	DesiredTPU resource.Quantity `json:"desiredTPU,omitempty"`
	// LastUpdateTime indicates last update timestamp for this cluster status.
	// +nullable
	LastUpdateTime *metav1.Time `json:"lastUpdateTime,omitempty"`
	// StateTransitionTimes indicates the time of the last state transition for each state.
	// +optional
	StateTransitionTimes map[ClusterState]*metav1.Time `json:"stateTransitionTimes,omitempty"`
	// Service Endpoints
	// +optional
	Endpoints map[string]string `json:"endpoints,omitempty"`
	// Head info
	// +optional
	Head HeadInfo `json:"head,omitempty"`
	// Reason provides more information about current State
	// +optional
	Reason string `json:"reason,omitempty"`

	// Represents the latest available observations of a RayCluster's current state.
	// +patchMergeKey=type
	// +patchStrategy=merge
	// +listType=map
	// +listMapKey=type
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`

	// ReadyWorkerReplicas indicates the number of worker pods currently in the Ready state in the cluster.
	// It actually reflects the number of Ready pods, although it is named "replicas" to maintain backward compatibility.
	// +optional
	ReadyWorkerReplicas int32 `json:"readyWorkerReplicas,omitempty"`
	// AvailableWorkerReplicas indicates how many worker pods are currently available (i.e., running).
	// It is named "replicas" to maintain backward compatibility.
	// +optional
	AvailableWorkerReplicas int32 `json:"availableWorkerReplicas,omitempty"`
	// DesiredWorkerReplicas indicates the desired total number of worker Pods at the cluster level,
	// calculated as the sum of `replicas * numOfHosts` for each worker group.
	// It is named "replicas" to maintain backward compatibility.
	// +optional
	DesiredWorkerReplicas int32 `json:"desiredWorkerReplicas,omitempty"`
	// MinWorkerReplicas indicates the minimum number of worker pods across all worker groups,
	// calculated as the sum of `minReplicas * numOfHosts` for each worker group.
	// It is named "replicas" to maintain backward compatibility.
	// +optional
	MinWorkerReplicas int32 `json:"minWorkerReplicas,omitempty"`
	// MaxWorkerReplicas indicates the maximum number of worker pods across all worker groups,
	// calculated as the sum of `maxReplicas * numOfHosts` for each worker group.
	// It is named "replicas" to maintain backward compatibility.
	// +optional
	MaxWorkerReplicas int32 `json:"maxWorkerReplicas,omitempty"`
	// observedGeneration is the most recent generation observed for this RayCluster. It corresponds to the
	// RayCluster's generation, which is updated on mutation by the API Server.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

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

	Spec RayJobSpec `json:"spec,omitempty"`
	// +optional
	Status RayJobStatus `json:"status,omitempty"`
}

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

type RayJobSpec struct {
	// ActiveDeadlineSeconds is the duration in seconds that the RayJob may be active before
	// KubeRay actively tries to terminate the RayJob; value must be positive integer.
	// +optional
	ActiveDeadlineSeconds *int32 `json:"activeDeadlineSeconds,omitempty"`
	// Specifies the number of retries before marking this job failed.
	// Each retry creates a new RayCluster.
	// +kubebuilder:default:=0
	// +optional
	BackoffLimit *int32 `json:"backoffLimit,omitempty"`
	// RayClusterSpec is the cluster template to run the job
	RayClusterSpec *RayClusterSpec `json:"rayClusterSpec,omitempty"`
	// SubmitterPodTemplate is the template for the pod that will run `ray job submit`.
	// +optional
	SubmitterPodTemplate *corev1.PodTemplateSpec `json:"submitterPodTemplate,omitempty"`
	// Metadata is data to store along with this job.
	// +optional
	Metadata map[string]string `json:"metadata,omitempty"`
	// clusterSelector is used to select running rayclusters by labels
	// +optional
	ClusterSelector map[string]string `json:"clusterSelector,omitempty"`
	// Configurations of submitter k8s job.
	// +optional
	SubmitterConfig *SubmitterConfig `json:"submitterConfig,omitempty"`
	// ManagedBy is an optional configuration for the controller or entity that manages a RayJob.
	// The value must be either 'ray.io/kuberay-operator' or 'kueue.x-k8s.io/multikueue'.
	// The kuberay-operator reconciles a RayJob which doesn't have this field at all or
	// the field value is the reserved string 'ray.io/kuberay-operator',
	// but delegates reconciling the RayJob with 'kueue.x-k8s.io/multikueue' to the Kueue.
	// The field is immutable.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="the managedBy field is immutable"
	// +kubebuilder:validation:XValidation:rule="self in ['ray.io/kuberay-operator', 'kueue.x-k8s.io/multikueue']",message="the managedBy field value must be either 'ray.io/kuberay-operator' or 'kueue.x-k8s.io/multikueue'"
	// +optional
	ManagedBy *string `json:"managedBy,omitempty"`
	// DeletionStrategy automates post-completion cleanup.
	// Choose one style or omit:
	//   - Legacy: both onSuccess & onFailure (deprecated; may combine with shutdownAfterJobFinishes and TTLSecondsAfterFinished).
	//   - Rules: deletionRules (non-empty) — incompatible with shutdownAfterJobFinishes, legacy fields, and global TTLSecondsAfterFinished (use per-rule condition.ttlSeconds).
	// Global TTLSecondsAfterFinished > 0 requires shutdownAfterJobFinishes=true.
	// Feature gate RayJobDeletionPolicy must be enabled when this field is set.
	// +optional
	DeletionStrategy *DeletionStrategy `json:"deletionStrategy,omitempty"`
	// Entrypoint represents the command to start execution.
	// +optional
	Entrypoint string `json:"entrypoint,omitempty"`
	// RuntimeEnvYAML represents the runtime environment configuration
	// provided as a multi-line YAML string.
	// +optional
	RuntimeEnvYAML string `json:"runtimeEnvYAML,omitempty"`
	// If jobId is not set, a new jobId will be auto-generated.
	// +optional
	JobId string `json:"jobId,omitempty"`
	// SubmissionMode specifies how RayJob submits the Ray job to the RayCluster.
	// In "K8sJobMode", the KubeRay operator creates a submitter Kubernetes Job to submit the Ray job.
	// In "HTTPMode", the KubeRay operator sends a request to the RayCluster to create a Ray job.
	// In "InteractiveMode", the KubeRay operator waits for a user to submit a job to the Ray cluster.
	// In "SidecarMode", the KubeRay operator injects a container into the Ray head Pod that acts as the job submitter to submit the Ray job.
	// +kubebuilder:default:=K8sJobMode
	// +optional
	SubmissionMode JobSubmissionMode `json:"submissionMode,omitempty"`
	// EntrypointResources specifies the custom resources and quantities to reserve for the
	// entrypoint command.
	// +optional
	EntrypointResources string `json:"entrypointResources,omitempty"`
	// EntrypointNumCpus specifies the number of cpus to reserve for the entrypoint command.
	// +optional
	EntrypointNumCpus float32 `json:"entrypointNumCpus,omitempty"`
	// EntrypointNumGpus specifies the number of gpus to reserve for the entrypoint command.
	// +optional
	EntrypointNumGpus float32 `json:"entrypointNumGpus,omitempty"`
	// TTLSecondsAfterFinished is the TTL to clean up RayCluster.
	// It's only working when ShutdownAfterJobFinishes set to true.
	// +kubebuilder:default:=0
	// +optional
	TTLSecondsAfterFinished int32 `json:"ttlSecondsAfterFinished,omitempty"`
	// ShutdownAfterJobFinishes will determine whether to delete the ray cluster once rayJob succeed or failed.
	// +optional
	ShutdownAfterJobFinishes bool `json:"shutdownAfterJobFinishes,omitempty"`
	// suspend specifies whether the RayJob controller should create a RayCluster instance
	// If a job is applied with the suspend field set to true,
	// the RayCluster will not be created and will wait for the transition to false.
	// If the RayCluster is already created, it will be deleted.
	// In case of transition to false a new RayCluster will be created.
	// +optional
	Suspend bool `json:"suspend,omitempty"`
}

type RayJobStatus struct {
	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
	// Important: Run "make" to regenerate code after modifying this file
	// RayJobStatusInfo contains information about the Ray job retrieved from the Ray dashboard.
	// +optional
	RayJobStatusInfo RayJobStatusInfo `json:"rayJobInfo,omitempty"`
	// +optional
	JobId string `json:"jobId,omitempty"`
	// +optional
	RayClusterName string `json:"rayClusterName,omitempty"`
	// +optional
	DashboardURL string `json:"dashboardURL,omitempty"`
	// +optional
	JobStatus JobStatus `json:"jobStatus,omitempty"`
	// +optional
	JobDeploymentStatus JobDeploymentStatus `json:"jobDeploymentStatus,omitempty"`
	// +optional
	Reason JobFailedReason `json:"reason,omitempty"`
	// +optional
	Message string `json:"message,omitempty"`
	// StartTime is the time when JobDeploymentStatus transitioned from 'New' to 'Initializing'.
	// +optional
	StartTime *metav1.Time `json:"startTime,omitempty"`
	// EndTime is the time when JobDeploymentStatus transitioned to 'Complete' status.
	// This occurs when the Ray job reaches a terminal state (SUCCEEDED, FAILED, STOPPED)
	// or the submitter Job has failed.
	// +optional
	EndTime *metav1.Time `json:"endTime,omitempty"`
	// Succeeded is the number of times this job succeeded.
	// +kubebuilder:default:=0
	// +optional
	Succeeded *int32 `json:"succeeded,omitempty"`
	// Failed is the number of times this job failed.
	// +kubebuilder:default:=0
	// +optional
	Failed *int32 `json:"failed,omitempty"`
	// RayClusterStatus is the status of the RayCluster running the job.
	// +optional
	RayClusterStatus RayClusterStatus `json:"rayClusterStatus,omitempty"`

	// observedGeneration is the most recent generation observed for this RayJob. It corresponds to the
	// RayJob's generation, which is updated on mutation by the API Server.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

type RayJobStatusInfo struct {
	StartTime *metav1.Time `json:"startTime,omitempty"`
	EndTime   *metav1.Time `json:"endTime,omitempty"`
}

type RayNodeType string

type RayService struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              RayServiceSpec `json:"spec,omitempty"`
	// +optional
	Status RayServiceStatuses `json:"status,omitempty"`
}

type RayServiceConditionReason string

type RayServiceConditionType string

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

type RayServiceSpec struct {
	// RayClusterDeletionDelaySeconds specifies the delay, in seconds, before deleting old RayClusters.
	// The default value is 60 seconds.
	// +kubebuilder:validation:Minimum=0
	// +optional
	RayClusterDeletionDelaySeconds *int32 `json:"rayClusterDeletionDelaySeconds,omitempty"`
	// Deprecated: This field is not used anymore. ref: https://github.com/ray-project/kuberay/issues/1685
	// +optional
	ServiceUnhealthySecondThreshold *int32 `json:"serviceUnhealthySecondThreshold,omitempty"`
	// Deprecated: This field is not used anymore. ref: https://github.com/ray-project/kuberay/issues/1685
	// +optional
	DeploymentUnhealthySecondThreshold *int32 `json:"deploymentUnhealthySecondThreshold,omitempty"`
	// ServeService is the Kubernetes service for head node and worker nodes who have healthy http proxy to serve traffics.
	// +optional
	ServeService *corev1.Service `json:"serveService,omitempty"`
	// UpgradeStrategy defines the scaling policy used when upgrading the RayService.
	// +optional
	UpgradeStrategy *RayServiceUpgradeStrategy `json:"upgradeStrategy,omitempty"`
	// Important: Run "make" to regenerate code after modifying this file
	// Defines the applications and deployments to deploy, should be a YAML multi-line scalar string.
	// +optional
	ServeConfigV2  string         `json:"serveConfigV2,omitempty"`
	RayClusterSpec RayClusterSpec `json:"rayClusterConfig"`
	// If the field is set to true, the value of the label `ray.io/serve` on the head Pod should always be false.
	// Therefore, the head Pod's endpoint will not be added to the Kubernetes Serve service.
	// +optional
	ExcludeHeadPodFromServeSvc bool `json:"excludeHeadPodFromServeSvc,omitempty"`
}

type RayServiceStatus struct {
	// Important: Run "make" to regenerate code after modifying this file
	// +optional
	Applications map[string]AppStatus `json:"applicationStatuses,omitempty"`
	// TargetCapacity is the `target_capacity` percentage for all Serve replicas
	// across the cluster for this RayService. The `num_replicas`, `min_replicas`, `max_replicas`,
	// and `initial_replicas` for each deployment will be scaled by this percentage."
	// +optional
	TargetCapacity *int32 `json:"targetCapacity,omitempty"`
	// TrafficRoutedPercent is the percentage of traffic that is routed to the Serve service
	// for this RayService. TrafficRoutedPercent is updated to reflect the weight on the HTTPRoute
	// created for this RayService during incremental upgrades to a new cluster.
	// +optional
	TrafficRoutedPercent *int32 `json:"trafficRoutedPercent,omitempty"`
	// LastTrafficMigratedTime is the last time that TrafficRoutedPercent was updated to a new value
	// for this RayService.
	// +optional
	LastTrafficMigratedTime *metav1.Time `json:"lastTrafficMigratedTime,omitempty"`
	// +optional
	RayClusterName string `json:"rayClusterName,omitempty"`
	// +optional
	RayClusterStatus RayClusterStatus `json:"rayClusterStatus,omitempty"`
}

type RayServiceStatuses struct {
	// Represents the latest available observations of a RayService's current state.
	// +patchMergeKey=type
	// +patchStrategy=merge
	// +listType=map
	// +listMapKey=type
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`
	// LastUpdateTime represents the timestamp when the RayService status was last updated.
	// +optional
	LastUpdateTime *metav1.Time `json:"lastUpdateTime,omitempty"`
	// Deprecated: `ServiceStatus` is deprecated - use `Conditions` instead. `Running` means the RayService is ready to
	// serve requests. An empty `ServiceStatus` means the RayService is not ready to serve requests. The definition of
	// `ServiceStatus` is equivalent to the `RayServiceReady` condition.
	// +optional
	ServiceStatus ServiceStatus `json:"serviceStatus,omitempty"`
	// +optional
	ActiveServiceStatus RayServiceStatus `json:"activeServiceStatus,omitempty"`
	// Pending Service Status indicates a RayCluster will be created or is being created.
	// +optional
	PendingServiceStatus RayServiceStatus `json:"pendingServiceStatus,omitempty"`
	// NumServeEndpoints indicates the number of Ray Pods that are actively serving or have been selected by the serve service.
	// Ray Pods without a proxy actor or those that are unhealthy will not be counted.
	// +optional
	NumServeEndpoints int32 `json:"numServeEndpoints,omitempty"`
	// observedGeneration is the most recent generation observed for this RayService. It corresponds to the
	// RayService's generation, which is updated on mutation by the API Server.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

type RayServiceUpgradeStrategy struct {
	// Type represents the strategy used when upgrading the RayService. Currently supports `NewCluster` and `None`.
	// +optional
	Type *RayServiceUpgradeType `json:"type,omitempty"`
	// ClusterUpgradeOptions defines the behavior of a NewClusterWithIncrementalUpgrade type.
	// RayServiceIncrementalUpgrade feature gate must be enabled to set ClusterUpgradeOptions.
	ClusterUpgradeOptions *ClusterUpgradeOptions `json:"clusterUpgradeOptions,omitempty"`
}

type RayServiceUpgradeType string

type RedisCredential struct {
	// +optional
	ValueFrom *corev1.EnvVarSource `json:"valueFrom,omitempty"`
	// +optional
	Value string `json:"value,omitempty"`
}

type ScaleStrategy struct {
	// WorkersToDelete workers to be deleted
	WorkersToDelete []string `json:"workersToDelete,omitempty"`
}

type ServeDeploymentStatus struct {
	// +optional
	Status string `json:"status,omitempty"`
	// +optional
	Message string `json:"message,omitempty"`
}

type ServiceStatus string

type SubmitterConfig struct {
	// BackoffLimit of the submitter k8s job.
	// +optional
	BackoffLimit *int32 `json:"backoffLimit,omitempty"`
}

type UpscalingMode string

type WorkerGroupSpec struct {
	// Suspend indicates whether a worker group should be suspended.
	// A suspended worker group will have all pods deleted.
	// This is not a user-facing API and is only used by RayJob DeletionStrategy.
	// +optional
	Suspend *bool `json:"suspend,omitempty"`
	// we can have multiple worker groups, we distinguish them by name
	GroupName string `json:"groupName"`
	// Replicas is the number of desired Pods for this worker group. See https://github.com/ray-project/kuberay/pull/1443 for more details about the reason for making this field optional.
	// +kubebuilder:default:=0
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`
	// MinReplicas denotes the minimum number of desired Pods for this worker group.
	// +kubebuilder:default:=0
	MinReplicas *int32 `json:"minReplicas"`
	// MaxReplicas denotes the maximum number of desired Pods for this worker group, and the default value is maxInt32.
	// +kubebuilder:default:=2147483647
	MaxReplicas *int32 `json:"maxReplicas"`
	// IdleTimeoutSeconds denotes the number of seconds to wait before the v2 autoscaler terminates an idle worker pod of this type.
	// This value is only used with the Ray Autoscaler enabled and defaults to the value set by the AutoscalingConfig if not specified for this worker group.
	// +optional
	IdleTimeoutSeconds *int32 `json:"idleTimeoutSeconds,omitempty"`
	// Resources specifies the resource quantities for this worker group.
	// These values override the resources passed to `rayStartParams` for the group, but
	// have no effect on the resources set at the K8s Pod container level.
	// +optional
	Resources map[string]string `json:"resources,omitempty"`
	// Labels specifies the Ray node labels for this worker group.
	// These labels will also be added to the Pods of this worker group and override the `--labels`
	// argument passed to `rayStartParams`.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`
	// RayStartParams are the params of the start command: address, object-store-memory, ...
	// +optional
	RayStartParams map[string]string `json:"rayStartParams"`
	// Template is a pod template for the worker
	Template corev1.PodTemplateSpec `json:"template"`
	// ScaleStrategy defines which pods to remove
	// +optional
	ScaleStrategy ScaleStrategy `json:"scaleStrategy,omitempty"`
	// NumOfHosts denotes the number of hosts to create per replica. The default value is 1.
	// +kubebuilder:default:=1
	// +optional
	NumOfHosts int32 `json:"numOfHosts,omitempty"`
}