v1

type AnnotationOperationValue string

type AutoScalerVersion string

type AutoScalingPolicy struct {
	// the policy of autoscaling. operator use autoscaling v2.
	HPAPolicy *HPAPolicy `json:"hpaPolicy,omitempty"`

	// version represents the autoscaler version for cn service. only support v1,v2beta2,v2
	// +optional
	Version AutoScalerVersion `json:"version,omitempty"`

	// MinReplicas is the lower limit for the number of replicas to which the autoscaler
	// can scale down. It defaults to 1 pod.
	// +optional
	MinReplicas *int32 `json:"minReplicas,omitempty"`

	// MaxReplicas is the upper limit for the number of pods that can be set by the autoscaler;
	// cannot be smaller than MinReplicas.
	MaxReplicas int32 `json:"maxReplicas"`
}

type ComponentPhase string

type ConfigMapInfo struct {
	// the config info for start progress.
	ConfigMapName string `json:"configMapName,omitempty"`

	// the config response key in configmap.
	ResolveKey string `json:"resolveKey,omitempty"`
}

type ConfigMapReference MountInfo

type DRPhase string

type DisasterRecovery struct {
	// Enabled is used to determine whether to enter disaster recovery mode.
	Enabled bool `json:"enabled,omitempty"`

	// Generation records the generation of disaster recovery. If you want to trigger disaster recovery, you should
	// increase the generation.
	Generation int64 `json:"generation,omitempty"`
}

type DisasterRecoveryStatus struct {
	// the available phase include: todo, doing, done
	Phase DRPhase `json:"phase,omitempty"`

	// the reason of disaster recovery.
	Reason string `json:"reason,omitempty"`

	// the unix time of starting disaster recovery.
	StartTimestamp int64 `json:"startTimestamp,omitempty"`

	// the unix time of ending disaster recovery.
	EndTimestamp int64 `json:"endTimestamp,omitempty"`

	// the observed generation of disaster recovery.
	// If the observed generation is less than the generation, it will trigger disaster recovery.
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
}

type HPAPolicy struct {
	// +optional
	// Metrics specifies how to scale based on a single metric
	// the struct copy from k8s.io/api/autoscaling/v2beta2/types.go. the redundancy code will hide the restriction about
	// HorizontalPodAutoscaler version and kubernetes releases matching issue.
	// the splice will have unsafe.Pointer convert, so be careful to edit the struct fields.
	Metrics []autoscalingv2beta2.MetricSpec `json:"metrics,omitempty"`

	// +optional
	// HorizontalPodAutoscalerBehavior configures the scaling behavior of the target.
	// the struct copy from k8s.io/api/autoscaling/v2beta2/types.go. the redundancy code will hide the restriction about
	// HorizontalPodAutoscaler version and kubernetes releases matching issue.
	// the
	Behavior *autoscalingv2beta2.HorizontalPodAutoscalerBehavior `json:"behavior,omitempty"`
}

type HorizontalScaler struct {
	// the horizontal scaler name
	Name string `json:"name,omitempty"`

	// the horizontal version.
	Version AutoScalerVersion `json:"version,omitempty"`
}

type MountInfo struct {
	// This must match the Name of a ConfigMap or Secret in the same namespace, and
	// the length of name must not more than 50 characters.
	Name string `json:"name,omitempty"`

	// Path within the container at which the volume should be mounted.  Must
	// not contain ':'.
	MountPath string `json:"mountPath,omitempty"`

	// SubPath within the volume from which the container's volume should be mounted.
	// Defaults to "" (volume's root).
	// +optional
	SubPath string `json:"subPath,omitempty"`
}

type Phase string

type SecretReference MountInfo

