v1alpha1

type AccessMode string

type AccountName string

type Action struct {
	// Image defines the container image to run the action.
	// Cannot be updated.
	// +optional
	Image string `json:"image,omitempty"`

	// Exec specifies the action to take.
	// Cannot be updated.
	// +optional
	Exec *ExecAction `json:"exec,omitempty"`

	// HTTP specifies the http request to perform.
	// Cannot be updated.
	// +optional
	HTTP *HTTPAction `json:"http,omitempty"`

	// List of environment variables to set in the container.
	// Cannot be updated.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge
	Env []corev1.EnvVar `json:"env,omitempty" patchStrategy:"merge" patchMergeKey:"name"`

	// TargetPodSelector defines the way that how to select the target Pod where the action will be performed,
	// if there may not have a target replica by default.
	// Cannot be updated.
	// +optional
	TargetPodSelector TargetPodSelector `json:"targetPodSelector,omitempty"`

	// MatchingKey uses to select the target pod(s) actually.
	// If the selector is AnyReplica or AllReplicas, the matchingKey will be ignored.
	// If the selector is RoleSelector, any replica which has the same role with matchingKey will be chosen.
	// Cannot be updated.
	// +optional
	MatchingKey string `json:"matchingKey,omitempty"`

	// Container defines the name of the container within the target Pod where the action will be executed.
	// If specified, it must be one of container declared in @Runtime.
	// If not specified, the first container declared in @Runtime will be used.
	// Cannot be updated.
	// +optional
	Container string `json:"container,omitempty"`

	// TimeoutSeconds defines the timeout duration for the action in seconds.
	// Cannot be updated.
	// +kubebuilder:default=0
	// +optional
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`

	// RetryPolicy defines the strategy for retrying the action in case of failure.
	// Cannot be updated.
	// +optional
	RetryPolicy *RetryPolicy `json:"retryPolicy,omitempty"`

	// PreCondition defines the condition when the action will be executed.
	//
	// - Immediately: The Action is executed immediately after the Component object is created,
	//   without guaranteeing the availability of the Component and its underlying resources. only after the action is successfully executed will the Component's state turn to ready.
	// - RuntimeReady: The Action is executed after the Component object is created and once all underlying Runtimes are ready.
	//   only after the action is successfully executed will the Component's state turn to ready.
	// - ComponentReady: The Action is executed after the Component object is created and once the Component is ready.
	//   the execution process does not impact the state of the Component and the Cluster.
	// - ClusterReady: The Action is executed after the Cluster object is created and once the Cluster is ready.
	//
	// the execution process does not impact the state of the Component and the Cluster.
	// Cannot be updated.
	// +optional
	PreCondition *PreConditionType `json:"preCondition,omitempty"`
}

type Affinity struct {
	// podAntiAffinity describes the anti-affinity level of pods within a component.
	// Preferred means try spread pods by `TopologyKeys`.
	// Required means must spread pods by `TopologyKeys`.
	// +kubebuilder:default=Preferred
	// +optional
	PodAntiAffinity PodAntiAffinity `json:"podAntiAffinity,omitempty"`

	// topologyKey is the key of node labels.
	// Nodes that have a label with this key and identical values are considered to be in the same topology.
	// It's used as the topology domain for pod anti-affinity and pod spread constraint.
	// Some well-known label keys, such as `kubernetes.io/hostname` and `topology.kubernetes.io/zone`
	// are often used as TopologyKey, as well as any other custom label key.
	//
	// +listType=set
	// +optional
	TopologyKeys []string `json:"topologyKeys,omitempty"`

	// nodeLabels describes that pods must be scheduled to the nodes with the specified node labels.
	// +optional
	NodeLabels map[string]string `json:"nodeLabels,omitempty"`

	// tenancy describes how pods are distributed across node.
	// SharedNode means multiple pods may share the same node.
	// DedicatedNode means each pod runs on their own dedicated node.
	// +kubebuilder:default=SharedNode
	// +optional
	Tenancy TenancyType `json:"tenancy,omitempty"`
}

type AutoTrigger struct {
	// processName is process name
	// +optional
	ProcessName string `json:"processName,omitempty"`
}

type AvailabilityPolicyType string

type BackupMethod struct {
	dpv1alpha1.BackupMethod `json:",inline"`

	// target instance for backup.
	// +optional
	Target *TargetInstance `json:"target"`

	// envMapping defines the variables of cluster mapped to env values' keys.
	// +optional
	EnvMapping []EnvMappingVar `json:"envMapping,omitempty"`
}

type BackupPolicy struct {
	// componentDefRef references componentDef defined in ClusterDefinition spec. Need to
	// comply with IANA Service Naming rule.
	// +kubebuilder:validation:MaxLength=22
	// +kubebuilder:validation:Pattern:=`^[a-z]([a-z0-9\-]*[a-z0-9])?$`
	// +optional
	ComponentDefRef string `json:"componentDefRef,omitempty"`

	// componentDef references componentDefinition. Need to
	// comply with IANA Service Naming rule.
	// +optional
	ComponentDefs []string `json:"componentDefs,omitempty"`

	// target instance for backup.
	// +optional
	Target TargetInstance `json:"target"`

	// schedule policy for backup.
	// +optional
	Schedules []SchedulePolicy `json:"schedules,omitempty"`

	// backupMethods defines the backup methods.
	// +kubebuilder:validation:Required
	BackupMethods []BackupMethod `json:"backupMethods"`

	// Specifies the number of retries before marking the backup failed.
	// +optional
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=10
	BackoffLimit *int32 `json:"backoffLimit,omitempty"`
}

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

	Spec   BackupPolicyTemplateSpec   `json:"spec,omitempty"`
	Status BackupPolicyTemplateStatus `json:"status,omitempty"`
}

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

type BackupPolicyTemplateSpec struct {
	// clusterDefinitionRef references ClusterDefinition name, this is an immutable attribute.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="clusterDefinitionRef is immutable"
	ClusterDefRef string `json:"clusterDefinitionRef"`

	// backupPolicies is a list of backup policy template for the specified componentDefinition.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinItems=1
	BackupPolicies []BackupPolicy `json:"backupPolicies"`

	// Identifier is a unique identifier for this BackupPolicyTemplate.
	// this identifier will be the suffix of the automatically generated backupPolicy name.
	// and must be added when multiple BackupPolicyTemplates exist,
	// otherwise the generated backupPolicy override will occur.
	// +optional
	// +kubebuilder:validation:MaxLength=20
	Identifier string `json:"identifier,omitempty"`
}

type BackupPolicyTemplateStatus struct {
}

type BackupRefSpec struct {
	// Refers to a reference backup that needs to be restored.
	// +optional
	Ref RefNamespaceName `json:"ref,omitempty"`
}

type BackupSpec struct {
	// Specifies the name of the backup.
	// +optional
	BackupName string `json:"backupName,omitempty"`

	// Indicates the backupPolicy applied to perform this backup.
	// +optional
	BackupPolicyName string `json:"backupPolicyName,omitempty"`

	// Defines the backup method that is defined in backupPolicy.
	// +optional
	BackupMethod string `json:"backupMethod,omitempty"`

	// Determines whether the backup contents stored in backup repository
	// should be deleted when the backup custom resource is deleted.
	// Supported values are `Retain` and `Delete`.
	// - `Retain` means that the backup content and its physical snapshot on backup repository are kept.
	// - `Delete` means that the backup content and its physical snapshot on backup repository are deleted.
	// +kubebuilder:validation:Enum=Delete;Retain
	// +kubebuilder:validation:Required
	// +kubebuilder:default=Delete
	// +optional
	DeletionPolicy string `json:"deletionPolicy,omitempty"`

	// Determines a duration up to which the backup should be kept.
	// Controller will remove all backups that are older than the RetentionPeriod.
	// For example, RetentionPeriod of `30d` will keep only the backups of last 30 days.
	// Sample duration format:
	//
	// - years: 2y
	// - months: 6mo
	// - days: 30d
	// - hours: 12h
	// - minutes: 30m
	//
	// You can also combine the above durations. For example: 30d12h30m.
	// If not set, the backup will be kept forever.
	// +optional
	RetentionPeriod string `json:"retentionPeriod,omitempty"`

	// If backupType is incremental, parentBackupName is required.
	// +optional
	ParentBackupName string `json:"parentBackupName,omitempty"`
}

type BackupStatusUpdateStage string

type BaseBackupType string

type BuiltinActionHandlerType string

type CPUConstraint struct {
	// The maximum count of vcpu cores, [Min, Max] defines a range for valid vcpu cores, and the value in this range
	// must be multiple times of Step. It's useful to define a large number of valid values without defining them one by
	// one. Please see the documentation for Step for some examples.
	// If Slots is specified, Max, Min, and Step are ignored
	// +optional
	Max *resource.Quantity `json:"max,omitempty"`

	// The minimum count of vcpu cores, [Min, Max] defines a range for valid vcpu cores, and the value in this range
	// must be multiple times of Step. It's useful to define a large number of valid values without defining them one by
	// one. Please see the documentation for Step for some examples.
	// If Slots is specified, Max, Min, and Step are ignored
	// +optional
	Min *resource.Quantity `json:"min,omitempty"`

	// The minimum granularity of vcpu cores, [Min, Max] defines a range for valid vcpu cores and the value in this range must be
	// multiple times of Step.
	// For example:
	// 1. Min is 2, Max is 8, Step is 2, and the valid vcpu core is {2, 4, 6, 8}.
	// 2. Min is 0.5, Max is 2, Step is 0.5, and the valid vcpu core is {0.5, 1, 1.5, 2}.
	// +optional
	Step *resource.Quantity `json:"step,omitempty"`

	// The valid vcpu cores, it's useful if you want to define valid vcpu cores explicitly.
	// If Slots is specified, Max, Min, and Step are ignored
	// +optional
	Slots []resource.Quantity `json:"slots,omitempty"`
}

type CfgFileFormat string

type CfgReloadType string

type ClassDefRef struct {
	// Name refers to the name of the ComponentClassDefinition.
	// +kubebuilder:validation:MaxLength=63
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	// +optional
	Name string `json:"name,omitempty"`

	// Class refers to the name of the class that is defined in the ComponentClassDefinition.
	// +kubebuilder:validation:Required
	Class string `json:"class"`
}

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

	Spec   ClusterSpec   `json:"spec,omitempty"`
	Status ClusterStatus `json:"status,omitempty"`
}

type ClusterBackup struct {
	// enabled defines whether to enable automated backup.
	// +kubebuilder:default=false
	// +optional
	Enabled *bool `json:"enabled,omitempty"`

	// retentionPeriod determines a duration up to which the backup should be kept.
	// controller will remove all backups that are older than the RetentionPeriod.
	// For example, RetentionPeriod of `30d` will keep only the backups of last 30 days.
	// Sample duration format:
	//
	// - years: 	2y
	// - months: 	6mo
	// - days: 		30d
	// - hours: 	12h
	// - minutes: 	30m
	//
	// You can also combine the above durations. For example: 30d12h30m
	//
	// +kubebuilder:default="7d"
	// +optional
	RetentionPeriod dpv1alpha1.RetentionPeriod `json:"retentionPeriod,omitempty"`

	// backup method name to use, that is defined in backupPolicy.
	// +optional
	Method string `json:"method"`

	// the cron expression for schedule, the timezone is in UTC. see https://en.wikipedia.org/wiki/Cron.
	// +optional
	CronExpression string `json:"cronExpression,omitempty"`

	// startingDeadlineMinutes defines the deadline in minutes for starting the backup job
	// if it misses scheduled time for any reason.
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:validation:Maximum=1440
	// +optional
	StartingDeadlineMinutes *int64 `json:"startingDeadlineMinutes,omitempty"`

	// repoName is the name of the backupRepo, if not set, will use the default backupRepo.
	// +optional
	RepoName string `json:"repoName,omitempty"`

	// pitrEnabled defines whether to enable point-in-time recovery.
	// +kubebuilder:default=false
	// +optional
	PITREnabled *bool `json:"pitrEnabled,omitempty"`
}

type ClusterComponentDefinition struct {
	// A component definition name, this name could be used as default name of `Cluster.spec.componentSpecs.name`,
	// and so this name is need to conform with same validation rules as `Cluster.spec.componentSpecs.name`, that
	// is currently comply with IANA Service Naming rule. This name will apply to "apps.kubeblocks.io/component-name"
	// object label value.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MaxLength=22
	// +kubebuilder:validation:Pattern:=`^[a-z]([a-z0-9\-]*[a-z0-9])?$`
	Name string `json:"name"`

	// The description of component definition.
	// +optional
	Description string `json:"description,omitempty"`

	// workloadType defines type of the workload.
	//
	// - `Stateless` is a stateless workload type used to describe stateless applications.
	// - `Stateful` is a stateful workload type used to describe common stateful applications.
	// - `Consensus` is a stateful workload type used to describe applications based on consensus protocols, common consensus protocols such as raft and paxos.
	// - `Replication` is a stateful workload type used to describe applications based on the primary-secondary data replication protocol.
	//
	// +kubebuilder:validation:Required
	WorkloadType WorkloadType `json:"workloadType"`

	// characterType defines well-known database component name, such as mongos(mongodb), proxy(redis), mariadb(mysql).
	// KubeBlocks will generate proper monitor configs for well-known characterType when builtIn is true.
	//
	// It will also be used in role probe to decide which probe engine to use.
	// current available candidates are: mysql, postgres, mongodb, redis, etcd, kafka.
	//
	// +optional
	CharacterType string `json:"characterType,omitempty"`

	// The configSpec field provided by provider, and
	// finally this configTemplateRefs will be rendered into the user's own configuration file according to the user's cluster.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	ConfigSpecs []ComponentConfigSpec `json:"configSpecs,omitempty"`

	// The scriptSpec field provided by provider, and
	// finally this configTemplateRefs will be rendered into the user's own configuration file according to the user's cluster.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	// +optional
	ScriptSpecs []ComponentTemplateSpec `json:"scriptSpecs,omitempty"`

	// probes setting for healthy checks.
	// +optional
	Probes *ClusterDefinitionProbes `json:"probes,omitempty"`

	// monitor is monitoring config which provided by provider.
	// +optional
	Monitor *MonitorConfig `json:"monitor,omitempty"`

	// logConfigs is detail log file config which provided by provider.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	LogConfigs []LogConfig `json:"logConfigs,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// podSpec define pod spec template of the cluster component.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	PodSpec *corev1.PodSpec `json:"podSpec,omitempty"`

	// service defines the behavior of a service spec.
	// provide read-write service when WorkloadType is Consensus.
	// +optional
	Service *ServiceSpec `json:"service,omitempty"`

	// statelessSpec defines stateless related spec if workloadType is Stateless.
	// +optional
	// +kubebuilder:deprecatedversion:warning="This field is deprecated from KB 0.7.0, use RSMSpec instead."
	StatelessSpec *StatelessSetSpec `json:"statelessSpec,omitempty"`

	// statefulSpec defines stateful related spec if workloadType is Stateful.
	// +optional
	// +kubebuilder:deprecatedversion:warning="This field is deprecated from KB 0.7.0, use RSMSpec instead."
	StatefulSpec *StatefulSetSpec `json:"statefulSpec,omitempty"`

	// consensusSpec defines consensus related spec if workloadType is Consensus, required if workloadType is Consensus.
	// +optional
	// +kubebuilder:deprecatedversion:warning="This field is deprecated from KB 0.7.0, use RSMSpec instead."
	ConsensusSpec *ConsensusSetSpec `json:"consensusSpec,omitempty"`

	// replicationSpec defines replication related spec if workloadType is Replication.
	// +optional
	// +kubebuilder:deprecatedversion:warning="This field is deprecated from KB 0.7.0, use RSMSpec instead."
	ReplicationSpec *ReplicationSetSpec `json:"replicationSpec,omitempty"`

	// RSMSpec defines workload related spec of this component.
	// start from KB 0.7.0, RSM(ReplicatedStateMachineSpec) will be the underlying CR which powers all kinds of workload in KB.
	// RSM is an enhanced stateful workload extension dedicated for heavy-state workloads like databases.
	// +optional
	RSMSpec *RSMSpec `json:"rsmSpec,omitempty"`

	// horizontalScalePolicy controls the behavior of horizontal scale.
	// +optional
	HorizontalScalePolicy *HorizontalScalePolicy `json:"horizontalScalePolicy,omitempty"`

	// Statement to create system account.
	// +optional
	SystemAccounts *SystemAccountSpec `json:"systemAccounts,omitempty"`

	// volumeTypes is used to describe the purpose of the volumes
	// mapping the name of the VolumeMounts in the PodSpec.Container field,
	// such as data volume, log volume, etc.
	// When backing up the volume, the volume can be correctly backed up
	// according to the volumeType.
	//
	// For example:
	//
	// - `name: data, type: data` means that the volume named `data` is used to store `data`.
	// - `name: binlog, type: log` means that the volume named `binlog` is used to store `log`.
	//
	// NOTE: When volumeTypes is not defined, the backup function will not be supported,
	// even if a persistent volume has been specified.
	//
	// +listType=map
	// +listMapKey=name
	// +optional
	VolumeTypes []VolumeTypeSpec `json:"volumeTypes,omitempty"`

	// customLabelSpecs is used for custom label tags which you want to add to the component resources.
	// +listType=map
	// +listMapKey=key
	// +optional
	CustomLabelSpecs []CustomLabelSpec `json:"customLabelSpecs,omitempty"`

	// switchoverSpec defines command to do switchover.
	// in particular, when workloadType=Replication, the command defined in switchoverSpec will only be executed under the condition of cluster.componentSpecs[x].SwitchPolicy.type=Noop.
	// +optional
	SwitchoverSpec *SwitchoverSpec `json:"switchoverSpec,omitempty"`

	// postStartSpec defines the command to be executed when the component is ready, and the command will only be executed once after the component becomes ready.
	// +optional
	PostStartSpec *PostStartAction `json:"postStartSpec,omitempty"`

	// +optional
	VolumeProtectionSpec *VolumeProtectionSpec `json:"volumeProtectionSpec,omitempty"`

	// componentDefRef is used to inject values from other components into the current component.
	// values will be saved and updated in a configmap and mounted to the current component.
	// +patchMergeKey=componentDefName
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=componentDefName
	// +optional
	ComponentDefRef []ComponentDefRef `json:"componentDefRef,omitempty" patchStrategy:"merge" patchMergeKey:"componentDefName"`

	// serviceRefDeclarations is used to declare the service reference of the current component.
	// +optional
	ServiceRefDeclarations []ServiceRefDeclaration `json:"serviceRefDeclarations,omitempty"`
}