type SpecInterface interface {

	// GetHostAliases returns the host aliases configuration for the pod. Host aliases allow adding entries to
	// the pod's /etc/hosts file to configure custom host-to-IP mappings.
	GetHostAliases() []corev1.HostAlias

	// GetRunAsNonRoot returns the user ID and group ID to run the container as non-root.
	// Returns (*uid, *gid) where nil means use container defaults.
	GetRunAsNonRoot() (*int64, *int64)

	// GetTerminationGracePeriodSeconds returns the grace period in seconds for pod termination.
	// This is how long to wait for the pod to terminate gracefully before forcefully killing it.
	GetTerminationGracePeriodSeconds() *int64

	// GetCapabilities returns the Linux capabilities configuration for the container.
	// Capabilities allow granting specific privileges to processes.
	GetCapabilities() *corev1.Capabilities

	// GetSidecars returns the list of sidecar containers to add to the pod.
	// Sidecars run alongside the main container to provide additional functionality.
	GetSidecars() []corev1.Container

	// GetInitContainers returns the list of init containers to run before the main containers.
	// Init containers run to completion in order, before the main containers start.
	GetInitContainers() []corev1.Container

	// IsReadOnlyRootFilesystem returns whether the container's root filesystem should be read-only.
	// A read-only root filesystem prevents modifications to improve security.
	IsReadOnlyRootFilesystem() *bool

	// GetSysctls returns the sysctl parameters to set for the container.
	// Sysctls allow configuring kernel parameters at runtime.
	GetSysctls() []corev1.Sysctl

	// GetCommand returns the command to run in the container.
	// This overrides the container image's default entrypoint.
	GetCommand() []string

	// GetArgs returns the arguments to pass to the container command.
	// These are the arguments passed to either the default entrypoint or GetCommand().
	GetArgs() []string

	// GetUpdateStrategy returns the update strategy for the StatefulSet.
	// This controls how pods are replaced during updates.
	GetUpdateStrategy() *appsv1.StatefulSetUpdateStrategy

	// GetMinReadySeconds returns the minimum number of seconds for which a newly created pod should be ready
	// without any of its container crashing, for it to be considered available.
	GetMinReadySeconds() *int32

	GetPodManagementPolicy() appsv1.PodManagementPolicyType
	// contains filtered or unexported methods
}

type StarRocksBeSpec struct {
	StarRocksComponentSpec `json:",inline"`

	// +optional
	// beEnvVars is a slice of environment variables that are added to the pods, the default is empty.
	BeEnvVars []corev1.EnvVar `json:"beEnvVars,omitempty"`
}

type StarRocksBeStatus struct {
	StarRocksComponentStatus `json:",inline"`
}

type StarRocksCluster struct {
	metav1.TypeMeta `json:",inline"`
	// +k8s:openapi-gen=false
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Specification of the desired state of the starrocks cluster.
	Spec StarRocksClusterSpec `json:"spec,omitempty"`

	// Most recent observed status of the starrocks cluster
	Status StarRocksClusterStatus `json:"status,omitempty"`
}

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

type StarRocksClusterSpec struct {
	// Specify a Service Account for starRocksCluster use k8s cluster.
	// +optional
	// Deprecated: component use serviceAccount in own's field.
	ServiceAccount string `json:"serviceAccount,omitempty"`

	// StarRocksFeSpec define fe configuration for start fe service.
	StarRocksFeSpec *StarRocksFeSpec `json:"starRocksFeSpec,omitempty"`

	// StarRocksBeSpec define be configuration for start be service.
	StarRocksBeSpec *StarRocksBeSpec `json:"starRocksBeSpec,omitempty"`

	// StarRocksCnSpec define cn configuration for start cn service.
	StarRocksCnSpec *StarRocksCnSpec `json:"starRocksCnSpec,omitempty"`

	// StarRocksLoadSpec define a proxy for fe.
	StarRocksFeProxySpec *StarRocksFeProxySpec `json:"starRocksFeProxySpec,omitempty"`

	// +optional
	// DisasterRecovery is used to determine whether to enter disaster recovery mode.
	DisasterRecovery *DisasterRecovery `json:"disasterRecovery,omitempty"`
}

type StarRocksClusterStatus struct {
	// Represents the state of cluster. the possible value are: running, failed, pending
	Phase Phase `json:"phase"`

	// Reason represents the errors when calling sub-controllers
	Reason string `json:"reason,omitempty"`

	// Represents the status of fe. the status have running, failed and creating pods.
	StarRocksFeStatus *StarRocksFeStatus `json:"starRocksFeStatus,omitempty"`

	// Represents the status of be. the status have running, failed and creating pods.
	StarRocksBeStatus *StarRocksBeStatus `json:"starRocksBeStatus,omitempty"`

	// Represents the status of cn. the status have running, failed and creating pods.
	StarRocksCnStatus *StarRocksCnStatus `json:"starRocksCnStatus,omitempty"`

	// Represents the status of fe proxy. the status have running, failed and creating pods.
	StarRocksFeProxyStatus *StarRocksFeProxyStatus `json:"starRocksFeProxyStatus,omitempty"`

	// +optional
	// DisasterRecoveryStatus represents the status of disaster recovery.
	DisasterRecoveryStatus *DisasterRecoveryStatus `json:"disasterRecoveryStatus,omitempty"`
}