type ClusterComponentPhase string

type ClusterComponentService struct {
	// Service name
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MaxLength=15
	Name string `json:"name"`

	// serviceType determines how the Service is exposed. Valid
	// options are ClusterIP, NodePort, and LoadBalancer.
	//
	// - `ClusterIP` allocates a cluster-internal IP address for load-balancing
	//   to endpoints. Endpoints are determined by the selector or if that is not
	//   specified, they are determined by manual construction of an Endpoints object or
	//   EndpointSlice objects. If clusterIP is "None", no virtual IP is
	//   allocated and the endpoints are published as a set of endpoints rather
	//   than a virtual IP.
	// - `NodePort` builds on ClusterIP and allocates a port on every node which
	//   routes to the same endpoints as the clusterIP.
	// - `LoadBalancer` builds on NodePort and creates an external load-balancer
	//   (if supported in the current cloud) which routes to the same endpoints
	//   as the clusterIP.
	//
	// More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types.
	//
	// +kubebuilder:default=ClusterIP
	// +kubebuilder:validation:Enum={ClusterIP,NodePort,LoadBalancer}
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	ServiceType corev1.ServiceType `json:"serviceType,omitempty"`

	// If ServiceType is LoadBalancer, cloud provider related parameters can be put here
	// More info: https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer.
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
}

type ClusterComponentSpec struct {
	// name defines cluster's component name, this name is also part of Service DNS name, so this name will comply with IANA Service Naming rule.
	// When ClusterComponentSpec is referenced as a template, name is optional. Otherwise, it is required.
	// +kubebuilder:validation:MaxLength=22
	// +kubebuilder:validation:Pattern:=`^[a-z]([a-z0-9\-]*[a-z0-9])?$`
	// TODO +kubebuilder:validation:XValidation:rule="self == oldSelf",message="name is immutable"
	// +optional
	Name string `json:"name"`

	// componentDefRef references componentDef defined in ClusterDefinition spec. Need to comply with IANA Service Naming rule.
	// +kubebuilder:validation:MaxLength=22
	// +kubebuilder:validation:Pattern:=`^[a-z]([a-z0-9\-]*[a-z0-9])?$`
	// TODO +kubebuilder:validation:XValidation:rule="self == oldSelf",message="componentDefRef is immutable"
	// +optional
	ComponentDefRef string `json:"componentDefRef,omitempty"`

	// componentDef references the name of the ComponentDefinition.
	// If both componentDefRef and componentDef are provided, the componentDef will take precedence over componentDefRef.
	// +kubebuilder:validation:MaxLength=22
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	// TODO +kubebuilder:validation:XValidation:rule="self == oldSelf",message="componentDef is immutable"
	// +optional
	ComponentDef string `json:"componentDef,omitempty"`

	// classDefRef references the class defined in ComponentClassDefinition.
	// +kubebuilder:deprecatedversion:warning="Due to the lack of practical use cases, this field is deprecated from KB 0.9.0."
	// +optional
	ClassDefRef *ClassDefRef `json:"classDefRef,omitempty"`

	// serviceRefs define service references for the current component. Based on the referenced services, they can be categorized into two types:
	//
	// - Service provided by external sources: These services are provided by external sources and are not managed by KubeBlocks. They can be Kubernetes-based or non-Kubernetes services. For external services, you need to provide an additional ServiceDescriptor object to establish the service binding.
	// - Service provided by other KubeBlocks clusters: These services are provided by other KubeBlocks clusters. You can bind to these services by specifying the name of the hosting cluster.
	//
	// Each type of service reference requires specific configurations and bindings to establish the connection and interaction with the respective services.
	// It should be noted that the ServiceRef has cluster-level semantic consistency, meaning that within the same Cluster, service references with the same ServiceRef.Name are considered to be the same service. It is only allowed to bind to the same Cluster or ServiceDescriptor.
	//
	// +optional
	ServiceRefs []ServiceRef `json:"serviceRefs,omitempty"`

	// monitor is a switch to enable monitoring and is set as false by default.
	// KubeBlocks provides an extension mechanism to support component level monitoring,
	// which will scrape metrics auto or manually from servers in component and export
	// metrics to Time Series Database.
	// +kubebuilder:default=false
	// +optional
	Monitor bool `json:"monitor,omitempty"`

	// enabledLogs indicates which log file takes effect in the database cluster.
	// element is the log type which is defined in cluster definition logConfig.name,
	// and will set relative variables about this log type in database kernel.
	// +listType=set
	// +optional
	EnabledLogs []string `json:"enabledLogs,omitempty"`

	// Component replicas.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum=0
	// +kubebuilder:default=1
	Replicas int32 `json:"replicas"`

	// affinity describes affinities specified by users.
	// +optional
	Affinity *Affinity `json:"affinity,omitempty"`

	// Component tolerations will override ClusterSpec.Tolerations if specified.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`

	// Resources requests and limits of workload.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Resources corev1.ResourceRequirements `json:"resources,omitempty"`

	// volumeClaimTemplates information for statefulset.spec.volumeClaimTemplates.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	VolumeClaimTemplates []ClusterComponentVolumeClaimTemplate `json:"volumeClaimTemplates,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// Services expose endpoints that can be accessed by clients.
	// +optional
	Services []ClusterComponentService `json:"services,omitempty"`

	// switchPolicy defines the strategy for switchover and failover when workloadType is Replication.
	// +optional
	SwitchPolicy *ClusterSwitchPolicy `json:"switchPolicy,omitempty"`

	// Enables or disables TLS certs.
	// +optional
	TLS bool `json:"tls,omitempty"`

	// issuer defines provider context for TLS certs.
	// required when TLS enabled
	// +optional
	Issuer *Issuer `json:"issuer,omitempty"`

	// serviceAccountName is the name of the ServiceAccount that running component depends on.
	// +optional
	ServiceAccountName string `json:"serviceAccountName,omitempty"`

	// noCreatePDB defines the PodDisruptionBudget creation behavior and is set to true if creation of PodDisruptionBudget
	// for this component is not needed. It defaults to false.
	// +kubebuilder:default=false
	// +optional
	NoCreatePDB bool `json:"noCreatePDB,omitempty"`

	// updateStrategy defines the update strategy for the component.
	// +optional
	UpdateStrategy *UpdateStrategy `json:"updateStrategy,omitempty"`

	// userResourceRefs defines the user-defined volumes.
	// +optional
	UserResourceRefs *UserResourceRefs `json:"userResourceRefs,omitempty"`

	// RsmTransformPolicy defines the policy generate sts using rsm.
	// ToSts: rsm transforms to statefulSet
	// ToPod: rsm transforms to pods
	// +kubebuilder:validation:Required
	// +kubebuilder:default=ToSts
	// +optional
	RsmTransformPolicy workloads.RsmTransformPolicy `json:"rsmTransformPolicy,omitempty"`

	// Nodes defines the list of nodes that pods can schedule
	// If the RsmTransformPolicy is specified as ToPod,the list of nodes will be used. If the list of nodes is empty,
	// no specific node will be assigned. However, if the list of node is filled, all pods will be evenly scheduled
	// across the nodes in the list.
	// +optional
	Nodes []types.NodeName `json:"nodes,omitempty"`

	// Instances defines the list of instance to be deleted priorly
	// If the RsmTransformPolicy is specified as ToPod,the list of instances will be used.
	// +optional
	Instances []string `json:"instances,omitempty"`
}