type StarRocksCnSpec struct {
	StarRocksComponentSpec `json:",inline"`

	// +optional
	// cnEnvVars is a slice of environment variables that are added to the pods, the default is empty.
	CnEnvVars []corev1.EnvVar `json:"cnEnvVars,omitempty"`

	// AutoScalingPolicy auto scaling strategy
	AutoScalingPolicy *AutoScalingPolicy `json:"autoScalingPolicy,omitempty"`
}

type StarRocksCnStatus struct {
	StarRocksComponentStatus `json:",inline"`

	// The policy name of autoScale.
	// Deprecated
	HpaName string `json:"hpaName,omitempty"`

	// HorizontalAutoscaler have the autoscaler information.
	HorizontalScaler HorizontalScaler `json:"horizontalScaler,omitempty"`

	// Replicas is the total number of non-terminated CN pods targeted.
	Replicas int32 `json:"replicas,omitempty"`

	// Selector for CN pods. The HPA will use this selector to know which pods to monitor.
	Selector string `json:"selector,omitempty"`
}

type StarRocksComponentSpec struct {
	StarRocksLoadSpec `json:",inline"`

	// RunAsNonRoot is used to determine whether to run starrocks as a normal user.
	// If RunAsNonRoot is true, operator will set RunAsUser and RunAsGroup to 1000 in securityContext.
	// default: nil
	RunAsNonRoot *bool `json:"runAsNonRoot,omitempty"`

	// refer to https://kubernetes.io/docs/tasks/configure-pod-container/security-context/#set-capabilities-for-a-container
	// grant certain privileges to a process without granting all the privileges of the root user
	// +optional
	Capabilities *corev1.Capabilities `json:"capabilities,omitempty"`

	// the reference for configMap which allow users to mount any files to container.
	// +optional
	ConfigMaps []ConfigMapReference `json:"configMaps,omitempty"`

	// the reference for secrets.
	// +optional
	Secrets []SecretReference `json:"secrets,omitempty"`

	// HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts
	// file if specified. This is only valid for non-hostNetwork pods.
	// +optional
	HostAliases []corev1.HostAlias `json:"hostAliases,omitempty"`

	// TerminationGracePeriodSeconds defines duration in seconds the pod needs to terminate gracefully. May be decreased in delete request.
	// Value must be non-negative integer. The value zero indicates stop immediately via
	// the kill signal (no opportunity to shut down).
	// If this value is nil, the default grace period will be used instead.
	// The grace period is the duration in seconds after the processes running in the pod are sent
	// a termination signal and the time when the processes are forcibly halted with a kill signal.
	// Set this value longer than the expected cleanup time for your process.
	// Defaults to 120 seconds.
	// +optional
	TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty"`

	// Sidecars is an optional list of containers that are run in the same pod as the starrocks component.
	// You can use this field to launch helper containers that provide additional functionality to the main container.
	// See https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#Container for how to configure a container.
	// +optional
	Sidecars []corev1.Container `json:"sidecars,omitempty"`

	// InitContainers is an optional list of containers that are run in the same pod as the starrocks component.
	// You can use this field to launch helper containers that run before the main container starts.
	// See https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#Container for how to configure a container.
	InitContainers []corev1.Container `json:"initContainers,omitempty"`

	// Entrypoint array. Not executed within a shell.
	// If this is not provided, it will use default entrypoint for different components:
	//	1. For FE, it will use /opt/starrocks/fe_entrypoint.sh as the entrypoint.
	//  2. For BE, it will use /opt/starrocks/be_entrypoint.sh as the entrypoint.
	//  3. For CN, it will use /opt/starrocks/cn_entrypoint.sh as the entrypoint.
	// More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
	// +optional
	Command []string `json:"command,omitempty"`

	// Arguments to the entrypoint.
	// If this is not provided, it will use $(FE_SERVICE_NAME) for all components.
	// Variable references $(VAR_NAME) are expanded using the container's environment. If a variable
	// cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced
	// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will
	// produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless
	// of whether the variable exists or not. Cannot be updated.
	// More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
	// +optional
	Args []string `json:"args,omitempty"`

	// StarRocksCluster use StatefulSet to deploy FE/BE/CN components.
	// UpdateStrategy indicates the StatefulSetUpdateStrategy that will be
	// employed to update Pods in the StatefulSet when a revision is made to
	// Template. See https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/#rolling-updates for more details.
	// Note: The maxUnavailable field is in Alpha stage and it is honored only by API servers that are running with the
	//       MaxUnavailableStatefulSet feature gate enabled.
	// +optional
	UpdateStrategy *appsv1.StatefulSetUpdateStrategy `json:"updateStrategy,omitempty"`

	// Whether this container has a read-only root filesystem.
	// Default is false.
	// Note that:
	// 	1. This field cannot be set when spec.os.name is windows.
	//	2. The FE/BE/CN container should support read-only root filesystem. The newest version of FE/BE/CN is 3.3.6,
	//     and does not support read-only root filesystem
	// +optional
	ReadOnlyRootFilesystem *bool `json:"readOnlyRootFilesystem,omitempty" protobuf:"varint,6,opt,name=readOnlyRootFilesystem"`

	// Sysctls defines a list of namespaced sysctls for the podSecurityContext.sysctls
	// See https://kubernetes.io/docs/tasks/administer-cluster/sysctl-cluster/ for more details.
	Sysctls []corev1.Sysctl `json:"sysctls,omitempty"`

	// PersistentVolumeClaimRetentionPolicy specifies the retention policy for PersistentVolumeClaims associated with the component.
	// The WhenDeleted field is supported for all components, and it determines whether to delete PVCs when the StatefulSet is deleted.
	// The WhenScaled field is only supported for the CN component.
	//nolint:lll
	PersistentVolumeClaimRetentionPolicy *appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy `json:"persistentVolumeClaimRetentionPolicy,omitempty"`

	// MinReadySeconds specifies the minimum number of seconds for which a newly created pod should be ready
	// without any of its container crashing, for it to be considered available.
	// Defaults to 0 (pod will be considered available as soon as it is ready).
	// +optional
	MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`

	// podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down.
	// The default policy is Parallel which is not the same as statefulset's default policy which maybe a not a good choice
	// to use a different default value.
	// +optional
	PodManagementPolicy appsv1.PodManagementPolicyType `json:"podManagementPolicy,omitempty"`
}

type StarRocksComponentStatus struct {
	// the name of fe service exposed for user.
	ServiceName string `json:"serviceName,omitempty"`

	// FailedInstances failed pod names.
	FailedInstances []string `json:"failedInstances,omitempty"`

	// CreatingInstances in creating pod names.
	CreatingInstances []string `json:"creatingInstances,omitempty"`

	// RunningInstances in running status pod names.
	RunningInstances []string `json:"runningInstances,omitempty"`

	// ResourceNames the statefulset names of fe.
	ResourceNames []string `json:"resourceNames,omitempty"`

	// Phase the value from all pods of component status. If component have one failed pod phase=failed,
	// also if fe have one creating pod phase=creating, also if component all running phase=running, others unknown.
	Phase ComponentPhase `json:"phase"`

	// Reason represents the reason of not running.
	Reason string `json:"reason,omitempty"`
}

type StarRocksFeProxySpec struct {
	StarRocksLoadSpec `json:",inline"`

	Resolver string `json:"resolver,omitempty"`
}

type StarRocksFeProxyStatus struct {
	StarRocksComponentStatus `json:",inline"`
}

type StarRocksFeSpec struct {
	StarRocksComponentSpec `json:",inline"`

	// +optional
	// feEnvVars is a slice of environment variables that are added to the pods, the default is empty.
	FeEnvVars []corev1.EnvVar `json:"feEnvVars,omitempty"`
}

type StarRocksFeStatus struct {
	StarRocksComponentStatus `json:",inline"`
}

type StarRocksLoadSpec struct {
	// defines the specification of resource cpu and mem.
	// +optional
	corev1.ResourceRequirements `json:",inline"`

	// annotation for pods. user can config monitor annotation for collect to monitor system.
	Annotations map[string]string `json:"annotations,omitempty"`

	// +optional
	// the pod labels for user select or classify pods.
	PodLabels map[string]string `json:"podLabels,omitempty"`

	// Replicas is the number of desired Pods.
	// When HPA policy is enabled with a fixed replica count in StarRocksCnSpec: every time
	// the starrockscluster CR is applied, the replica count of the StatefulSet
	// object in K8S will be reset to the value specified by the 'Replicas'
	// field, erasing the value previously set by HPA.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:default=1
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// Image for a starrocks deployment.
	// +optional
	Image string `json:"image"`

	// Image pull policy.
	// One of Always, Never, IfNotPresent.
	// Defaults to IfNotPresent for compatibility.
	// More info: https://kubernetes.io/docs/concepts/containers/images#updating-images
	// +optional
	ImagePullPolicy corev1.PullPolicy `json:"imagePullPolicy,omitempty"`

	// ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the
	// images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for
	// them to use.
	// More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge
	ImagePullSecrets []corev1.LocalObjectReference `json:"imagePullSecrets,omitempty" patchStrategy:"merge" patchMergeKey:"name" protobuf:"bytes,15,rep,name=imagePullSecrets"` //nolint:lll

	// SchedulerName is the name of the kubernetes scheduler that will be used to schedule the pods.
	// +optional
	SchedulerName string `json:"schedulerName,omitempty"`

	// (Optional) If specified, the pod's nodeSelector，displayName="Map of nodeSelectors to match when scheduling pods on nodes"
	// +optional
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`

	// +optional
	// If specified, the pod's scheduling constraints.
	Affinity *corev1.Affinity `json:"affinity,omitempty"`

	// (Optional) Tolerations for scheduling pods onto some dedicated nodes
	// +optional
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`

	// (Optional) TopologySpreadConstraints for spreading pods across failure-domains
	// More info: https://kubernetes.io/docs/concepts/scheduling-eviction/topology-spread-constraints/
	// +optional
	TopologySpreadConstraints []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`

	// Service defines the template for the associated Kubernetes Service object.
	// +optional
	Service *StarRocksService `json:"service,omitempty"`

	// StorageVolumes defines the additional storage for FE meta or BE/CN storage.
	//
	// For FE component
	//	If the storage volume name is fe-meta or the volume mount path is /opt/starrocks/fe/meta,
	//	then it will be recognized as storing the FE meta.
	//	If the storage volume name is fe-log or the volume mount path is /opt/starrocks/fe/log,
	//	then it will be recognized as storing the FE log.
	//
	// For BE component
	// 	If the storage volume name is be-storage(or be-data) or the volume mount path is /opt/starrocks/be/storage,
	// 	then it will be recognized as storing the BE data.
	// 	If the storage volume name is be-log or the volume mount path is /opt/starrocks/be/log,
	// 	then it will be recognized as storing the BE log.
	//
	// For CN component
	// 	If the storage volume name is cn-log or the volume mount path is /opt/starrocks/cn/log,
	// 	then it will be recognized as storing the cn log.
	//
	// If operator can't find the above storage volume names or the volume mount paths, it will create
	// default storage volumes by using emptyDir.
	//
	// +optional
	StorageVolumes []StorageVolume `json:"storageVolumes,omitempty"`

	// serviceAccount for access cloud service.
	ServiceAccount string `json:"serviceAccount,omitempty"`

	// the reference for configMap which store the config info to start starrocks. e.g. be.conf, fe.conf, cn.conf.
	// +optional
	ConfigMapInfo ConfigMapInfo `json:"configMapInfo,omitempty"`

	// StartupProbeFailureSeconds defines the total failure seconds of startup Probe.
	// Default failureThreshold is 60 and the periodSeconds is 5, this means the startup
	// will fail if the pod can't start in 300 seconds. Your StartupProbeFailureSeconds is
	// the total time of seconds before startupProbe give up and fail the container start.
	// If startupProbeFailureSeconds can't be divided by defaultPeriodSeconds, the failureThreshold
	// will be rounded up.
	// Note: you can set it to 0 to disable the startup probe.
	// +optional
	StartupProbeFailureSeconds *int32 `json:"startupProbeFailureSeconds,omitempty"`

	// LivenessProbeFailureSeconds defines the total failure seconds of liveness Probe.
	// Default failureThreshold is 3 and the periodSeconds is 5, this means the liveness
	// will fail if the pod can't respond in 15 seconds. Your LivenessProbeFailureSeconds is
	// the total time of seconds before the container restart. If LivenessProbeFailureSeconds
	// can't be divided by defaultPeriodSeconds, the failureThreshold will be rounded up.
	// Note: you can set it to 0 to disable the liveness probe.
	// +optional
	LivenessProbeFailureSeconds *int32 `json:"livenessProbeFailureSeconds,omitempty"`

	// ReadinessProbeFailureSeconds defines the total failure seconds of readiness Probe.
	// Default failureThreshold is 3 and the periodSeconds is 5, this means the readiness
	// will fail if the pod can't respond in 15 seconds. Your ReadinessProbeFailureSeconds is
	// the total time of seconds before pods becomes not ready. If ReadinessProbeFailureSeconds
	// can't be divided by defaultPeriodSeconds, the failureThreshold will be rounded up.
	// Note: you can set it to 0 to disable the readiness probe.
	// +optional
	ReadinessProbeFailureSeconds *int32 `json:"readinessProbeFailureSeconds,omitempty"`

	// Lifecycle describes actions that the management system should take in response to container lifecycle events.
	// By default, Operator will add corresponding preStop hooks for different components. For example, the preStop
	// script for the FE Component is /opt/starrocks/fe_prestop.sh, for the BE Component is /opt/starrocks/be_prestop.sh,
	// and for the CN Component is /opt/starrocks/cn_prestop.sh.
	// +optional
	Lifecycle *corev1.Lifecycle `json:"lifecycle,omitempty"`

	// Share a single process namespace between all of the containers in a pod.
	// When this is set containers will be able to view and signal processes from other containers
	// in the same pod, and the first process in each container will not be assigned PID 1.
	// Optional: Default to false.
	// +optional
	ShareProcessNamespace *bool `json:"shareProcessNamespace,omitempty"`
}