type ClusterComponentStatus struct {
	// phase describes the phase of the component and the detail information of the phases are as following:
	//
	// - Creating: `Creating` is a special `Updating` with previous phase `empty`(means "") or `Creating`.
	// - Running: component replicas > 0 and all pod specs are latest with a Running state.
	// - Updating: component replicas > 0 and has no failed pods. the component is being updated.
	// - Abnormal: component replicas > 0 but having some failed pods. the component basically works but in a fragile state.
	// - Failed: component replicas > 0 but having some failed pods. the component doesn't work anymore.
	// - Stopping: component replicas = 0 and has terminating pods.
	// - Stopped: component replicas = 0 and all pods have been deleted.
	// - Deleting: the component is being deleted.
	Phase ClusterComponentPhase `json:"phase,omitempty"`

	// message records the component details message in current phase.
	// Keys are podName or deployName or statefulSetName. The format is `ObjectKind/Name`.
	// +optional
	Message ComponentMessageMap `json:"message,omitempty"`

	// podsReady checks if all pods of the component are ready.
	// +optional
	PodsReady *bool `json:"podsReady,omitempty"`

	// podsReadyTime what time point of all component pods are ready,
	// this time is the ready time of the last component pod.
	// +optional
	PodsReadyTime *metav1.Time `json:"podsReadyTime,omitempty"`

	// consensusSetStatus specifies the mapping of role and pod name.
	// +optional
	// +kubebuilder:deprecatedversion:warning="This field is deprecated from KB 0.7.0, use MembersStatus instead."
	ConsensusSetStatus *ConsensusSetStatus `json:"consensusSetStatus,omitempty"`

	// replicationSetStatus specifies the mapping of role and pod name.
	// +optional
	// +kubebuilder:deprecatedversion:warning="This field is deprecated from KB 0.7.0, use MembersStatus instead."
	ReplicationSetStatus *ReplicationSetStatus `json:"replicationSetStatus,omitempty"`

	// members' status.
	// +optional
	MembersStatus []workloads.MemberStatus `json:"membersStatus,omitempty"`
}

type ClusterComponentVersion struct {
	// componentDefRef reference one of the cluster component definition names in ClusterDefinition API (spec.componentDefs.name).
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MaxLength=63
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	ComponentDefRef string `json:"componentDefRef"`

	// configSpecs defines a configuration extension mechanism to handle configuration differences between versions,
	// the configTemplateRefs field, together with configTemplateRefs in the ClusterDefinition,
	// determines the final configuration file.
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	ConfigSpecs []ComponentConfigSpec `json:"configSpecs,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// systemAccountSpec define image for the component to connect database or engines.
	// It overrides `image` and `env` attributes defined in ClusterDefinition.spec.componentDefs.systemAccountSpec.cmdExecutorConfig.
	// To clean default envs settings, set `SystemAccountSpec.CmdExecutorConfig.Env` to empty list.
	// +optional
	SystemAccountSpec *SystemAccountShortSpec `json:"systemAccountSpec,omitempty"`

	// versionContext defines containers images' context for component versions,
	// this value replaces ClusterDefinition.spec.componentDefs.podSpec.[initContainers | containers]
	VersionsCtx VersionsContext `json:"versionsContext"`

	// switchoverSpec defines images for the component to do switchover.
	// It overrides `image` and `env` attributes defined in ClusterDefinition.spec.componentDefs.SwitchoverSpec.CommandExecutorEnvItem.
	// +optional
	SwitchoverSpec *SwitchoverShortSpec `json:"switchoverSpec,omitempty"`
}

type ClusterComponentVolumeClaimTemplate struct {
	// Reference `ClusterDefinition.spec.componentDefs.containers.volumeMounts.name`.
	// +kubebuilder:validation:Required
	Name string `json:"name"`
	// spec defines the desired characteristics of a volume requested by a pod author.
	// +optional
	Spec PersistentVolumeClaimSpec `json:"spec,omitempty"`
}

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

	Spec   ClusterDefinitionSpec   `json:"spec,omitempty"`
	Status ClusterDefinitionStatus `json:"status,omitempty"`
}

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

type ClusterDefinitionProbe struct {
	// How often (in seconds) to perform the probe.
	// +kubebuilder:default=1
	// +kubebuilder:validation:Minimum=1
	PeriodSeconds int32 `json:"periodSeconds,omitempty"`

	// Number of seconds after which the probe times out. Defaults to 1 second.
	// +kubebuilder:default=1
	// +kubebuilder:validation:Minimum=1
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`

	// Minimum consecutive failures for the probe to be considered failed after having succeeded.
	// +kubebuilder:default=3
	// +kubebuilder:validation:Minimum=2
	FailureThreshold int32 `json:"failureThreshold,omitempty"`

	// commands used to execute for probe.
	// +optional
	Commands *ClusterDefinitionProbeCMDs `json:"commands,omitempty"`
}

type ClusterDefinitionProbeCMDs struct {
	// Write check executed on probe sidecar, used to check workload's allow write access.
	// +optional
	Writes []string `json:"writes,omitempty"`

	// Read check executed on probe sidecar, used to check workload's readonly access.
	// +optional
	Queries []string `json:"queries,omitempty"`
}

type ClusterDefinitionProbes struct {
	// Probe for DB running check.
	// +optional
	RunningProbe *ClusterDefinitionProbe `json:"runningProbe,omitempty"`

	// Probe for DB status check.
	// +optional
	StatusProbe *ClusterDefinitionProbe `json:"statusProbe,omitempty"`

	// Probe for DB role changed check.
	// +optional
	// +kubebuilder:deprecatedversion:warning="This field is deprecated from KB 0.7.0, use RSMSpec instead."
	RoleProbe *ClusterDefinitionProbe `json:"roleProbe,omitempty"`

	// roleProbeTimeoutAfterPodsReady(in seconds), when all pods of the component are ready,
	// it will detect whether the application is available in the pod.
	// if pods exceed the InitializationTimeoutSeconds time without a role label,
	// this component will enter the Failed/Abnormal phase.
	//
	// Note that this configuration will only take effect if the component supports RoleProbe
	// and will not affect the life cycle of the pod. default values are 60 seconds.
	//
	// +optional
	// +kubebuilder:validation:Minimum=30
	RoleProbeTimeoutAfterPodsReady int32 `json:"roleProbeTimeoutAfterPodsReady,omitempty"`
}

type ClusterDefinitionSpec struct {

	// Cluster definition type defines well known application cluster type, e.g. mysql/redis/mongodb
	// +kubebuilder:validation:MaxLength=24
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$`
	// +optional
	Type string `json:"type,omitempty"`

	// componentDefs provides cluster components definitions.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinItems=1
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	ComponentDefs []ClusterComponentDefinition `json:"componentDefs" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// Connection credential template used for creating a connection credential
	// secret for cluster.apps.kubeblocks.io object.
	//
	// Built-in objects are:
	//
	// - `$(RANDOM_PASSWD)` random 8 characters.
	// dfjksgks
	// - `$(STRONG_RANDOM_PASSWD)` random 16 characters, with mixed cases, digits and symbols.
	// - `$(UUID)` generate a random UUID v4 string.
	// - `$(UUID_B64)` generate a random UUID v4 BASE64 encoded string.
	// - `$(UUID_STR_B64)` generate a random UUID v4 string then BASE64 encoded.
	// - `$(UUID_HEX)` generate a random UUID v4 HEX representation.
	// - `$(HEADLESS_SVC_FQDN)` headless service FQDN placeholder, value pattern is `$(CLUSTER_NAME)-$(1ST_COMP_NAME)-headless.$(NAMESPACE).svc`,
	//    where 1ST_COMP_NAME is the 1st component that provide `ClusterDefinition.spec.componentDefs[].service` attribute;
	// - `$(SVC_FQDN)` service FQDN placeholder, value pattern is `$(CLUSTER_NAME)-$(1ST_COMP_NAME).$(NAMESPACE).svc`,
	//    where 1ST_COMP_NAME is the 1st component that provide `ClusterDefinition.spec.componentDefs[].service` attribute;
	// - `$(SVC_PORT_{PORT-NAME})` is ServicePort's port value with specified port name, i.e, a servicePort JSON struct:
	//    `{"name": "mysql", "targetPort": "mysqlContainerPort", "port": 3306}`, and `$(SVC_PORT_mysql)` in the
	//    connection credential value is 3306.
	// +optional
	ConnectionCredential map[string]string `json:"connectionCredential,omitempty"`
}

type ClusterDefinitionStatus struct {
	// ClusterDefinition phase, valid values are `empty`, `Available`, `Unavailable`.
	// Available is ClusterDefinition become available, and can be referenced for co-related objects.
	Phase Phase `json:"phase,omitempty"`

	// Extra message in current phase
	// +optional
	Message string `json:"message,omitempty"`

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

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

type ClusterMonitor struct {

	// monitoringInterval specifies interval of monitoring, no monitor if set to 0
	// +kubebuilder:validation:XIntOrString
	// +optional
	MonitoringInterval *intstr.IntOrString `json:"monitoringInterval,omitempty"`
}

type ClusterNetwork struct {

	// hostNetworkAccessible specifies whether host network is accessible. It defaults to false
	// +kubebuilder:default=false
	// +optional
	HostNetworkAccessible bool `json:"hostNetworkAccessible,omitempty"`

	// publiclyAccessible specifies whether it is publicly accessible. It defaults to false
	// +kubebuilder:default=false
	// +optional
	PubliclyAccessible bool `json:"publiclyAccessible,omitempty"`
}

type ClusterObjectReference struct {
	// CompDef specifies the definition used by the component that the referent object resident in.
	// If not specified, the component itself will be used.
	// +optional
	CompDef string `json:"compDef,omitempty"`

	// Name of the referent object.
	// +optional
	Name string `json:"name,omitempty"`

	// Specify whether the object must be defined.
	// +optional
	Optional *bool `json:"optional,omitempty"`

	// This option defines the behavior when multiple component objects match the specified @CompDef.
	// If not provided, an error will be raised when handling multiple matches.
	//
	// +optional
	MultipleClusterObjectOption *MultipleClusterObjectOption `json:"multipleClusterObjectOption,omitempty"`
}

type ClusterPhase string

type ClusterResourceConstraintSelector struct {
	// clusterDefRef is the name of the cluster definition.
	// +kubebuilder:validation:Required
	ClusterDefRef string `json:"clusterDefRef"`

	// selector is used to bind the resource constraint to components.
	// +listType=map
	// +listMapKey=componentDefRef
	// +kubebuilder:validation:Required
	Components []ComponentResourceConstraintSelector `json:"components"`
}

type ClusterResources struct {

	// cpu resource needed, more info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	// +optional
	CPU resource.Quantity `json:"cpu,omitempty"`

	// memory resource needed, more info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	// +optional
	Memory resource.Quantity `json:"memory,omitempty"`
}

type ClusterService struct {
	Service `json:",inline"`

	// ShardingSelector extends the ServiceSpec.Selector by allowing you to specify a sharding name
	// defined in Cluster.Spec.ShardingSpecs[x].Name as selectors for the service.
	// ShardingSelector and ComponentSelector cannot be set at the same time.
	// +optional
	ShardingSelector string `json:"shardingSelector,omitempty"`

	// ComponentSelector extends the ServiceSpec.Selector by allowing you to specify a component as selectors for the service.
	// ComponentSelector and ShardingSelector cannot be set at the same time.
	// +optional
	ComponentSelector string `json:"componentSelector,omitempty"`
}

type ClusterSpec struct {
	// Cluster referencing ClusterDefinition name. This is an immutable attribute.
	// If ClusterDefRef is not specified, ComponentDef must be specified for each Component in ComponentSpecs.
	// +kubebuilder:validation:MaxLength=63
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="clusterDefinitionRef is immutable"
	// +optional
	ClusterDefRef string `json:"clusterDefinitionRef,omitempty"`

	// Cluster referencing ClusterVersion name.
	// +kubebuilder:validation:MaxLength=63
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	// +optional
	ClusterVersionRef string `json:"clusterVersionRef,omitempty"`

	// Cluster termination policy. Valid values are `DoNotTerminate`, `Halt`, `Delete`, `WipeOut`.
	//
	// - DoNotTerminate will block delete operation.
	// - Halt will delete workload resources such as statefulset, deployment workloads but keep PVCs.
	// - Delete is based on Halt and deletes PVCs.
	// - WipeOut is based on Delete and wipe out all volume snapshots and snapshot data from backup storage location.
	//
	// +kubebuilder:validation:Required
	TerminationPolicy TerminationPolicyType `json:"terminationPolicy"`

	// List of ShardingSpec which is used to define components with a sharding topology structure that make up a cluster.
	// ShardingSpecs and ComponentSpecs cannot both be empty at the same time.
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=128
	// +optional
	ShardingSpecs []ShardingSpec `json:"shardingSpecs,omitempty"`

	// List of componentSpec which is used to define the components that make up a cluster.
	// ComponentSpecs and ShardingSpecs cannot both be empty at the same time.
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=128
	// +kubebuilder:validation:XValidation:rule="self.all(x, size(self.filter(c, c.name == x.name)) == 1)",message="duplicated component"
	// +optional
	ComponentSpecs []ClusterComponentSpec `json:"componentSpecs,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// services defines the services to access a cluster.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Services []ClusterService `json:"services,omitempty"`

	// affinity is a group of affinity scheduling rules.
	// +optional
	Affinity *Affinity `json:"affinity,omitempty"`

	// tolerations are attached to tolerate any taint that matches the triple `key,value,effect` using the matching operator `operator`.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`

	// tenancy describes how pods are distributed across node.
	// SharedNode means multiple pods may share the same node.
	// DedicatedNode means each pod runs on their own dedicated node.
	// +optional
	Tenancy TenancyType `json:"tenancy,omitempty"`

	// availabilityPolicy describes the availability policy, including zone, node, and none.
	// +optional
	AvailabilityPolicy AvailabilityPolicyType `json:"availabilityPolicy,omitempty"`

	// replicas specifies the replicas of the first componentSpec, if the replicas of the first componentSpec is specified, this value will be ignored.
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// resources specifies the resources of the first componentSpec, if the resources of the first componentSpec is specified, this value will be ignored.
	// +optional
	Resources ClusterResources `json:"resources,omitempty"`

	// storage specifies the storage of the first componentSpec, if the storage of the first componentSpec is specified, this value will be ignored.
	// +optional
	Storage ClusterStorage `json:"storage,omitempty"`

	// monitor specifies the configuration of monitor
	// +optional
	Monitor ClusterMonitor `json:"monitor,omitempty"`

	// network specifies the configuration of network
	// +optional
	Network *ClusterNetwork `json:"network,omitempty"`

	// cluster backup configuration.
	// +optional
	Backup *ClusterBackup `json:"backup,omitempty"`
}

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

	// phase describes the phase of the Cluster, the detail information of the phases are as following:
	//
	// - Creating: all components are in `Creating` phase.
	// - Running: all components are in `Running` phase, means the cluster is working well.
	// - Updating: all components are in `Creating`, `Running` or `Updating` phase,
	//   and at least one component is in `Creating` or `Updating` phase, means the cluster is doing an update.
	// - Stopping: at least one component is in `Stopping` phase, means the cluster is in a stop progress.
	// - Stopped: all components are in `Stopped` phase, means the cluster has stopped and didn't provide any function anymore.
	// - Failed: all components are in `Failed` phase, means the cluster is unavailable.
	// - Abnormal: some components are in `Failed` or `Abnormal` phase, means the cluster in a fragile state. troubleshoot need to be done.
	// - Deleting: the cluster is being deleted.
	//
	// +optional
	Phase ClusterPhase `json:"phase,omitempty"`

	// message describes cluster details message in current phase.
	// +optional
	Message string `json:"message,omitempty"`

	// components record the current status information of all components of the cluster.
	// +optional
	Components map[string]ClusterComponentStatus `json:"components,omitempty"`

	// clusterDefGeneration represents the generation number of ClusterDefinition referenced.
	// +optional
	ClusterDefGeneration int64 `json:"clusterDefGeneration,omitempty"`

	// Describe current state of cluster API Resource, like warning.
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type ClusterStorage struct {

	// storage size needed, more info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	// +optional
	Size resource.Quantity `json:"size,omitempty"`
}

type ClusterSwitchPolicy struct {

	// clusterSwitchPolicy defines type of the switchPolicy when workloadType is Replication.
	//
	// - MaximumAvailability: [WIP] when the primary is active, do switch if the synchronization delay = 0 in the user-defined lagProbe data delay detection logic, otherwise do not switch. The primary is down, switch immediately. It will be available in future versions.
	// - MaximumDataProtection: [WIP] when the primary is active, do switch if synchronization delay = 0 in the user-defined lagProbe data lag detection logic, otherwise do not switch. If the primary is down, if it can be judged that the primary and secondary data are consistent, then do the switch, otherwise do not switch. It will be available in future versions.
	// - Noop: KubeBlocks will not perform high-availability switching on components. Users need to implement HA by themselves or integrate open source HA solution.
	//
	// +kubebuilder:validation:Required
	// +kubebuilder:default=Noop
	// +optional
	Type SwitchPolicyType `json:"type"`
}

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

	Spec   ClusterVersionSpec   `json:"spec,omitempty"`
	Status ClusterVersionStatus `json:"status,omitempty"`
}

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