type StarRocksProbe struct {
	// Type identifies the mode of probe main container
	// +kubebuilder:validation:Enum=tcp;command
	Type string `json:"type"`

	// Number of seconds after the container has started before liveness probes are initiated.
	// Default to 10 seconds.
	// +kubebuilder:validation:Minimum=0
	// +optional
	InitialDelaySeconds *int32 `json:"initialDelaySeconds,omitempty"`

	// How often (in seconds) to perform the probe.
	// Default to Kubernetes default (10 seconds). Minimum value is 1.
	// +kubebuilder:validation:Minimum=1
	// +optional
	PeriodSeconds *int32 `json:"periodSeconds,omitempty"`
}

type StarRocksService struct {
	// Annotations' store Kubernetes Service annotations. These will be added to the external service
	// only (not internal).
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`

	// Labels store Kubernetes Service labels. These will be added to the external service only (not
	// internal). StarRocks may add its own default labels.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// type of service,the possible value for the service type are : ClusterIP, NodePort, LoadBalancer,ExternalName.
	// More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
	// +optional
	Type corev1.ServiceType `json:"type,omitempty"`

	// Only applies to Service Type: LoadBalancer.
	// This feature depends on whether the underlying cloud-provider supports specifying
	// the loadBalancerIP when a load balancer is created.
	// This field will be ignored if the cloud-provider does not support the feature.
	// This field was under-specified and its meaning varies across implementations,
	// and it cannot support dual-stack.
	// As of Kubernetes v1.24, users are encouraged to use implementation-specific annotations when available.
	// This field may be removed in a future API version.
	// +optional
	LoadBalancerIP string `json:"loadBalancerIP,omitempty"`

	// Ports are the ports that are exposed by this service.
	// You can override the default port information by specifying the same StarRocksServicePort.Name in the ports list.
	// e.g. if you want to use a dedicated node port, you can just specify the StarRocksServicePort.Name and
	// StarRocksServicePort.NodePort field.
	// +optional
	Ports []StarRocksServicePort `json:"ports,omitempty"`

	// If specified and supported by the platform, this will restrict traffic through the cloud-provider
	// load-balancer will be restricted to the specified client IPs. This field will be ignored if the
	// cloud-provider does not support the feature.
	// More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
	// +optional
	LoadBalancerSourceRanges []string `json:"loadBalancerSourceRanges,omitempty"`
}

type StarRocksServicePort struct {
	// Name of this port within the service.
	// For fe, port name can be http, query, rpc, edit-log, and their default container port is 8030, 9030, 9020, 9010.
	// For be, port name can be webserver, heartbeat, brpc, be, and their default container port is 8040, 9050, 8060, 9060.
	// For cn, port name can be webserver, heartbeat, brpc, thrift, and their default container port is 8040, 9050, 8060, 9060.
	// For fe proxy, port name can be http-port, and its default container port is 8080.
	// +optional
	Name string `json:"name,omitempty"`

	// Port that will be exposed by this service.
	// +optional
	Port int32 `json:"port,omitempty"`

	// ContainerPort of the service port.
	// For fe, port name can be http, query, rpc, edit-log, and their default container port is 8030, 9030, 9020, 9010.
	// For be, port name can be webserver, heartbeat, brpc, be, and their default container port is 8040, 9050, 8060, 9060.
	// For cn, port name can be webserver, heartbeat, brpc, thrift, and their default container port is 8040, 9050, 8060, 9060.
	// For fe proxy, port name can be http-port, and its default container port is 8080.
	// +optional
	ContainerPort int32 `json:"containerPort,omitempty"`

	// NodePort is used to specify the port on each node on which the service is exposed.
	// The range of valid ports is 30000-32767
	// +optional
	NodePort int32 `json:"nodePort,omitempty"`
}

type StarRocksWarehouse struct {
	metav1.TypeMeta `json:",inline"`
	// +k8s:openapi-gen=false
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec represents the specification of desired state of a starrocks warehouse.
	Spec StarRocksWarehouseSpec `json:"spec,omitempty"`

	// Status represents the recent observed status of the starrocks warehouse.
	Status StarRocksWarehouseStatus `json:"status,omitempty"`
}

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

type StarRocksWarehouseSpec struct {
	// StarRocksCluster is the name of a StarRocksCluster which the warehouse belongs to.
	StarRocksCluster string `json:"starRocksCluster"`

	// Template define component configuration.
	Template *WarehouseComponentSpec `json:"template"`
}

type StarRocksWarehouseStatus struct {
	*WarehouseComponentStatus `json:",inline"`
}

type StorageVolume struct {
	// name of a storage volume.
	// +kubebuilder:validation:Pattern=[a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*
	Name string `json:"name"`

	// storageClassName is the name of the StorageClass required by the claim.
	// If storageClassName is not set, the default StorageClass of kubernetes will be used.
	// there are some special storageClassName: emptyDir, hostPath. In this case, It will use emptyDir or hostPath, not PVC.
	// More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1
	// +optional
	StorageClassName *string `json:"storageClassName,omitempty"`

	// StorageSize is a valid memory size type based on powers-of-2, so 1Mi is 1024Ki.
	// Supported units:Mi, Gi, GiB, Ti, Ti, Pi, Ei, Ex: `512Mi`.
	// It will take effect only when storageClassName is real storage class, not emptyDir or hostPath.
	// +kubebuilder:validation:Pattern:="(^0|([0-9]*l[.])?[0-9]+((M|G|T|E|P)i))$"
	// +optional
	StorageSize string `json:"storageSize,omitempty"`

	// HostPath Represents a host path mapped into a pod.
	// If StorageClassName is hostPath, HostPath is required.
	// +optional
	HostPath *corev1.HostPathVolumeSource `json:"hostPath,omitempty"`

	// MountPath specify the path of volume mount.
	MountPath string `json:"mountPath"`

	// SubPath within the volume from which the container's volume should be mounted.
	// Defaults to "" (volume's root).
	SubPath string `json:"subPath,omitempty"`
}

type WarehouseComponentSpec struct {
	StarRocksComponentSpec `json:",inline"`

	// +optional
	// envVars is a slice of environment variables that are added to the pods, the default is empty.
	EnvVars []corev1.EnvVar `json:"envVars,omitempty"`

	// AutoScalingPolicy defines auto scaling policy
	AutoScalingPolicy *AutoScalingPolicy `json:"autoScalingPolicy,omitempty"`
}

type WarehouseComponentStatus = StarRocksCnStatus