type ClusterVersionSpec struct {
	// ref ClusterDefinition.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	ClusterDefinitionRef string `json:"clusterDefinitionRef"`

	// List of components' containers versioning context, i.e., container image ID, container commands, args, and environments.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinItems=1
	// +patchMergeKey=componentDefRef
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=componentDefRef
	ComponentVersions []ClusterComponentVersion `json:"componentVersions" patchStrategy:"merge,retainKeys" patchMergeKey:"componentDefRef"`
}

type ClusterVersionStatus struct {
	// phase - in list of [Available,Unavailable]
	// +optional
	Phase Phase `json:"phase,omitempty"`

	// A human readable message indicating details about why the ClusterVersion is in this phase.
	// +optional
	Message string `json:"message,omitempty"`

	// generation number
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// clusterDefGeneration represents the generation number of ClusterDefinition referenced.
	// +optional
	ClusterDefGeneration int64 `json:"clusterDefGeneration,omitempty"`
}

type CmdExecutorConfig struct {
	CommandExecutorEnvItem `json:",inline"`
	CommandExecutorItem    `json:",inline"`
}

type CommandExecutorEnvItem struct {
	// image for Connector when executing the command.
	// +kubebuilder:validation:Required
	Image string `json:"image"`
	// envs is a list of environment variables.
	// +kubebuilder:pruning:PreserveUnknownFields
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +optional
	Env []corev1.EnvVar `json:"env,omitempty" patchStrategy:"merge" patchMergeKey:"name"`
}

type CommandExecutorItem struct {
	// command to perform statements.
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinItems=1
	Command []string `json:"command"`
	// args is used to perform statements.
	// +optional
	Args []string `json:"args,omitempty"`
}

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

	Spec   ComponentSpec   `json:"spec,omitempty"`
	Status ComponentStatus `json:"status,omitempty"`
}

type ComponentClass struct {
	// name is the class name
	// +optional
	Name string `json:"name,omitempty"`

	// args are variable's value
	// +optional
	Args []string `json:"args,omitempty"`

	// the CPU of the class
	// +optional
	CPU resource.Quantity `json:"cpu,omitempty"`

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

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

	Spec   ComponentClassDefinitionSpec   `json:"spec,omitempty"`
	Status ComponentClassDefinitionStatus `json:"status,omitempty"`
}

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

type ComponentClassDefinitionSpec struct {
	// group defines a list of class series that conform to the same constraint.
	// +optional
	Groups []ComponentClassGroup `json:"groups,omitempty"`
}

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

	// classes is the list of classes that have been observed for this ComponentClassDefinition
	Classes []ComponentClass `json:"classes,omitempty"`
}

type ComponentClassGroup struct {
	// template is a class definition template that uses the Go template syntax and allows for variable declaration.
	// When defining a class in Series, specifying the variable's value is sufficient, as the complete class
	// definition will be generated through rendering the template.
	//
	// For example:
	//
	// “`yaml
	// template: |
	//	 cpu: "{{ or .cpu 1 }}"
	//	 memory: "{{ or .memory 4 }}Gi"
	// “`
	//
	// +optional
	Template string `json:"template,omitempty"`

	// vars defines the variables declared in the template and will be used to generating the complete class definition by
	// render the template.
	// +listType=set
	// +optional
	Vars []string `json:"vars,omitempty"`

	// series is a series of class definitions.
	// +optional
	Series []ComponentClassSeries `json:"series,omitempty"`
}

type ComponentClassSeries struct {
	// namingTemplate is a template that uses the Go template syntax and allows for referencing variables defined
	// in ComponentClassGroup.Template. This enables dynamic generation of class names.
	// For example:
	// name: "general-{{ .cpu }}c{{ .memory }}g"
	// +optional
	NamingTemplate string `json:"namingTemplate,omitempty"`

	// classes are definitions of classes that come in two forms. In the first form, only ComponentClass.Args
	// need to be defined, and the complete class definition is generated by rendering the ComponentClassGroup.Template
	// and Name. In the second form, the Name, CPU and Memory must be defined.
	// +optional
	Classes []ComponentClass `json:"classes,omitempty"`
}

type ComponentConfigSpec struct {
	ComponentTemplateSpec `json:",inline"`

	// Specify a list of keys.
	// If empty, ConfigConstraint takes effect for all keys in configmap.
	// +listType=set
	// +optional
	Keys []string `json:"keys,omitempty"`

	// lazyRenderedConfigSpec is optional: specify the secondary rendered config spec.
	// +optional
	LegacyRenderedConfigSpec *LegacyRenderedTemplateSpec `json:"legacyRenderedConfigSpec,omitempty"`

	// Specify the name of the referenced the configuration constraints object.
	// +kubebuilder:validation:MaxLength=63
	// +kubebuilder:validation:Pattern:=`^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$`
	// +optional
	ConfigConstraintRef string `json:"constraintRef,omitempty"`

	// asEnvFrom is optional: the list of containers will be injected into EnvFrom.
	// +listType=set
	// +optional
	AsEnvFrom []string `json:"asEnvFrom,omitempty"`
}

type ComponentDefRef struct {
	// componentDefName is the name of the componentDef to select.
	// +kubebuilder:validation:Required
	ComponentDefName string `json:"componentDefName"`
	// failurePolicy is the failure policy of the component.
	// If failed to find the component, the failure policy will be used.
	// +kubebuilder:validation:Enum={Ignore,Fail}
	// +default="Ignore"
	// +optional
	FailurePolicy FailurePolicyType `json:"failurePolicy,omitempty"`
	// componentRefEnv specifies a list of values to be injected as env variables to each component.
	// +kbubebuilder:validation:Required
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	// +optional
	ComponentRefEnvs []ComponentRefEnv `json:"componentRefEnv" patchStrategy:"merge" patchMergeKey:"name"`
}

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

	Spec   ComponentDefinitionSpec   `json:"spec,omitempty"`
	Status ComponentDefinitionStatus `json:"status,omitempty"`
}

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

type ComponentDefinitionRef struct {

	// Refers to the name of the component definition. This is a required field with a maximum length of 32 characters.
	//
	// +kubebuilder:validation:MaxLength=32
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// Represents the account name of the component.
	// If provided, the account username and password will be injected into the job environment variables `KB_ACCOUNT_USERNAME` and `KB_ACCOUNT_PASSWORD`.
	//
	// +optional
	AccountName string `json:"accountName,omitempty"`

	// References the name of the service.
	// If provided, the service name and ports will be mapped to the job environment variables `KB_COMP_SVC_NAME` and `KB_COMP_SVC_PORT_$(portName)`.
	// Note that the portName will replace the characters '-' with '_' and convert to uppercase.
	//
	// +optional
	ServiceName string `json:"serviceName,omitempty"`

	// Defines the environment variables that need to be referenced from the target component pod and will be injected into the job's containers.
	// If this field is set, the global "varsRef" will be ignored.
	//
	// +optional
	VarsRef *VarsRef `json:"varsRef,omitempty"`
}

type ComponentDefinitionSpec struct {
	// Provider is the name of the component provider.
	// +kubebuilder:validation:MaxLength=32
	// +optional
	Provider string `json:"provider,omitempty"`

	// Description is a brief description of the component.
	// +kubebuilder:validation:MaxLength=256
	// +optional
	Description string `json:"description,omitempty"`

	// ServiceKind defines what kind of well-known service that the component provides (e.g., MySQL, Redis, ETCD, case insensitive).
	// Cannot be updated.
	// +kubebuilder:validation:MaxLength=32
	// +optional
	ServiceKind string `json:"serviceKind,omitempty"`

	// ServiceVersion defines the version of the well-known service that the component provides.
	// Cannot be updated.
	// +kubebuilder:validation:MaxLength=32
	// +optional
	ServiceVersion string `json:"serviceVersion,omitempty"`

	// Runtime defines primarily runtime information for the component, including:
	//
	// - Init containers
	// - Containers
	//     - Image
	//     - Commands
	//     - Args
	//     - Envs
	//     - Mounts
	//     - Ports
	//     - Security context
	//     - Probes
	//     - Lifecycle
	// - Volumes
	//
	// CPU and memory resource limits, as well as scheduling settings (affinity, toleration, priority), should not be configured within this structure.
	// Cannot be updated.
	//
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Required
	Runtime corev1.PodSpec `json:"runtime"`

	// Vars represents user-defined variables.
	//
	// These variables can be utilized as environment variables for Pods and Actions, or to render the templates of config and script.
	// When used as environment variables, these variables are placed in front of the environment variables declared in the Pod.
	// Cannot be updated.
	//
	// +optional
	Vars []EnvVar `json:"vars,omitempty"`

	// Volumes defines the persistent volumes needed by the component.
	// The users are responsible for providing these volumes when creating a component instance.
	// Cannot be updated.
	// +optional
	Volumes []ComponentVolume `json:"volumes"`

	// Services defines endpoints that can be used to access the component service to manage the component.
	//
	// In addition, a reserved headless service will be created by default, with the name pattern `{clusterName}-{componentName}-headless`.
	// Cannot be updated.
	//
	// +optional
	Services []ComponentService `json:"services,omitempty"`

	// The configs field provided by provider, and
	// finally this configTemplateRefs will be rendered into the user's own configuration file according to the user's cluster.
	// Cannot be updated.
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	// +optional
	// TODO: support referencing configs from other components or clusters.
	Configs []ComponentConfigSpec `json:"configs,omitempty"`

	// LogConfigs is detail log file config which provided by provider.
	// Cannot be updated.
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	// +optional
	LogConfigs []LogConfig `json:"logConfigs,omitempty" patchStrategy:"merge,retainKeys" patchMergeKey:"name"`

	// Monitor is monitoring config which provided by provider.
	// Cannot be updated.
	// +optional
	Monitor *MonitorConfig `json:"monitor,omitempty"`

	// The scripts field provided by provider, and
	// finally this configTemplateRefs will be rendered into the user's own configuration file according to the user's cluster.
	// Cannot be updated.
	// +patchMergeKey=name
	// +patchStrategy=merge,retainKeys
	// +listType=map
	// +listMapKey=name
	// +optional
	Scripts []ComponentTemplateSpec `json:"scripts,omitempty"`

	// PolicyRules defines the namespaced policy rules required by the component.
	// If any rule application fails (e.g., due to lack of permissions), the provisioning of the component instance will also fail.
	// Cannot be updated.
	// +optional
	PolicyRules []rbacv1.PolicyRule `json:"policyRules,omitempty"`

	// Labels defines static labels that will be patched to all k8s resources created for the component.
	// If a label key conflicts with any other system labels or user-specified labels, it will be silently ignored.
	// Cannot be updated.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// ReplicasLimit defines the limit of valid replicas supported.
	// Cannot be updated.
	// +optional
	ReplicasLimit *ReplicasLimit `json:"replicasLimit,omitempty"`

	// SystemAccounts defines the pre-defined system accounts required to manage the component.
	// TODO(component): accounts KB required
	// Cannot be updated.
	// +optional
	SystemAccounts []SystemAccount `json:"systemAccounts,omitempty"`

	// UpdateStrategy defines the strategy for updating the component instance.
	// Cannot be updated.
	// +kubebuilder:default=Serial
	// +optional
	UpdateStrategy *UpdateStrategy `json:"updateStrategy,omitempty"`

	// Roles defines all the roles that the component can assume.
	// Cannot be updated.
	// +optional
	Roles []ReplicaRole `json:"roles,omitempty"`

	// RoleArbitrator defines the strategy for electing the component's active role.
	// Cannot be updated.
	// +kubebuilder:default=External
	// +optional
	RoleArbitrator *RoleArbitrator `json:"roleArbitrator,omitempty"`

	// LifecycleActions defines the operational actions that needed to interoperate with the component
	// service and processes for lifecycle management.
	// Cannot be updated.
	// +optional
	LifecycleActions *ComponentLifecycleActions `json:"lifecycleActions,omitempty"`

	// ServiceRefDeclarations is used to declare the service reference of the current component.
	// Cannot be updated.
	// +optional
	ServiceRefDeclarations []ServiceRefDeclaration `json:"serviceRefDeclarations,omitempty"`
}

type ComponentDefinitionStatus struct {
	// ObservedGeneration is the most recent generation observed for this ComponentDefinition.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Phase valid values are “, `Available`, `Unavailable`.
	// Available is ComponentDefinition become available, and can be used for co-related objects.
	// +optional
	Phase Phase `json:"phase,omitempty"`

	// Extra message for current phase.
	// +optional
	Message string `json:"message,omitempty"`
}

type ComponentLifecycleActions struct {
	// PostProvision defines the actions to be executed and the corresponding policy when a component is created.
	// You can define the preCondition for executing PostProvision using Action.PreCondition. The default PostProvision action preCondition is ComponentReady.
	// The PostProvision Action will be executed only once.
	// Dedicated env vars for the action:
	//
	// - KB_CLUSTER_COMPONENT_LIST: The list of all components in the cluster, joined by ',' (e.g., "comp1,comp2").
	// - KB_CLUSTER_COMPONENT_POD_NAME_LIST: The list of all pods name in this component, joined by ',' (e.g., "pod1,pod2").
	// - KB_CLUSTER_COMPONENT_POD_IP_LIST: The list of pod IPs where each pod resides in this component, corresponding one-to-one with each pod in the KB_CLUSTER_COMPONENT_POD_NAME_LIST. joined by ',' (e.g., "podIp1,podIp2").
	// - KB_CLUSTER_COMPONENT_POD_HOST_NAME_LIST: The list of hostName where each pod resides in this component, corresponding one-to-one with each pod in the KB_CLUSTER_COMPONENT_POD_NAME_LIST. joined by ',' (e.g., "hostName1,hostName2").
	// - KB_CLUSTER_COMPONENT_POD_HOST_IP_LIST: The list of host IPs where each pod resides in this component, corresponding one-to-one with each pod in the KB_CLUSTER_COMPONENT_POD_NAME_LIST. joined by ',' (e.g., "hostIp1,hostIp2").
	//
	// Cannot be updated.
	//
	// +optional
	PostProvision *LifecycleActionHandler `json:"postProvision,omitempty"`

	// PreTerminate defines the actions to be executed when a component is terminated due to an API request.
	// The PreTerminate Action will be executed only once. Upon receiving a scale-down command for the Component, it is executed immediately.
	// Only after the preTerminate action is successfully executed, the destruction of the Component and its underlying resources proceeds.
	// Cannot be updated.
	// +optional
	PreTerminate *LifecycleActionHandler `json:"preTerminate,omitempty"`

	// RoleProbe defines the mechanism to probe the role of replicas periodically. The specified action will be
	// executed by Lorry at the configured interval. If the execution is successful, the output will be used as
	// the replica's assigned role, and the role must be one of the names defined in the componentdefinition roles.
	// The output will be compared with the last successful result.  If there is a change, a role change event will
	// be created to notify the controller and trigger updating the replica's role.
	// Defining a RoleProbe is required if roles are configured for the component. Otherwise, the replicas' pods will
	// lack role information after the cluster is created, and services will not route to the replica correctly.
	//
	// The following dedicated environment variables are available for the action:
	//
	// - KB_POD_FQDN: The pod FQDN of the replica to check the role.
	// - KB_SERVICE_PORT: The port on which the DB service listens.
	// - KB_SERVICE_USER: The username used to access the DB service and retrieve the role information with sufficient privileges.
	// - KB_SERVICE_PASSWORD: The password of the user used to access the DB service and retrieve the role information.
	//
	// Output of the action:
	// - ROLE: the role of the replica. It must be one of the names defined in the roles.
	// - ERROR: Any error message if the action fails.
	//
	// This field cannot be updated.
	//
	// +optional
	RoleProbe *RoleProbe `json:"roleProbe,omitempty"`

	// Switchover defines how to proactively switch the current leader to a new replica to minimize the impact on availability.
	// This action is typically invoked when the leader is about to become unavailable due to events, such as:
	//
	// - switchover
	// - stop
	// - restart
	// - scale-in
	//
	// Dedicated env vars for the action:
	//
	// - KB_SWITCHOVER_CANDIDATE_NAME: The name of the new candidate replica's Pod. It may be empty.
	// - KB_SWITCHOVER_CANDIDATE_FQDN: The FQDN of the new candidate replica. It may be empty.
	// - KB_LEADER_POD_IP: The IP address of the original leader's Pod before switchover.
	// - KB_LEADER_POD_NAME: The name of the original leader's Pod before switchover.
	// - KB_LEADER_POD_FQDN: The FQDN of the original leader's Pod before switchover.
	//
	// The env vars with following prefix are deprecated and will be removed in the future:
	//
	// - KB_REPLICATION_PRIMARY_POD_: The prefix of the environment variables of the original primary's Pod before switchover.
	// - KB_CONSENSUS_LEADER_POD_: The prefix of the environment variables of the original leader's Pod before switchover.
	//
	// Cannot be updated.
	//
	// +optional
	Switchover *ComponentSwitchover `json:"switchover,omitempty"`

	// MemberJoin defines how to add a new replica to the replication group.
	// This action is typically invoked when a new replica needs to be added, such as during scale-out.
	// The function does not specify or constrain the role of the new member. The role assignment
	// is handled by the scripts implemented in the action commands. This provides flexibility
	// as the new member can be automatically scaled and assigned a role based on the cluster's needs.
	//
	// The following dedicated environment variables are available for the action:
	//
	// - KB_SERVICE_PORT: The port on which the DB service listens.
	// - KB_SERVICE_USER: The username used to access the DB service with sufficient privileges.
	// - KB_SERVICE_PASSWORD: The password of the user used to access the DB service .
	// - KB_PRIMARY_POD_FQDN: The FQDN of the original primary Pod.
	// - KB_MEMBER_ADDRESSES: The addresses of all members.
	// - KB_NEW_MEMBER_POD_NAME: The name of the new member's Pod.
	// - KB_NEW_MEMBER_POD_IP: The name of the new member's Pod.
	//
	// Output of the action:
	// - ERROR: Any error message if the action fails.
	//
	// For example, the following command can be used to add a new OBServer to the OceanBase Cluster in zone1:
	// command:
	// - bash
	// - -c
	// - |
	//    ADDRESS=$(KB_MEMBER_ADDRESSES%%,*)
	//    HOST=$(echo $ADDRESS | cut -d ':' -f 1)
	//    PORT=$(echo $ADDRESS | cut -d ':' -f 2)
	//    CLIENT="mysql -u $KB_SERVICE_USER -p$KB_SERVICE_PASSWORD -P $PORT -h $HOST -e"
	// 	  $CLIENT "ALTER SYSTEM ADD SERVER '$KB_NEW_MEMBER_POD_IP:$KB_SERVICE_PORT' ZONE 'zone1'"
	//
	// This field cannot be updated.
	//
	// +optional
	MemberJoin *LifecycleActionHandler `json:"memberJoin,omitempty"`

	// MemberLeave defines how to remove a replica from the replication group.
	// This action is typically invoked when a replica needs to be removed, such as during scale-in.
	// It may involve configuration updates and notifying other members about the departure,
	// but it is advisable to avoid performing data migration within this action.
	//
	// The following dedicated environment variables are available for the action:
	//
	// - KB_SERVICE_PORT: The port on which the DB service listens.
	// - KB_SERVICE_USER: The username used to access the DB service with sufficient privileges.
	// - KB_SERVICE_PASSWORD: The password of the user used to access the DB service.
	// - KB_PRIMARY_POD_FQDN: The FQDN of the original primary Pod.
	// - KB_MEMBER_ADDRESSES: The addresses of all members.
	// - KB_LEAVE_MEMBER_POD_NAME: The name of the leave member's Pod.
	// - KB_LEAVE_MEMBER_POD_IP: The IP of the leave member's Pod.
	//
	// Output of the action:
	// - ERROR: Any error message if the action fails.
	//
	// For example, the following command can be used to delete a OBServer from the OceanBase Cluster in zone1:
	// command:
	// - bash
	// - -c
	// - |
	//    ADDRESS=$(KB_MEMBER_ADDRESSES%%,*)
	//    HOST=$(echo $ADDRESS | cut -d ':' -f 1)
	//    PORT=$(echo $ADDRESS | cut -d ':' -f 2)
	//    CLIENT="mysql -u $KB_SERVICE_USER  -p$KB_SERVICE_PASSWORD -P $PORT -h $HOST -e"
	// 	  $CLIENT "ALTER SYSTEM DELETE SERVER '$KB_NEW_MEMBER_POD_IP:$KB_SERVICE_PORT' ZONE 'zone1'"
	//
	// This field cannot be updated.
	//
	// +optional
	MemberLeave *LifecycleActionHandler `json:"memberLeave,omitempty"`

	// Readonly defines how to set a replica service as read-only.
	// This action is used to protect a replica in case of volume space exhaustion or excessive traffic.
	//
	// The following dedicated environment variables are available for the action:
	//
	// - KB_POD_FQDN: The FQDN of the replica pod to check the role.
	// - KB_SERVICE_PORT: The port on which the DB service listens.
	// - KB_SERVICE_USER: The username used to access the DB service with sufficient privileges.
	// - KB_SERVICE_PASSWORD: The password of the user used to access the DB service.
	//
	// Output of the action:
	// - ERROR: Any error message if the action fails.
	//
	// This field cannot be updated.
	//
	// +optional
	Readonly *LifecycleActionHandler `json:"readonly,omitempty"`

	// Readwrite defines how to set a replica service as read-write.
	//
	// The following dedicated environment variables are available for the action:
	//
	// - KB_POD_FQDN: The FQDN of the replica pod to check the role.
	// - KB_SERVICE_PORT: The port on which the DB service listens.
	// - KB_SERVICE_USER: The username used to access the DB service with sufficient privileges.
	// - KB_SERVICE_PASSWORD: The password of the user used to access the DB service.
	//
	// Output of the action:
	// - ERROR: Any error message if the action fails.
	//
	// This field cannot be updated.
	//
	// +optional
	Readwrite *LifecycleActionHandler `json:"readwrite,omitempty"`

	// DataPopulate defines how to populate the data to create new replicas.
	// This action is typically used when a new replica needs to be constructed, such as:
	//
	// - scale-out
	// - rebuild
	// - clone
	//
	// It should write the valid data to stdout without including any extraneous information.
	// Cannot be updated.
	//
	// +optional
	DataPopulate *LifecycleActionHandler `json:"dataPopulate,omitempty"`

	// DataAssemble defines how to assemble data synchronized from external before starting the service for a new replica.
	// This action is typically used when creating a new replica, such as:
	//
	//  - scale-out
	//  - rebuild
	//  - clone
	//
	// The data will be streamed in via stdin. If any error occurs during the assembly process,
	// the action must be able to guarantee idempotence to allow for retries from the beginning.
	// Cannot be updated.
	//
	// +optional
	DataAssemble *LifecycleActionHandler `json:"dataAssemble,omitempty"`

	// Reconfigure defines how to notify the replica service that there is a configuration update.
	// Cannot be updated.
	// +optional
	Reconfigure *LifecycleActionHandler `json:"reconfigure,omitempty"`

	// AccountProvision defines how to provision accounts.
	// Cannot be updated.
	// +optional
	AccountProvision *LifecycleActionHandler `json:"accountProvision,omitempty"`
}

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